chrono-node 2.9.1 → 2.9.2

package/src/locales/de/parsers/DECasualTimeParser.ts

@@ -24,6 +24,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "vormittag":
@@ -31,6 +32,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "mittag":
@@ -39,6 +41,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/noon");
                 break;
 
             case "nachmittag":
@@ -46,6 +49,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "abend":
@@ -53,6 +57,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "nacht":
@@ -60,6 +65,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "mitternacht":
@@ -71,6 +77,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/midnight");
                 break;
         }
         return component;

package/src/locales/en/configuration.ts

@@ -5,6 +5,7 @@ import ENMonthNameLittleEndianParser from "./parsers/ENMonthNameLittleEndianPars
 import ENMonthNameMiddleEndianParser from "./parsers/ENMonthNameMiddleEndianParser";
 import ENMonthNameParser from "./parsers/ENMonthNameParser";
 import ENYearMonthDayParser from "./parsers/ENYearMonthDayParser";
+import ENYearMonthNameParser from "./parsers/ENYearMonthNameParser";
 import ENSlashMonthFormatParser from "./parsers/ENSlashMonthFormatParser";
 import ENTimeExpressionParser from "./parsers/ENTimeExpressionParser";
 import ENTimeUnitAgoFormatParser from "./parsers/ENTimeUnitAgoFormatParser";
@@ -61,6 +62,7 @@ export default class ENDefaultConfiguration {
                     new ENTimeExpressionParser(strictMode),
                     new ENTimeUnitAgoFormatParser(strictMode),
                     new ENTimeUnitLaterFormatParser(strictMode),
+                    new ENYearMonthNameParser(),
                 ],
                 refiners: [new ENMergeDateTimeRefiner()],
             },

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

@@ -12,7 +12,7 @@ const PATTERN = new RegExp(
     `(?:on\\s{0,3})?` +
         `(${ORDINAL_NUMBER_PATTERN})` +
         `(?:` +
-            `\\s{0,3}(?:to|\\-|\\–|until|through|till)?\\s{0,3}` +
+            `\\s{0,3}(?:to|\\-|\\–|until|through|till)\\s{0,3}` +
             `(${ORDINAL_NUMBER_PATTERN})` +
         ")?" +
         `(?:-|/|\\s{0,3}(?:of)?\\s{0,3})` +

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

@@ -0,0 +1,38 @@
+import { MONTH_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3})`;
+
+const PATTERN = new RegExp(
+    `(${YEAR_PATTERN})` +
+        `(?:\\s*[-.\\/,]?\\s*|\\s+of\\s+)` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
+    "i"
+);
+
+const YEAR_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+
+export default class ENYearMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const year = parseYear(match[YEAR_GROUP]);
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+        const month = MONTH_DICTIONARY[monthName];
+
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.imply("day", 1);
+        result.start.assign("month", month);
+        result.start.assign("year", year);
+        result.start.addTag("parser/ENYearMonthNameParser");
+
+        return result;
+    }
+}

package/src/locales/fi/parsers/FICasualTimeParser.ts

@@ -25,6 +25,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "aamupäivällä":
@@ -32,6 +33,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "päivällä":
@@ -39,6 +41,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/noon");
                 break;
 
             case "iltapäivällä":
@@ -46,6 +49,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "illalla":
@@ -53,6 +57,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "yöllä":
@@ -60,6 +65,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "keskiyöllä":
@@ -71,6 +77,7 @@ export default class FICasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/midnight");
                 break;
         }
         return component;

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

@@ -18,29 +18,34 @@ export default class FRCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("hour", 14);
                 component.imply("minute", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "soir":
                 component.imply("hour", 18);
                 component.imply("minute", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "matin":
                 component.imply("hour", 8);
                 component.imply("minute", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "a midi":
                 component.imply("hour", 12);
                 component.imply("minute", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/noon");
                 break;
 
             case "à minuit":
                 component.imply("hour", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/midnight");
                 break;
         }
 

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

@@ -16,7 +16,8 @@ export default class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBou
                 `(${NUMBER_PATTERN})?` +
                 `(?:\\s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))?` +
                 `\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})` +
-                `(?:\\s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))?`,
+                `(?:\\s*(prochaine?s?|derni[eè]re?s?|pass[ée]e?s?|pr[ée]c[ée]dents?|suivante?s?))?` +
+                `(?=\\W|$)`,
             "i"
         );
     }

package/src/locales/it/parsers/ITCasualTimeParser.ts

@@ -18,12 +18,14 @@ export default class ITCasualTimeParser extends AbstractParserWithWordBoundaryCh
             case "pomeriggio":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 15);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "sera":
             case "notte":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 20);
+                component.addTag("casualReference/evening");
                 break;
 
             case "mezzanotte":
@@ -34,16 +36,19 @@ export default class ITCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);
+                component.addTag("casualReference/midnight");
                 break;
 
             case "mattina":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 6);
+                component.addTag("casualReference/morning");
                 break;
 
             case "mezzogiorno":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 12);
+                component.addTag("casualReference/noon");
                 break;
         }
 

package/src/locales/uk/parsers/UKTimeUnitWithinFormatParser.ts

@@ -12,7 +12,7 @@ export default class UKTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerPattern(context: ParsingContext): RegExp {
         return context.option.forwardDate
-            ? new RegExp(PATTERN, "i")
+            ? new RegExp(PATTERN, REGEX_PARTS.flags)
             : new RegExp(`(?:протягом|на протязі|протягом|упродовж|впродовж)\\s*${PATTERN}`, REGEX_PARTS.flags);
     }
 

package/src/locales/zh/hans/index.ts

@@ -10,6 +10,7 @@ import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
 import ZHHansDateParser from "./parsers/ZHHansDateParser";
 import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
+import ZHHansAgoFormatParser from "./parsers/ZHHansAgoFormatParser";
 import ZHHansRelationWeekdayParser from "./parsers/ZHHansRelationWeekdayParser";
 import ZHHansTimeExpressionParser from "./parsers/ZHHansTimeExpressionParser";
 import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
@@ -53,6 +54,7 @@ export function createConfiguration(): Configuration {
             new ZHHansWeekdayParser(),
             new ZHHansTimeExpressionParser(),
             new ZHHansDeadlineFormatParser(),
+            new ZHHansAgoFormatParser(),
         ],
         refiners: [new ZHHansMergeDateRangeRefiner(), new ZHHansMergeDateTimeRefiner()],
     });

package/src/locales/zh/hans/parsers/ZHHansAgoFormatParser.ts

@@ -0,0 +1,87 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { addDuration, Duration, reverseDuration } from "../../../../calculation/duration";
+import { NUMBER, zhStringToNumber } from "../constants";
+
+const PATTERN = new RegExp(
+    "(\\d+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+|半|几)(?:\\s*)" +
+        "(?:个)?" +
+        "(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)" +
+        "(?:之)?前",
+    "i"
+);
+
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+
+export default class ZHHansAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = zhStringToNumber(match[NUMBER_GROUP]);
+        }
+
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "几") {
+                number = 3;
+            } else if (string === "半") {
+                number = 0.5;
+            } else {
+                //just in case
+                return null;
+            }
+        }
+
+        let duration: Duration = {};
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+
+        if (unitAbbr.match(/[日天星礼月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                duration.day = number;
+            } else if (unitAbbr == "星" || unitAbbr == "礼") {
+                duration.week = number;
+            } else if (unitAbbr == "月") {
+                duration.month = number;
+            } else if (unitAbbr == "年") {
+                duration.year = number;
+            }
+
+            duration = reverseDuration(duration);
+
+            const date = addDuration(context.refDate, duration);
+            result.start.assign("year", date.getFullYear());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("day", date.getDate());
+            return result;
+        }
+
+        if (unitAbbr == "秒") {
+            duration.second = number;
+        } else if (unitAbbr == "分") {
+            duration.minute = number;
+        } else if (unitAbbr == "小" || unitAbbr == "钟") {
+            duration.hour = number;
+        }
+
+        duration = reverseDuration(duration);
+
+        const date = addDuration(context.refDate, duration);
+        result.start.imply("year", date.getFullYear());
+        result.start.imply("month", date.getMonth() + 1);
+        result.start.imply("day", date.getDate());
+        result.start.assign("hour", date.getHours());
+        result.start.assign("minute", date.getMinutes());
+        result.start.assign("second", date.getSeconds());
+        return result;
+    }
+}

package/src/locales/zh/hant/index.ts

@@ -11,6 +11,7 @@ import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 import ZHHantCasualDateParser from "./parsers/ZHHantCasualDateParser";
 import ZHHantDateParser from "./parsers/ZHHantDateParser";
 import ZHHantDeadlineFormatParser from "./parsers/ZHHantDeadlineFormatParser";
+import ZHHantAgoFormatParser from "./parsers/ZHHantAgoFormatParser";
 import ZHHantRelationWeekdayParser from "./parsers/ZHHantRelationWeekdayParser";
 import ZHHantTimeExpressionParser from "./parsers/ZHHantTimeExpressionParser";
 import ZHHantWeekdayParser from "./parsers/ZHHantWeekdayParser";
@@ -54,6 +55,7 @@ export function createConfiguration(): Configuration {
             new ZHHantWeekdayParser(),
             new ZHHantTimeExpressionParser(),
             new ZHHantDeadlineFormatParser(),
+            new ZHHantAgoFormatParser(),
         ],
         refiners: [new ZHHantMergeDateRangeRefiner(), new ZHHantMergeDateTimeRefiner()],
     });

package/src/locales/zh/hant/parsers/ZHHantAgoFormatParser.ts

@@ -0,0 +1,87 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { addDuration, Duration, reverseDuration } from "../../../../calculation/duration";
+import { NUMBER, zhStringToNumber } from "../constants";
+
+const PATTERN = new RegExp(
+    "(\\d+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+|半|幾)(?:\\s*)" +
+        "(?:個)?" +
+        "(秒(?:鐘)?|分鐘|小時|鐘|日|天|星期|禮拜|月|年)" +
+        "(?:之)?前",
+    "i"
+);
+
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+
+export default class ZHHantAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = zhStringToNumber(match[NUMBER_GROUP]);
+        }
+
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "幾") {
+                number = 3;
+            } else if (string === "半") {
+                number = 0.5;
+            } else {
+                //just in case
+                return null;
+            }
+        }
+
+        let duration: Duration = {};
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+
+        if (unitAbbr.match(/[日天星禮月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                duration.day = number;
+            } else if (unitAbbr == "星" || unitAbbr == "禮") {
+                duration.week = number;
+            } else if (unitAbbr == "月") {
+                duration.month = number;
+            } else if (unitAbbr == "年") {
+                duration.year = number;
+            }
+
+            duration = reverseDuration(duration);
+
+            const date = addDuration(context.refDate, duration);
+            result.start.assign("year", date.getFullYear());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("day", date.getDate());
+            return result;
+        }
+
+        if (unitAbbr == "秒") {
+            duration.second = number;
+        } else if (unitAbbr == "分") {
+            duration.minute = number;
+        } else if (unitAbbr == "小" || unitAbbr == "鐘") {
+            duration.hour = number;
+        }
+
+        duration = reverseDuration(duration);
+
+        const date = addDuration(context.refDate, duration);
+        result.start.imply("year", date.getFullYear());
+        result.start.imply("month", date.getMonth() + 1);
+        result.start.imply("day", date.getDate());
+        result.start.assign("hour", date.getHours());
+        result.start.assign("minute", date.getMinutes());
+        result.start.assign("second", date.getSeconds());
+        return result;
+    }
+}

package/test/de/de_casual.test.ts

@@ -320,3 +320,17 @@ test("Test - Random negative text", function () {
 
     testUnexpectedResult(chrono.de, "ljetztlich");
 });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.de, "nachmittag um 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.de, "abend um 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});

package/test/en/en_month.test.ts

@@ -293,3 +293,47 @@ test("Test - Month only in different context", () => {
     testUnexpectedResult(chrono.casual, "The mountain may not move");
     testUnexpectedResult(chrono.casual, "May not be correct");
 });
+
+test("Test - Year Month expression", () => {
+    testSingleCase(chrono, "2024 Aug", (result) => {
+        expect(result.text).toBe("2024 Aug");
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("day")).toBe(false);
+    });
+
+    testSingleCase(chrono, "2024 August", (result) => {
+        expect(result.text).toBe("2024 August");
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(1);
+    });
+
+    testSingleCase(chrono, "2023 Sept", (result) => {
+        expect(result.text).toBe("2023 Sept");
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+    });
+
+    testSingleCase(chrono, "2024-August", (result) => {
+        expect(result.text).toBe("2024-August");
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(8);
+    });
+
+    testSingleCase(chrono, "2024/August", (result) => {
+        expect(result.text).toBe("2024/August");
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(8);
+    });
+
+    testSingleCase(chrono, "2024 AD August", (result) => {
+        expect(result.text).toBe("2024 AD August");
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(8);
+    });
+});

package/test/fi/fi_casual.test.ts

@@ -83,3 +83,17 @@ test("Test - Combined Expression", function () {
         expect(result.start.get("hour")).toBe(0);
     });
 });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono, "iltapäivällä klo 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono, "illalla klo 8", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});

package/test/fr/fr_casual.test.ts

@@ -298,3 +298,17 @@ test("Test - Combined Expression", function () {
 //     expect(results.length).toBe(0);
 //
 // });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.fr, "après-midi à 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.fr, "soir à 8", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});

package/test/fr/fr_time_units_casual_relative.test.ts

@@ -106,3 +106,9 @@ test("Test - fr - relative date", function () {
         expect(result.start.isCertain("second")).toBeFalsy();
     });
 });
+
+test("Test - fr - false positive prevention for single-letter time units", function () {
+    // Test that "la derniere h" in "la derniere homme" doesn't match as "la derniere h" (last hour)
+    // The word boundary check should prevent "h" from matching the time unit "h"
+    testUnexpectedResult(chrono.fr, "la derniere homme");
+});

package/test/it/it_casual.test.ts

@@ -42,3 +42,40 @@ test("Test - Single Expression", () => {
         expect(result.start).toBeDate(new Date(2012, 7, 11, 17, 10));
     });
 });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.it, "pomeriggio alle 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.it, "sera alle 8", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});
+
+test("Test - Casual time midnight and noon", () => {
+    testSingleCase(chrono.it.casual, "La scadenza è mezzanotte", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(13);
+        expect(result.text).toBe(" mezzanotte");
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+    });
+
+    testSingleCase(chrono.it.casual, "La scadenza è mezzogiorno", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(13);
+        expect(result.text).toBe(" mezzogiorno");
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("meridiem")).toBe(0);
+    });
+});

package/test/uk/uk_time_units_within.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
 
 test("Test - The normal within expression", () => {
     testSingleCase(chrono.uk, "буде зроблено протягом хвилини", new Date(2012, 7, 10), (result) => {
@@ -14,3 +14,10 @@ test("Test - The normal within expression", () => {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 2));
     });
 });
+
+test("Test - Within expression respects the word boundary", () => {
+    // The forwardDate branch builds a bare time-unit pattern whose right boundary uses the
+    // \p{L}\p{N} escapes, so a unit glued to a following letter must not match. "годин" (hours)
+    // is a prefix of "годинників" (watches), so this sentence must not parse as "5 hours".
+    testUnexpectedResult(chrono.uk, "купив 5 годинників", new Date(2012, 7, 10), { forwardDate: true });
+});