chrono-node 2.7.4 → 2.7.6

package/dist/esm/utils/pattern.d.ts

@@ -1,7 +1,7 @@
 declare type DictionaryLike = string[] | {
     [word: string]: unknown;
 } | Map<string, unknown>;
-export declare function repeatedTimeunitPattern(prefix: string, singleTimeunitPattern: string): string;
+export declare function repeatedTimeunitPattern(prefix: string, singleTimeunitPattern: string, connectorPattern?: string): string;
 export declare function extractTerms(dictionary: DictionaryLike): string[];
 export declare function matchAnyPattern(dictionary: DictionaryLike): string;
 export {};

package/dist/esm/utils/pattern.js

@@ -1,6 +1,6 @@
-export function repeatedTimeunitPattern(prefix, singleTimeunitPattern) {
+export function repeatedTimeunitPattern(prefix, singleTimeunitPattern, connectorPattern = "\\s{0,5},?\\s{0,5}") {
     const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\((?!\?)/g, "(?:");
-    return `${prefix}${singleTimeunitPatternNoCapture}\\s{0,5}(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
+    return `${prefix}${singleTimeunitPatternNoCapture}(?:${connectorPattern}${singleTimeunitPatternNoCapture}){0,10}`;
 }
 export function extractTerms(dictionary) {
     let keys;

package/dist/esm/utils/pattern.js.map

@@ -1 +1 @@
-{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../../src/utils/pattern.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,uBAAuB,CAAC,MAAc,EAAE,qBAA6B;IACjF,MAAM,8BAA8B,GAAG,qBAAqB,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACzF,OAAO,GAAG,MAAM,GAAG,8BAA8B,wBAAwB,8BAA8B,SAAS,CAAC;AACrH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,UAA0B;IACnD,IAAI,IAAc,CAAC;IACnB,IAAI,UAAU,YAAY,KAAK,EAAE;QAC7B,IAAI,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;KAC1B;SAAM,IAAI,UAAU,YAAY,GAAG,EAAE;QAClC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAE,UAAmC,CAAC,IAAI,EAAE,CAAC,CAAC;KAClE;SAAM;QACH,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;KAClC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,UAA0B;IAGtD,MAAM,WAAW,GAAG,YAAY,CAAC,UAAU,CAAC;SACvC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;SACnC,IAAI,CAAC,GAAG,CAAC;SACT,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAE3B,OAAO,MAAM,WAAW,GAAG,CAAC;AAChC,CAAC"}
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../../../src/utils/pattern.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,uBAAuB,CACnC,MAAc,EACd,qBAA6B,EAC7B,gBAAgB,GAAG,oBAAoB;IAEvC,MAAM,8BAA8B,GAAG,qBAAqB,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACzF,OAAO,GAAG,MAAM,GAAG,8BAA8B,MAAM,gBAAgB,GAAG,8BAA8B,SAAS,CAAC;AACtH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,UAA0B;IACnD,IAAI,IAAc,CAAC;IACnB,IAAI,UAAU,YAAY,KAAK,EAAE;QAC7B,IAAI,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC;KAC1B;SAAM,IAAI,UAAU,YAAY,GAAG,EAAE;QAClC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAE,UAAmC,CAAC,IAAI,EAAE,CAAC,CAAC;KAClE;SAAM;QACH,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;KAClC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,UAA0B;IAGtD,MAAM,WAAW,GAAG,YAAY,CAAC,UAAU,CAAC;SACvC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;SACnC,IAAI,CAAC,GAAG,CAAC;SACT,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAE3B,OAAO,MAAM,WAAW,GAAG,CAAC;AAChC,CAAC"}

package/package.json

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

package/src/common/parsers/AbstractTimeExpressionParser.ts

@@ -80,6 +80,13 @@ export abstract class AbstractTimeExpressionParser implements Parser {
     extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
         const startComponents = this.extractPrimaryTimeComponents(context, match);
         if (!startComponents) {
+            // If the match seem like a year e.g. "2013.12:...",
+            // then skips the year part and try matching again.
+            if (match[0].match(/^\d{4}/)) {
+                match.index += 4; // Skip over potential overlapping pattern
+                return null;
+            }
+
             match.index += match[0].length; // Skip over potential overlapping pattern
             return null;
         }
@@ -94,8 +101,15 @@ export abstract class AbstractTimeExpressionParser implements Parser {
         const followingMatch = followingPattern.exec(remainingText);
 
         // Pattern "456-12", "2022-12" should not be time without proper context
-        if (text.match(/^\d{3,4}/) && followingMatch && followingMatch[0].match(/^\s*([+-])\s*\d{2,4}$/)) {
-            return null;
+        if (text.match(/^\d{3,4}/) && followingMatch) {
+            // e.g. "2022-12"
+            if (followingMatch[0].match(/^\s*([+-])\s*\d{2,4}$/)) {
+                return null;
+            }
+            // e.g. "2022-12:01..."
+            if (followingMatch[0].match(/^\s*([+-])\s*\d{2}\W\d{2}/)) {
+                return null;
+            }
         }
 
         if (

package/src/index.ts

@@ -39,6 +39,6 @@ export function parse(text: string, ref?: ParsingReference | Date, option?: Pars
 /**
  * A shortcut for {@link en | chrono.en.casual.parseDate()}
  */
-export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date | null {
     return casual.parseDate(text, ref, option);
 }

package/src/locales/de/index.ts

@@ -22,11 +22,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/en/constants.ts

@@ -264,10 +264,17 @@ const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAny
     TIME_UNIT_DICTIONARY_NO_ABBR
 )})`;
 
-export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+const TIME_UNIT_CONNECTOR_PATTERN = `\\s{0,5},?(?:\\s*and)?\\s{0,5}`;
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(
+    `(?:(?:about|around)\\s{0,3})?`,
+    SINGLE_TIME_UNIT_PATTERN,
+    TIME_UNIT_CONNECTOR_PATTERN
+);
 export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
     `(?:(?:about|around)\\s{0,3})?`,
-    SINGLE_TIME_UNIT_NO_ABBR_PATTERN
+    SINGLE_TIME_UNIT_NO_ABBR_PATTERN,
+    TIME_UNIT_CONNECTOR_PATTERN
 );
 
 export function parseTimeUnits(timeunitText): TimeUnits {

package/src/locales/en/index.ts

@@ -33,13 +33,13 @@ export const GB = new Chrono(configuration.createCasualConfiguration(true));
 /**
  * A shortcut for en.casual.parse()
  */
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
 /**
  * A shortcut for en.casual.parseDate()
  */
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }

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/ENMonthNameMiddleEndianParser.ts

@@ -6,17 +6,18 @@ import { YEAR_PATTERN, parseYear } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
+// prettier-ignore
 const PATTERN = new RegExp(
     `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         "(?:-|/|\\s*,?\\s*)" +
         `(${ORDINAL_NUMBER_PATTERN})(?!\\s*(?:am|pm))\\s*` +
         "(?:" +
-        "(?:to|\\-)\\s*" +
-        `(${ORDINAL_NUMBER_PATTERN})\\s*` +
+            "(?:to|\\-)\\s*" +
+            `(${ORDINAL_NUMBER_PATTERN})\\s*` +
         ")?" +
         "(?:" +
-        "(?:-|/|\\s*,?\\s*)" +
-        `(${YEAR_PATTERN})` +
+            `(?:-|/|\\s*,\\s*|\\s+)` +
+            `(${YEAR_PATTERN})` +
         ")?" +
         "(?=\\W|$)(?!\\:\\d)",
     "i"

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

@@ -8,10 +8,7 @@ const PATTERN = new RegExp(
     "i"
 );
 
-const STRICT_PATTERN = new RegExp(
-    "" + "(" + TIME_UNITS_NO_ABBR_PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))",
-    "i"
-);
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(later|after|from now)(?=\\W|$)`, "i");
 const GROUP_NUM_TIMEUNITS = 1;
 
 export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {

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/es/index.ts

@@ -25,11 +25,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/fr/index.ts

@@ -28,11 +28,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/ja/index.ts

@@ -19,11 +19,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration());
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/nl/index.ts

@@ -33,11 +33,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/pt/index.ts

@@ -24,11 +24,11 @@ export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/ru/index.ts

@@ -40,14 +40,14 @@ export const strict = new Chrono(createConfiguration(true));
 /**
  * A shortcut for ru.casual.parse()
  */
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
 /**
  * A shortcut for ru.casual.parseDate()
  */
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

package/src/locales/uk/index.ts

@@ -78,13 +78,13 @@ export function createConfiguration(strictMode: boolean): Configuration {
 /**
  * A shortcut for uk.casual.parse()
  */
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
 /**
  * A shortcut for uk.casual.parseDate()
  */
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }

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

@@ -25,11 +25,11 @@ export const hans = new Chrono(createCasualConfiguration());
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration());
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

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

@@ -26,11 +26,11 @@ export const hant = new Chrono(createCasualConfiguration());
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration());
 
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
 

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/utils/pattern.ts

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

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

@@ -70,9 +70,14 @@ test("Test - Month-Year expression", function () {
     });
 
     testSingleCase(chrono, "Statement of comprehensive income for the year ended Dec. 2021", (result) => {
+        expect(result.text).toBe("Dec. 2021");
+
         expect(result.start.get("year")).toBe(2021);
         expect(result.start.get("month")).toBe(12);
-        expect(result.text).toBe("Dec. 2021");
+
+        expect(result.start.isCertain("year")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("day")).toBe(false);
     });
 });
 

package/test/en/en_month_name_middle_endian.test.ts

@@ -381,4 +381,6 @@ test("Test - Impossible Dates (Strict Mode)", () => {
     testUnexpectedResult(chrono.strict, "August 32", new Date(2012, 7, 10));
 
     testUnexpectedResult(chrono.strict, "February 29", new Date(2014, 7, 10));
+
+    testUnexpectedResult(chrono.strict, "February 151998", new Date(2014, 7, 10));
 });

package/test/en/en_slash.test.ts

@@ -136,6 +136,21 @@ test("Test - Single Expression Little-Endian with Month name", function () {
 
         expect(result.start).toBeDate(new Date(2012, 10 - 1, 8, 12));
     });
+
+    testSingleCase(chrono.strict, "06/Nov/2023", (result) => {
+        expect(result.text).toBe("06/Nov/2023");
+        expect(result).toBeDate(new Date(2023, 11 - 1, 6, 12));
+    });
+
+    testSingleCase(chrono.strict, "06/Nov/2023:06:36:02", (result) => {
+        expect(result.text).toBe("06/Nov/2023:06:36:02");
+        expect(result).toBeDate(new Date(2023, 11 - 1, 6, 6, 36, 2));
+    });
+
+    testSingleCase(chrono.strict, "06/Nov/2023:06:36:02 +0200", (result) => {
+        expect(result.text).toBe("06/Nov/2023:06:36:02 +0200");
+        expect(result).toBeDate(new Date("Mon Nov 06 2023 06:36:02 GMT+0200"));
+    });
 });
 
 test("Test - Range Expression", function () {

package/test/en/en_time_exp.test.ts

@@ -24,6 +24,36 @@ test("Test - Time expression", function () {
     });
 });
 
+test("Test - Time expression after date", function () {
+    testSingleCase(chrono, "05/31/2024 14:15", new Date(2016, 10 - 1, 1, 8), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "05/31/2024.14:15", new Date(2016, 10 - 1, 1, 8), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "05/31/2024:14:15", new Date(2016, 10 - 1, 1, 8), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "05/31/2024-14:15", new Date(2016, 10 - 1, 1, 8), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+});
+
 test("Test - Time range expression", function () {
     testSingleCase(chrono, "10:00:00 - 21:45:00", new Date(2016, 10 - 1, 1, 8), (result, text) => {
         expect(result.text).toBe(text);

package/test/en/en_time_units_later.test.ts

@@ -249,7 +249,9 @@ test("Test - From now Expression", () => {
 
         expect(result.start).toBeDate(new Date(2012, 7, 10, 14, 10));
     });
+});
 
+test("Test - The later expression with multiple time units", function () {
     testSingleCase(chrono, "in 1d 2hr 5min", new Date(2012, 7, 10, 12, 40), (result) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe("in 1d 2hr 5min");
@@ -259,6 +261,16 @@ test("Test - From now Expression", () => {
 
         expect(result.start).toBeDate(new Date(2012, 7, 11, 14, 45));
     });
+
+    testSingleCase(chrono, "in 1d, 2hr, and 5min", new Date(2012, 7, 10, 12, 40), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in 1d, 2hr, and 5min");
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(45);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 11, 14, 45));
+    });
 });
 
 test("Test - Strict mode", function () {

package/test/en/en_time_units_within.test.ts

@@ -174,6 +174,48 @@ test("Test - The normal within expression", () => {
     });
 });
 
+test("Test - The within expression with multiple time units", function () {
+    testSingleCase(chrono, "set a timer for 5 minutes 30 seconds", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(12);
+        expect(result.text).toBe("for 5 minutes 30 seconds");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19, 30));
+    });
+
+    testSingleCase(chrono, "set a timer for 5 minutes, 30 seconds", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(12);
+        expect(result.text).toBe("for 5 minutes, 30 seconds");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19, 30));
+    });
+
+    testSingleCase(chrono, "set a timer for 1 hour, 5 minutes, 30 seconds", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(12);
+        expect(result.text).toBe("for 1 hour, 5 minutes, 30 seconds");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 19, 30));
+    });
+
+    testSingleCase(chrono, "set a timer for 5 minutes and 30 seconds", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(12);
+        expect(result.text).toBe("for 5 minutes and 30 seconds");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19, 30));
+    });
+
+    testSingleCase(
+        chrono,
+        "set a timer for 1 hour, 5 minutes, and 30 seconds",
+        new Date(2012, 7, 10, 12, 14),
+        (result) => {
+            expect(result.index).toBe(12);
+            expect(result.text).toBe("for 1 hour, 5 minutes, and 30 seconds");
+
+            expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 19, 30));
+        }
+    );
+});
+
 test("Test - The within expression with certain keywords", () => {
     testSingleCase(chrono, "In  about 5 hours", new Date(2012, 8 - 1, 10, 12, 49), (result, text) => {
         expect(result.text).toBe(text);

package/test/system_timezone.test.ts

@@ -54,6 +54,17 @@ test("Test - Timezone difference on reference date", function () {
     });
 });
 
+test("Test - Timezone difference on reference date #2", function () {
+    const refInstant = new Date("2024-02-21T10:00:00+1300");
+
+    testSingleCase(chrono, "yesterday 18:00", { instant: refInstant, timezone: 780 }, (result) => {
+        // expect(result.start.get("year")).toBe(2024);
+        // expect(result.start.get("month")).toBe(2);
+        // expect(result.start.get("day")).toBe(20);
+        // expect(result).toBeDate(new Date("2024-02-20T18:00:00+1300"));
+    });
+});
+
 test("Test - Timezone difference on written date", function () {
     // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
     // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)

package/test/zh/{zh_hans_casual.test.ts → hans/zh_hans_casual.test.ts}

@@ -1,5 +1,5 @@
-import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import * as chrono from "../../../src";
+import { testSingleCase } from "../../test_util";
 
 test("Test - Single Expression", function () {
     testSingleCase(chrono.zh.hans, "我今天要打游戏", new Date(2012, 7, 10, 12), (result) => {

package/test/zh/{zh_hans_date.test.ts → hans/zh_hans_date.test.ts}

@@ -1,5 +1,5 @@
-import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import * as chrono from "../../../src";
+import { testSingleCase } from "../../test_util";
 
 test("Test - Single Expression", function () {
     testSingleCase(chrono.zh.hans, "我2016年9月3号要打游戏", new Date(2012, 8 - 1, 10), (result) => {