chrono-node 2.8.4 → 2.9.0

package/src/locales/ja/parsers/JPTimeExpressionParser.ts

@@ -1,7 +1,8 @@
 import { ParsingContext } from "../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { Meridiem } from "../../../types";
+import { Meridiem, ParsedComponents } from "../../../types";
 import { NUMBER, jaStringToNumber, toHankaku } from "../constants";
+import { ParsingComponents } from "../../../results";
 
 const FIRST_REG_PATTERN = new RegExp(
     "(?:" +
@@ -10,7 +11,7 @@ const FIRST_REG_PATTERN = new RegExp(
         "(?:[\\s,，、]*)" +
         "(?:([0-9０-９]+|[" +
         Object.keys(NUMBER).join("") +
-        "]+)(?:\\s*)(?:時|:|：)" +
+        "]+)(?:\\s*)(?:時(?!間)|:|：)" +
         "(?:\\s*)" +
         "([0-9０-９]+|半|[" +
         Object.keys(NUMBER).join("") +
@@ -56,96 +57,23 @@ export default class JPTimeExpressionParser extends AbstractParserWithWordBounda
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        // This pattern can be overlaped Ex. [12] AM, 1[2] AM
+        // This pattern can be overlapped Ex. [12] AM, 1[2] AM
         if (match.index > 0 && context.text[match.index - 1].match(/\w/)) {
             return null;
         }
 
         const result = context.createParsingResult(match.index, match[0]);
-
-        let hour = 0;
-        let minute = 0;
-        let meridiem = -1;
-
-        // ----- Second
-        if (match[SECOND_GROUP]) {
-            let second = parseInt(toHankaku(match[SECOND_GROUP]));
-            if (isNaN(second)) {
-                second = jaStringToNumber(match[SECOND_GROUP]);
-            }
-            if (second >= 60) return null;
-            result.start.assign("second", second);
-        }
-
-        hour = parseInt(toHankaku(match[HOUR_GROUP]));
-        if (isNaN(hour)) {
-            hour = jaStringToNumber(match[HOUR_GROUP]);
-        }
-
-        // ----- Minutes
-        if (match[MINUTE_GROUP]) {
-            if (match[MINUTE_GROUP] === "半") {
-                minute = 30;
-            } else {
-                minute = parseInt(toHankaku(match[MINUTE_GROUP]));
-                if (isNaN(minute)) {
-                    minute = jaStringToNumber(match[MINUTE_GROUP]);
-                }
-            }
-        } else if (hour > 100) {
-            minute = hour % 100;
-            hour = Math.floor(hour / 100);
-        }
-
-        if (minute >= 60) {
-            return null;
-        }
-
-        if (hour > 24) {
+        result.start = createTimeComponents(
+            context,
+            match[HOUR_GROUP],
+            match[MINUTE_GROUP],
+            match[SECOND_GROUP],
+            match[AM_PM_HOUR_GROUP_1] ?? match[AM_PM_HOUR_GROUP_2]
+        );
+        if (!result.start) {
+            match.index += match[0].length; // Skip over potential overlapping pattern
             return null;
         }
-        if (hour >= 12) {
-            meridiem = Meridiem.PM;
-        }
-
-        // ----- AM & PM
-        if (match[AM_PM_HOUR_GROUP_1]) {
-            if (hour > 12) return null;
-            const AMPMString = match[AM_PM_HOUR_GROUP_1];
-            const FirstAMPMString = AMPMString[0].toLowerCase();
-            if (AMPMString === "午前" || FirstAMPMString === "a") {
-                meridiem = Meridiem.AM;
-                if (hour === 12) hour = 0;
-            } else if (AMPMString === "午後" || FirstAMPMString === "p") {
-                meridiem = Meridiem.PM;
-                if (hour != 12) hour += 12;
-            }
-        } else if (match[AM_PM_HOUR_GROUP_2]) {
-            if (hour > 12) return null;
-            const ampm = match[AM_PM_HOUR_GROUP_2][0].toLowerCase();
-            if (ampm === "a") {
-                meridiem = Meridiem.AM;
-                if (hour === 12) hour = 0;
-            }
-
-            if (ampm === "p") {
-                meridiem = Meridiem.PM;
-                if (hour != 12) hour += 12;
-            }
-        }
-
-        result.start.assign("hour", hour);
-        result.start.assign("minute", minute);
-
-        if (meridiem >= 0) {
-            result.start.assign("meridiem", meridiem);
-        } else {
-            if (hour < 12) {
-                result.start.imply("meridiem", 0);
-            } else {
-                result.start.imply("meridiem", 1);
-            }
-        }
 
         // =============================================================================================
         //                  Extracting the 'to' chunk
@@ -153,129 +81,102 @@ export default class JPTimeExpressionParser extends AbstractParserWithWordBounda
 
         match = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));
         if (!match) {
-            // Not accept number only result
-            if (result.text.match(/^\d+$/)) {
-                return null;
-            }
             return result;
         }
 
-        result.end = context.createParsingComponents();
-
-        hour = 0;
-        minute = 0;
-        meridiem = -1;
-
-        // ----- Second
-        if (match[SECOND_GROUP]) {
-            let second = parseInt(toHankaku(match[SECOND_GROUP]));
-            if (isNaN(second)) {
-                second = jaStringToNumber(match[SECOND_GROUP]);
+        result.text = result.text + match[0];
+        result.end = createTimeComponents(
+            context,
+            match[HOUR_GROUP],
+            match[MINUTE_GROUP],
+            match[SECOND_GROUP],
+            match[AM_PM_HOUR_GROUP_1] ?? match[AM_PM_HOUR_GROUP_2]
+        );
+        if (!result.end) {
+            return null;
+        }
+        if (!result.end.isCertain("meridiem") && result.start.isCertain("meridiem")) {
+            result.end.imply("meridiem", result.start.get("meridiem"));
+            if (result.start.get("meridiem") === Meridiem.PM) {
+                if (result.start.get("hour") - 12 > result.end.get("hour")) {
+                    // 10pm - 1 (am)
+                    result.end.imply("meridiem", Meridiem.AM);
+                } else if (result.end.get("hour") < 12) {
+                    result.end.assign("hour", result.end.get("hour") + 12);
+                }
             }
-
-            if (second >= 60) return null;
-            result.end.assign("second", second);
         }
-
-        hour = parseInt(toHankaku(match[HOUR_GROUP]));
-        if (isNaN(hour)) {
-            hour = jaStringToNumber(match[HOUR_GROUP]);
+        if (result.end.date().getTime() < result.start.date().getTime()) {
+            result.end.imply("day", result.end.get("day") + 1);
         }
+        return result;
+    }
+}
 
-        // ----- Minutes
-        if (match[MINUTE_GROUP]) {
-            if (match[MINUTE_GROUP] === "半") {
-                minute = 30;
-            } else {
-                minute = parseInt(toHankaku(match[MINUTE_GROUP]));
-                if (isNaN(minute)) {
-                    minute = jaStringToNumber(match[MINUTE_GROUP]);
-                }
+function createTimeComponents(
+    context: ParsingContext,
+    matchHour: string | null,
+    matchMinute: string | null,
+    matchSecond: string | null,
+    matchAmPm: string | null
+): ParsingComponents | null {
+    let hour = 0;
+    let meridiem = -1;
+    let targetComponents = context.createParsingComponents();
+    hour = parseInt(toHankaku(matchHour));
+    if (isNaN(hour)) {
+        hour = jaStringToNumber(matchHour);
+    }
+    if (hour > 24) {
+        return null;
+    }
+
+    if (matchMinute) {
+        let minute: number;
+        if (matchMinute === "半") {
+            minute = 30;
+        } else {
+            minute = parseInt(toHankaku(matchMinute));
+            if (isNaN(minute)) {
+                minute = jaStringToNumber(matchMinute);
             }
-        } else if (hour > 100) {
-            minute = hour % 100;
-            hour = Math.floor(hour / 100);
         }
-
-        if (minute >= 60) {
-            return null;
+        if (minute >= 60) return null;
+        targetComponents.assign("minute", minute);
+    }
+    if (matchSecond) {
+        let second = parseInt(toHankaku(matchSecond));
+        if (isNaN(second)) {
+            second = jaStringToNumber(matchSecond);
         }
+        if (second >= 60) return null;
+        targetComponents.assign("second", second);
+    }
 
-        if (hour > 24) {
+    if (matchAmPm) {
+        if (hour > 12) {
             return null;
         }
-        if (hour >= 12) {
+        const AMPMString = matchAmPm;
+        if (AMPMString === "午前" || AMPMString[0].toLowerCase() === "a") {
+            meridiem = Meridiem.AM;
+            if (hour === 12) hour = 0;
+        } else if (AMPMString === "午後" || AMPMString[0].toLowerCase() === "p") {
             meridiem = Meridiem.PM;
+            if (hour != 12) hour += 12;
         }
+    }
 
-        // ----- AM & PM
-        if (match[AM_PM_HOUR_GROUP_1]) {
-            if (hour > 12) return null;
-            const AMPMString = match[AM_PM_HOUR_GROUP_1];
-            const FirstAMPMString = AMPMString[0].toLowerCase();
-            if (AMPMString === "午前" || FirstAMPMString === "a") {
-                meridiem = Meridiem.AM;
-                if (hour === 12) hour = 0;
-            } else if (AMPMString === "午後" || FirstAMPMString === "p") {
-                meridiem = Meridiem.PM;
-                if (hour != 12) hour += 12;
-            }
-
-            if (!result.start.isCertain("meridiem")) {
-                if (meridiem === Meridiem.AM) {
-                    result.start.imply("meridiem", Meridiem.AM);
-
-                    if (result.start.get("hour") === 12) {
-                        result.start.assign("hour", 0);
-                    }
-                } else {
-                    result.start.imply("meridiem", 1);
-
-                    if (result.start.get("hour") != 12) {
-                        result.start.assign("hour", result.start.get("hour") + 12);
-                    }
-                }
-            }
-        } else if (match[AM_PM_HOUR_GROUP_2]) {
-            if (hour > 12) return null;
-            const ampm = match[AM_PM_HOUR_GROUP_2][0].toLowerCase();
-            if (ampm === "a") {
-                meridiem = Meridiem.AM;
-                if (hour === 12) hour = 0;
-            }
+    targetComponents.assign("hour", hour);
 
-            if (ampm === "p") {
-                meridiem = Meridiem.PM;
-                if (hour != 12) hour += 12;
-            }
-        }
-
-        result.text = result.text + match[0];
-        result.end.assign("hour", hour);
-        result.end.assign("minute", minute);
-        if (meridiem >= 0) {
-            result.end.assign("meridiem", meridiem);
+    if (meridiem >= 0) {
+        targetComponents.assign("meridiem", meridiem);
+    } else {
+        if (hour < 12) {
+            targetComponents.imply("meridiem", Meridiem.AM);
         } else {
-            const startAtPM = result.start.isCertain("meridiem") && result.start.get("hour") > 12;
-            if (startAtPM) {
-                if (result.start.get("hour") - 12 > hour) {
-                    // 10pm - 1 (am)
-                    result.end.imply("meridiem", Meridiem.AM);
-                } else if (hour <= 12) {
-                    result.end.assign("hour", hour + 12);
-                    result.end.assign("meridiem", Meridiem.PM);
-                }
-            } else if (hour > 12) {
-                result.end.imply("meridiem", Meridiem.PM);
-            } else if (hour <= 12) {
-                result.end.imply("meridiem", Meridiem.AM);
-            }
+            targetComponents.imply("meridiem", Meridiem.PM);
         }
-
-        if (result.end.date().getTime() < result.start.date().getTime()) {
-            result.end.imply("day", result.end.get("day") + 1);
-        }
-
-        return result;
     }
+    return targetComponents;
 }

package/src/locales/nl/constants.ts

@@ -1,7 +1,7 @@
-import { OpUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
-import { TimeUnits } from "../../utils/timeunits";
+import { Duration } from "../../calculation/duration";
+import { Timeunit } from "../../types";
 
 export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
     // Zondag
@@ -136,7 +136,7 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "eenendertigste": 31,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
     sec: "second",
     second: "second",
     seconden: "second",
@@ -152,8 +152,8 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
     uur: "hour",
     u: "hour",
     uren: "hour",
-    dag: "d",
-    dagen: "d",
+    dag: "day",
+    dagen: "day",
     week: "week",
     weken: "week",
     maand: "month",
@@ -220,7 +220,7 @@ const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
 export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:binnen|in)\\s*)?`, SINGLE_TIME_UNIT_PATTERN);
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseDuration(timeunitText): Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -229,7 +229,7 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length);
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
-    return fragments;
+    return fragments as Duration;
 }
 
 function collectDateTimeFragment(fragments, match) {

package/src/locales/nl/parsers/NLCasualDateTimeParser.ts

@@ -2,8 +2,7 @@ import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { Meridiem } from "../../../types";
-import { assignSimilarDate, assignTheNextDay } from "../../../utils/dayjs";
-import dayjs from "dayjs";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
 
 /*
  * Find combined words
@@ -36,17 +35,22 @@ export default class NLCasualDateTimeParser extends AbstractParserWithWordBounda
         const dateText = match[DATE_GROUP].toLowerCase();
         const timeText = match[TIME_OF_DAY_GROUP].toLowerCase();
         const component = context.createParsingComponents();
-        const targetDate = dayjs(context.refDate);
+        const targetDate = context.refDate;
 
         switch (dateText) {
             case "gisteren":
-                assignSimilarDate(component, targetDate.add(-1, "day"));
+                const previousDay = new Date(targetDate.getTime());
+                previousDay.setDate(previousDay.getDate() - 1);
+                assignSimilarDate(component, previousDay);
                 break;
             case "van":
                 assignSimilarDate(component, targetDate);
                 break;
             case "morgen":
-                assignTheNextDay(component, targetDate);
+                const nextDay = new Date(targetDate.getTime());
+                nextDay.setDate(nextDay.getDate() + 1);
+                assignSimilarDate(component, nextDay);
+                implySimilarTime(component, nextDay);
                 break;
         }
 

package/src/locales/nl/parsers/NLCasualTimeParser.ts

@@ -1,8 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import dayjs from "dayjs";
-import { assignTheNextDay } from "../../../utils/dayjs";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
 
 const DAY_GROUP = 1;
 const MOMENT_GROUP = 2;
@@ -13,7 +12,7 @@ export default class NLCasualTimeParser extends AbstractParserWithWordBoundaryCh
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const targetDate = dayjs(context.refDate);
+        const targetDate = context.refDate;
         const component = context.createParsingComponents();
 
         if (match[DAY_GROUP] === "deze") {
@@ -36,7 +35,10 @@ export default class NLCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 break;
 
             case "middernacht":
-                assignTheNextDay(component, targetDate);
+                const nextDay = new Date(targetDate.getTime());
+                nextDay.setDate(nextDay.getDate() + 1);
+                assignSimilarDate(component, nextDay);
+                implySimilarTime(component, nextDay);
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);

package/src/locales/nl/parsers/NLRelativeDateFormatParser.ts

@@ -1,7 +1,6 @@
 import { TIME_UNIT_DICTIONARY } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import dayjs from "dayjs";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { matchAnyPattern } from "../../../utils/pattern";
 
@@ -37,32 +36,31 @@ export default class NLRelativeDateFormatParser extends AbstractParserWithWordBo
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.reference.instant);
+        let date = new Date(context.reference.instant.getTime());
 
         // This week
         if (unitWord.match(/week/i)) {
-            date = date.add(-date.get("d"), "d");
-            components.imply("day", date.date());
-            components.imply("month", date.month() + 1);
-            components.imply("year", date.year());
+            date.setDate(date.getDate() - date.getDay());
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.imply("year", date.getFullYear());
         }
 
         // This month
         else if (unitWord.match(/maand/i)) {
-            date = date.add(-date.date() + 1, "d");
-            components.imply("day", date.date());
-            components.assign("year", date.year());
-            components.assign("month", date.month() + 1);
+            date.setDate(1);
+            components.imply("day", date.getDate());
+            components.assign("year", date.getFullYear());
+            components.assign("month", date.getMonth() + 1);
         }
 
         // This year
         else if (unitWord.match(/jaar/i)) {
-            date = date.add(-date.date() + 1, "d");
-            date = date.add(-date.month(), "month");
-
-            components.imply("day", date.date());
-            components.imply("month", date.month() + 1);
-            components.assign("year", date.year());
+            date.setDate(1);
+            date.setMonth(0);
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.assign("year", date.getFullYear());
         }
 
         return components;

package/src/locales/nl/parsers/NLTimeUnitAgoFormatParser.ts

@@ -1,8 +1,8 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { reverseTimeUnits } from "../../../utils/timeunits";
+import { reverseDuration } from "../../../calculation/duration";
 
 const PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(?:geleden|voor|eerder)(?=(?:\\W|$))", "i");
 
@@ -18,8 +18,8 @@ export default class NLTimeUnitAgoFormatParser extends AbstractParserWithWordBou
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const timeUnits = parseTimeUnits(match[1]);
-        const outputTimeUnits = reverseTimeUnits(timeUnits);
+        const timeUnits = parseDuration(match[1]);
+        const outputTimeUnits = reverseDuration(timeUnits);
 
         return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }

package/src/locales/nl/parsers/NLTimeUnitCasualRelativeFormatParser.ts

@@ -1,8 +1,8 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { reverseTimeUnits } from "../../../utils/timeunits";
+import { reverseDuration } from "../../../calculation/duration";
 
 const PATTERN = new RegExp(
     `(dit|deze|vorig|afgelopen|(?:aan)?komend|over|\\+|-)e?\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
@@ -19,12 +19,12 @@ export default class NLTimeUnitCasualRelativeFormatParser extends AbstractParser
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const prefix = match[PREFIX_WORD_GROUP].toLowerCase();
-        let timeUnits = parseTimeUnits(match[TIME_UNIT_WORD_GROUP]);
+        let timeUnits = parseDuration(match[TIME_UNIT_WORD_GROUP]);
         switch (prefix) {
             case "vorig":
             case "afgelopen":
             case "-":
-                timeUnits = reverseTimeUnits(timeUnits);
+                timeUnits = reverseDuration(timeUnits);
                 break;
         }
 

package/src/locales/nl/parsers/NLTimeUnitLaterFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
@@ -21,7 +21,7 @@ export default class NLTimeUnitLaterFormatParser extends AbstractParserWithWordB
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        const fragments = parseDuration(match[GROUP_NUM_TIMEUNITS]);
         return ParsingComponents.createRelativeFromReference(context.reference, fragments);
     }
 }

package/src/locales/nl/parsers/NLTimeUnitWithinFormatParser.ts

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -9,7 +9,7 @@ export default class NLTimeUnitWithinFormatParser extends AbstractParserWithWord
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const timeUnits = parseTimeUnits(match[1]);
+        const timeUnits = parseDuration(match[1]);
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/pt/parsers/PTCasualTimeParser.ts

@@ -1,8 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { assignTheNextDay } from "../../../utils/dayjs";
-import dayjs from "dayjs";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
 
 export default class PTCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern() {
@@ -10,7 +9,7 @@ export default class PTCasualTimeParser extends AbstractParserWithWordBoundaryCh
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const targetDate = dayjs(context.refDate);
+        const targetDate = context.refDate;
         const component = context.createParsingComponents();
         switch (match[1].toLowerCase()) {
             case "tarde":
@@ -30,7 +29,10 @@ export default class PTCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 break;
 
             case "meia-noite":
-                assignTheNextDay(component, targetDate);
+                const nextDay = new Date(targetDate.getTime());
+                nextDay.setDate(nextDay.getDate() + 1);
+                assignSimilarDate(component, nextDay);
+                implySimilarTime(component, nextDay);
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);