timelang 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Kamran Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -14,8 +14,7 @@ It takes natural language inputs and converts them into structured date, duratio
 - **Forgiving parser** — Extra spaces, mixed case, missing separators all work
 - **Edge case handling** — Year rollovers, leap years, fiscal quarters
 - **Configurable** — Reference date, fiscal year start, week start day, date format
-- **Zero dependencies** — Lightweight and fast
-- **TypeScript** — Full type definitions included
+- **TypeScript** — Typesafe with full type definitions
 
 ## Installation
 

package/dist/index.cjs

@@ -270,8 +270,23 @@ var lexer = import_moo.default.compile({
         "sat",
         "sun"
       ],
+      // Ago keyword for relative dates
+      kw_ago: ["ago"],
+      // Weekend and night keywords
+      kw_weekend: ["weekend"],
+      kw_tonight: ["tonight"],
+      kw_night: ["night"],
+      kw_fortnight: ["fortnight", "fortnights"],
       // Other keywords
-      otherKeyword: ["fiscal", "fy", "daily", "weekly", "monthly", "yearly", "annually", "ago", "hence", "later"]
+      otherKeyword: ["fiscal", "fy", "daily", "weekly", "monthly", "yearly", "annually", "hence", "later", "earlier"],
+      // Business keywords
+      kw_business: ["business"],
+      // EOD/COB keywords
+      kw_eod: ["eod"],
+      kw_cob: ["cob"],
+      kw_close: ["close"],
+      // Week keyword (for "week 1" patterns)
+      kw_week: ["week"]
     })
     // Keywords are matched against lowercase input
   },
@@ -324,6 +339,13 @@ var makeRelative = (direction, duration) => ({
   direction,
   duration
 });
+var makeRelativeDate = (direction, duration, baseDate, time2) => ({
+  nodeType: "relativeDate",
+  direction,
+  duration,
+  baseDate,
+  time: time2
+});
 var makeTitled = (title, expression, titleStart, titleEnd) => ({
   nodeType: "titled",
   title: title.trim(),
@@ -559,10 +581,14 @@ var grammar = {
     { "name": "expression", "symbols": ["range"], "postprocess": first },
     { "name": "expression", "symbols": ["span"], "postprocess": first },
     { "name": "expression", "symbols": ["relative"], "postprocess": first },
+    { "name": "expression", "symbols": ["relativeDate"], "postprocess": first },
+    { "name": "expression", "symbols": ["lastDayOfMonthExpr"], "postprocess": first },
+    { "name": "expression", "symbols": ["date"], "postprocess": first },
     { "name": "expression", "symbols": ["fuzzy"], "postprocess": first },
     { "name": "expression", "symbols": ["forDuration"], "postprocess": first },
     { "name": "expression", "symbols": ["duration"], "postprocess": first },
-    { "name": "expression", "symbols": ["date"], "postprocess": first },
+    { "name": "lastDayOfMonthExpr", "symbols": ["lastRelative", "_", "dayUnit", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ month: d[6], lastDayOfMonth: true }) },
+    { "name": "lastDayOfMonthExpr", "symbols": ["lastRelative", "_", "dayUnit", "_", "ofConnector", "_", "theConnector", "_", "monthUnit"], "postprocess": (d) => makeDate({ lastDayOfMonth: true, monthFromRef: true }) },
     { "name": "forDuration", "symbols": ["forConnector", "_", "duration"], "postprocess": (d) => d[2] },
     { "name": "range", "symbols": ["date", "_", "toConnector", "_", "date"], "postprocess": (d) => makeRange(d[0], d[4]) },
     { "name": "range", "symbols": ["fromConnector", "_", "date", "_", "toConnector", "_", "date"], "postprocess": (d) => makeRange(d[2], d[6]) },
@@ -644,6 +670,30 @@ var grammar = {
     { "name": "relative", "symbols": ["inConnector", "_", "theConnector", "_", "pastRelative", "_", "unit"], "postprocess": (d) => makeRelative("past", makeDuration(1, d[6])) },
     { "name": "relative", "symbols": ["inConnector", "_", "theConnector", "_", "comingRelative", "_", "unit"], "postprocess": (d) => makeRelative("future", makeDuration(1, d[6])) },
     { "name": "relative", "symbols": ["inConnector", "_", "theConnector", "_", "upcomingRelative", "_", "unit"], "postprocess": (d) => makeRelative("future", makeDuration(1, d[6])) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "agoConnector"], "postprocess": (d) => makeRelativeDate("past", d[0]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "agoConnector", "_", "atConnector", "_", "time"], "postprocess": (d) => makeRelativeDate("past", d[0], void 0, d[6]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "agoConnector", "_", "atConnector", "_", "timeWord"], "postprocess": (d) => makeRelativeDate("past", d[0], void 0, { special: d[6] }) },
+    { "name": "relativeDate", "symbols": ["inConnector", "_", "duration"], "postprocess": (d) => makeRelativeDate("future", d[2]) },
+    { "name": "relativeDate", "symbols": ["inConnector", "_", "duration", "_", "atConnector", "_", "time"], "postprocess": (d) => makeRelativeDate("future", d[2], void 0, d[6]) },
+    { "name": "relativeDate", "symbols": ["inConnector", "_", "duration", "_", "atConnector", "_", "timeWord"], "postprocess": (d) => makeRelativeDate("future", d[2], void 0, { special: d[6] }) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "now"], "postprocess": (d) => makeRelativeDate("future", d[0]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "now", "_", "atConnector", "_", "time"], "postprocess": (d) => makeRelativeDate("future", d[0], void 0, d[8]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "now", "_", "atConnector", "_", "timeWord"], "postprocess": (d) => makeRelativeDate("future", d[0], void 0, { special: d[8] }) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "today"], "postprocess": (d) => makeRelativeDate("future", d[0], makeDate({ special: "today" })) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "today", "_", "atConnector", "_", "time"], "postprocess": (d) => makeRelativeDate("future", d[0], makeDate({ special: "today" }), d[8]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "tomorrow"], "postprocess": (d) => makeRelativeDate("future", d[0], makeDate({ special: "tomorrow" })) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "tomorrow", "_", "atConnector", "_", "time"], "postprocess": (d) => makeRelativeDate("future", d[0], makeDate({ special: "tomorrow" }), d[8]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "fromConnector", "_", "yesterday"], "postprocess": (d) => makeRelativeDate("future", d[0], makeDate({ special: "yesterday" })) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "henceConnector"], "postprocess": (d) => makeRelativeDate("future", d[0]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "laterConnector"], "postprocess": (d) => makeRelativeDate("future", d[0]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "beforeConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("past", d[0], d[4]) },
+    { "name": "relativeDate", "symbols": ["duration", "_", "afterConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("future", d[0], d[4]) },
+    { "name": "relativeDate", "symbols": ["theConnector", "_", "dayUnit", "_", "beforeConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("past", makeDuration(1, "day"), d[6]) },
+    { "name": "relativeDate", "symbols": ["theConnector", "_", "dayUnit", "_", "afterConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("future", makeDuration(1, "day"), d[6]) },
+    { "name": "relativeDate", "symbols": ["dayUnit", "_", "beforeConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("past", makeDuration(1, "day"), d[4]) },
+    { "name": "relativeDate", "symbols": ["dayUnit", "_", "afterConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("future", makeDuration(1, "day"), d[4]) },
+    { "name": "relativeDate", "symbols": ["wordNumber", "_", "unit", "_", "beforeConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("past", makeDuration(parseWordNumber(d[0]), d[2]), d[6]) },
+    { "name": "relativeDate", "symbols": ["wordNumber", "_", "unit", "_", "afterConnector", "_", "date"], "postprocess": (d) => makeRelativeDate("future", makeDuration(parseWordNumber(d[0]), d[2]), d[6]) },
     { "name": "fuzzy", "symbols": ["quarter"], "postprocess": (d) => makeFuzzy({ period: "quarter", quarter: parseQuarter(d[0].value) }) },
     { "name": "fuzzy", "symbols": ["quarter", "_", "year"], "postprocess": (d) => makeFuzzy({ period: "quarter", quarter: parseQuarter(d[0].value), year: d[2] }) },
     { "name": "fuzzy", "symbols": ["half"], "postprocess": (d) => makeFuzzy({ period: "half", half: parseHalf(d[0].value) }) },
@@ -726,8 +776,29 @@ var grammar = {
     { "name": "fuzzy", "symbols": ["lateModifier", "_", "thisRelative", "_", "unit"], "postprocess": (d) => makeFuzzy({ period: d[4], modifier: "late", relative: "this" }) },
     { "name": "fuzzy", "symbols": ["beginningConnector", "_", "ofConnector", "_", "theConnector", "_", "unit"], "postprocess": (d) => makeFuzzy({ period: d[6], modifier: "beginning" }) },
     { "name": "fuzzy", "symbols": ["middleConnector", "_", "ofConnector", "_", "theConnector", "_", "unit"], "postprocess": (d) => makeFuzzy({ period: d[6], modifier: "middle" }) },
-    { "name": "fuzzy", "symbols": ["lastRelative", "_", "unit", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeFuzzy({ period: "month", month: d[6], modifier: "late" }) },
-    { "name": "fuzzy", "symbols": ["ordinalWord", "_", "unit", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeFuzzy({ period: "month", month: d[6], modifier: parseOrdinalWord(d[0]) <= 2 ? "early" : parseOrdinalWord(d[0]) >= 4 ? "late" : "mid" }) },
+    { "name": "fuzzy", "symbols": ["lastRelative", "_", "unit", "_", "ofConnector", "_", "month"], "postprocess": (d, _, reject) => {
+      if (d[2].toLowerCase() === "day" || d[2].toLowerCase() === "days") return reject;
+      return makeFuzzy({ period: "month", month: d[6], modifier: "late" });
+    } },
+    { "name": "fuzzy", "symbols": ["ordinalWord", "_", "unit", "_", "ofConnector", "_", "month"], "postprocess": (d, _, reject) => {
+      if (d[2].toLowerCase() === "day" || d[2].toLowerCase() === "days") return reject;
+      return makeFuzzy({ period: "month", month: d[6], modifier: parseOrdinalWord(d[0]) <= 2 ? "early" : parseOrdinalWord(d[0]) >= 4 ? "late" : "mid" });
+    } },
+    { "name": "fuzzy", "symbols": ["weekendKeyword"], "postprocess": (d) => makeFuzzy({ period: "weekend", relative: "this" }) },
+    { "name": "fuzzy", "symbols": ["theConnector", "_", "weekendKeyword"], "postprocess": (d) => makeFuzzy({ period: "weekend", relative: "this" }) },
+    { "name": "fuzzy", "symbols": ["thisRelative", "_", "weekendKeyword"], "postprocess": (d) => makeFuzzy({ period: "weekend", relative: "this" }) },
+    { "name": "fuzzy", "symbols": ["nextRelative", "_", "weekendKeyword"], "postprocess": (d) => makeFuzzy({ period: "weekend", relative: "next" }) },
+    { "name": "fuzzy", "symbols": ["lastRelative", "_", "weekendKeyword"], "postprocess": (d) => makeFuzzy({ period: "weekend", relative: "last" }) },
+    { "name": "fuzzy", "symbols": ["tonightKeyword"], "postprocess": (d) => makeFuzzy({ period: "tonight" }) },
+    { "name": "fuzzy", "symbols": ["nightKeyword"], "postprocess": (d) => makeFuzzy({ period: "night" }) },
+    { "name": "fuzzy", "symbols": ["lastRelative", "_", "nightKeyword"], "postprocess": (d) => makeFuzzy({ period: "night", relative: "last" }) },
+    { "name": "fuzzy", "symbols": ["tomorrow", "_", "nightKeyword"], "postprocess": (d) => makeFuzzy({ period: "night", relative: "tomorrow" }) },
+    { "name": "fuzzy", "symbols": ["weekday", "_", "nightKeyword"], "postprocess": (d) => makeFuzzy({ period: "night", weekday: d[0] }) },
+    { "name": "fuzzy", "symbols": ["fortnightKeyword"], "postprocess": (d) => makeFuzzy({ period: "fortnight" }) },
+    { "name": "fuzzy", "symbols": ["nextRelative", "_", "fortnightKeyword"], "postprocess": (d) => makeFuzzy({ period: "fortnight", relative: "next" }) },
+    { "name": "fuzzy", "symbols": ["lastRelative", "_", "fortnightKeyword"], "postprocess": (d) => makeFuzzy({ period: "fortnight", relative: "last" }) },
+    { "name": "fuzzy", "symbols": ["inConnector", "_", "wordNumber", "_", "fortnightKeyword"], "postprocess": (d) => makeFuzzy({ period: "fortnight", count: parseWordNumber(d[2]) }) },
+    { "name": "fuzzy", "symbols": ["inConnector", "_", "number", "_", "fortnightKeyword"], "postprocess": (d) => makeFuzzy({ period: "fortnight", count: d[2] }) },
     { "name": "duration", "symbols": ["number", "_", "unit"], "postprocess": (d) => makeDuration(d[0], d[2]) },
     { "name": "duration", "symbols": ["wordNumber", "_", "unit"], "postprocess": (d) => makeDuration(parseWordNumber(d[0]), d[2]) },
     { "name": "duration", "symbols": ["abbreviatedDuration"], "postprocess": (d) => d[0] },
@@ -755,6 +826,7 @@ var grammar = {
       return makeDuration(value, unitMap[match[2]]);
     } },
     { "name": "date", "symbols": ["specialDay"], "postprocess": (d) => makeDate({ special: d[0] }) },
+    { "name": "date", "symbols": ["ordinalWeekdayOfMonth"], "postprocess": first },
     { "name": "date", "symbols": ["relativeWeekday"], "postprocess": first },
     { "name": "date", "symbols": ["weekday"], "postprocess": (d) => makeDate({ weekday: d[0] }) },
     { "name": "date", "symbols": ["monthDayYear"], "postprocess": first },
@@ -769,6 +841,7 @@ var grammar = {
     { "name": "date", "symbols": ["monthOnly"], "postprocess": first },
     { "name": "date", "symbols": ["yearOnly"], "postprocess": first },
     { "name": "date", "symbols": ["timeOnly"], "postprocess": first },
+    { "name": "date", "symbols": ["dayOnly"], "postprocess": first },
     { "name": "monthDayCompact", "symbols": [lexer.has("monthDayCompact") ? { type: "monthDayCompact" } : monthDayCompact], "postprocess": (d) => {
       const parsed = parseMonthDayCompact(d[0].value);
       return makeDate({ month: parsed.month, day: parsed.day });
@@ -785,6 +858,8 @@ var grammar = {
     } },
     { "name": "timeOnly", "symbols": ["time"], "postprocess": (d) => makeDate({ time: d[0], timeOnly: true }) },
     { "name": "timeOnly", "symbols": ["timeWord"], "postprocess": (d) => makeDate({ time: { special: d[0] }, timeOnly: true }) },
+    { "name": "dayOnly", "symbols": ["theConnector", "_", "dayNumber"], "postprocess": (d) => makeDate({ day: d[2], dayOnly: true }) },
+    { "name": "dayOnly", "symbols": ["onConnector", "_", "theConnector", "_", "dayNumber"], "postprocess": (d) => makeDate({ day: d[4], dayOnly: true }) },
     { "name": "specialDay", "symbols": ["today"], "postprocess": (d) => "today" },
     { "name": "specialDay", "symbols": ["tomorrow"], "postprocess": (d) => "tomorrow" },
     { "name": "specialDay", "symbols": ["yesterday"], "postprocess": (d) => "yesterday" },
@@ -793,7 +868,7 @@ var grammar = {
     { "name": "specialDay", "symbols": ["dayUnit", "_", "afterConnector", "_", "tomorrow"], "postprocess": (d) => "dayAfterTomorrow" },
     { "name": "specialDay", "symbols": ["theConnector", "_", "dayUnit", "_", "beforeConnector", "_", "yesterday"], "postprocess": (d) => "dayBeforeYesterday" },
     { "name": "specialDay", "symbols": ["dayUnit", "_", "beforeConnector", "_", "yesterday"], "postprocess": (d) => "dayBeforeYesterday" },
-    { "name": "dayUnit", "symbols": [lexer.has("unit") ? { type: "unit" } : unit], "postprocess": (d) => d[0].value === "day" ? d[0] : null },
+    { "name": "dayUnit", "symbols": [lexer.has("unit") ? { type: "unit" } : unit], "postprocess": (d, _, reject) => d[0].value === "day" ? d[0] : reject },
     { "name": "relativeWeekday", "symbols": ["nextRelative", "_", "weekday"], "postprocess": (d) => makeDate({ weekday: d[2], relative: "next" }) },
     { "name": "relativeWeekday", "symbols": ["lastRelative", "_", "weekday"], "postprocess": (d) => makeDate({ weekday: d[2], relative: "last" }) },
     { "name": "relativeWeekday", "symbols": ["thisRelative", "_", "weekday"], "postprocess": (d) => makeDate({ weekday: d[2], relative: "this" }) },
@@ -808,6 +883,14 @@ var grammar = {
     { "name": "monthDay", "symbols": ["theConnector", "_", "dayNumber", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ month: d[6], day: d[2] }) },
     { "name": "monthDay", "symbols": ["month", "_", "ordinalWord"], "postprocess": (d) => makeDate({ month: d[0], day: parseOrdinalWord(d[2]) }) },
     { "name": "monthDay", "symbols": ["month", "_", "theConnector", "_", "dayNumber"], "postprocess": (d) => makeDate({ month: d[0], day: d[4] }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["ordinalWord", "_", "weekday", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ ordinalWeekday: parseOrdinalWord(d[0]), weekday: d[2], month: d[6] }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["lastRelative", "_", "weekday", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ ordinalWeekday: -1, weekday: d[2], month: d[6] }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["ordinalWord", "_", "weekday", "_", "ofConnector", "_", "theConnector", "_", "monthUnit"], "postprocess": (d) => makeDate({ ordinalWeekday: parseOrdinalWord(d[0]), weekday: d[2], monthFromRef: true }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["lastRelative", "_", "weekday", "_", "ofConnector", "_", "theConnector", "_", "monthUnit"], "postprocess": (d) => makeDate({ ordinalWeekday: -1, weekday: d[2], monthFromRef: true }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["ordinalWord", "_", "dayUnit", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ month: d[6], day: parseOrdinalWord(d[0]) }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["lastRelative", "_", "dayUnit", "_", "ofConnector", "_", "month"], "postprocess": (d) => makeDate({ month: d[6], day: -1, lastDayOfMonth: true }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["lastRelative", "_", "dayUnit", "_", "ofConnector", "_", "theConnector", "_", "monthUnit"], "postprocess": (d) => makeDate({ lastDayOfMonth: true, monthFromRef: true }) },
+    { "name": "ordinalWeekdayOfMonth", "symbols": ["ordinalWord", "_", "dayUnit", "_", "ofConnector", "_", "nextRelative", "_", "monthUnit"], "postprocess": (d) => makeDate({ ordinalWeekday: parseOrdinalWord(d[0]), dayOfMonth: true, nextMonth: true }) },
     { "name": "monthDayYear", "symbols": ["monthDay", "_", "year"], "postprocess": (d) => ({ ...d[0], year: d[2] }) },
     { "name": "monthDayYear", "symbols": ["monthDay", lexer.has("comma") ? { type: "comma" } : comma, "_", "year"], "postprocess": (d) => ({ ...d[0], year: d[3] }) },
     { "name": "dateFormat", "symbols": [lexer.has("integer") ? { type: "integer" } : integer, lexer.has("dash") ? { type: "dash" } : dash, lexer.has("integer") ? { type: "integer" } : integer, lexer.has("dash") ? { type: "dash" } : dash, lexer.has("integer") ? { type: "integer" } : integer], "postprocess": (d) => {
@@ -901,6 +984,11 @@ var grammar = {
       if (val === "year" || val === "years" || val === "yr" || val === "yrs") return val;
       return reject;
     } },
+    { "name": "monthUnit", "symbols": [lexer.has("unit") ? { type: "unit" } : unit], "postprocess": (d, _, reject) => {
+      const val = d[0].value.toLowerCase();
+      if (val === "month" || val === "months" || val === "mo" || val === "mos") return val;
+      return reject;
+    } },
     { "name": "wordNumber", "symbols": [lexer.has("wordNumber") ? { type: "wordNumber" } : wordNumber], "postprocess": (d) => d[0].value },
     { "name": "ordinalWord", "symbols": [lexer.has("ordinalWord") ? { type: "ordinalWord" } : ordinalWord], "postprocess": (d) => d[0].value },
     { "name": "ordinalWord", "symbols": [lexer.has("unit") ? { type: "unit" } : unit], "postprocess": (d, _, reject) => {
@@ -937,6 +1025,9 @@ var grammar = {
     { "name": "beginningConnector", "symbols": [lexer.has("kw_beginning") ? { type: "kw_beginning" } : kw_beginning], "postprocess": first },
     { "name": "startConnector", "symbols": [lexer.has("kw_start") ? { type: "kw_start" } : kw_start], "postprocess": first },
     { "name": "middleConnector", "symbols": [lexer.has("kw_middle") ? { type: "kw_middle" } : kw_middle], "postprocess": first },
+    { "name": "agoConnector", "symbols": [lexer.has("kw_ago") ? { type: "kw_ago" } : kw_ago], "postprocess": first },
+    { "name": "henceConnector", "symbols": [lexer.has("otherKeyword") ? { type: "otherKeyword" } : otherKeyword], "postprocess": (d, _, reject) => d[0].value === "hence" ? d[0] : reject },
+    { "name": "laterConnector", "symbols": [lexer.has("otherKeyword") ? { type: "otherKeyword" } : otherKeyword], "postprocess": (d, _, reject) => d[0].value === "later" ? d[0] : reject },
     { "name": "earlyModifier", "symbols": [lexer.has("kw_early") ? { type: "kw_early" } : kw_early], "postprocess": first },
     { "name": "midModifier", "symbols": [lexer.has("kw_mid") ? { type: "kw_mid" } : kw_mid], "postprocess": first },
     { "name": "lateModifier", "symbols": [lexer.has("kw_late") ? { type: "kw_late" } : kw_late], "postprocess": first },
@@ -953,6 +1044,10 @@ var grammar = {
     { "name": "now", "symbols": [lexer.has("kw_now") ? { type: "kw_now" } : kw_now], "postprocess": first },
     { "name": "noon", "symbols": [lexer.has("kw_noon") ? { type: "kw_noon" } : kw_noon], "postprocess": first },
     { "name": "midnight", "symbols": [lexer.has("kw_midnight") ? { type: "kw_midnight" } : kw_midnight], "postprocess": first },
+    { "name": "weekendKeyword", "symbols": [lexer.has("kw_weekend") ? { type: "kw_weekend" } : kw_weekend], "postprocess": first },
+    { "name": "tonightKeyword", "symbols": [lexer.has("kw_tonight") ? { type: "kw_tonight" } : kw_tonight], "postprocess": first },
+    { "name": "nightKeyword", "symbols": [lexer.has("kw_night") ? { type: "kw_night" } : kw_night], "postprocess": first },
+    { "name": "fortnightKeyword", "symbols": [lexer.has("kw_fortnight") ? { type: "kw_fortnight" } : kw_fortnight], "postprocess": first },
     { "name": "_$ebnf$1", "symbols": [] },
     { "name": "_$ebnf$1", "symbols": ["_$ebnf$1", lexer.has("ws") ? { type: "ws" } : ws], "postprocess": (d) => d[0].concat([d[1]]) },
     { "name": "_", "symbols": ["_$ebnf$1"], "postprocess": nuller }
@@ -1210,6 +1305,114 @@ function convertMonthDay(node, opts) {
   }
   return date;
 }
+function convertOrdinalWeekdayOfMonth(node, opts) {
+  const ref = opts.referenceDate;
+  const ordinal2 = node.ordinalWeekday;
+  const weekdayName = node.weekday.toLowerCase();
+  const weekdayNum = WEEKDAY_MAP[weekdayName] ?? 0;
+  let month2;
+  let year;
+  if (node.monthFromRef) {
+    month2 = ref.getUTCMonth();
+    year = ref.getUTCFullYear();
+  } else if (node.nextMonth) {
+    month2 = ref.getUTCMonth() + 1;
+    year = ref.getUTCFullYear();
+    if (month2 > 11) {
+      month2 = 0;
+      year++;
+    }
+  } else {
+    month2 = typeof node.month === "number" ? node.month - 1 : ref.getUTCMonth();
+    year = ref.getUTCFullYear();
+    if (month2 < ref.getUTCMonth()) {
+      year++;
+    }
+  }
+  if (ordinal2 === -1) {
+    const lastDay2 = new Date(Date.UTC(year, month2 + 1, 0));
+    let day2 = lastDay2.getUTCDate();
+    let date2 = new Date(Date.UTC(year, month2, day2));
+    while (date2.getUTCDay() !== weekdayNum) {
+      day2--;
+      date2 = new Date(Date.UTC(year, month2, day2));
+    }
+    return date2;
+  }
+  let count = 0;
+  for (let day2 = 1; day2 <= 31; day2++) {
+    const date2 = new Date(Date.UTC(year, month2, day2));
+    if (date2.getUTCMonth() !== month2) {
+      break;
+    }
+    if (date2.getUTCDay() === weekdayNum) {
+      count++;
+      if (count === ordinal2) {
+        return date2;
+      }
+    }
+  }
+  const lastDay = new Date(Date.UTC(year, month2 + 1, 0));
+  let day = lastDay.getUTCDate();
+  let date = new Date(Date.UTC(year, month2, day));
+  while (date.getUTCDay() !== weekdayNum) {
+    day--;
+    date = new Date(Date.UTC(year, month2, day));
+  }
+  return date;
+}
+function convertLastDayOfMonth(node, opts) {
+  const ref = opts.referenceDate;
+  let month2;
+  let year;
+  if (node.monthFromRef) {
+    month2 = ref.getUTCMonth();
+    year = ref.getUTCFullYear();
+  } else if (node.nextMonth) {
+    month2 = ref.getUTCMonth() + 1;
+    year = ref.getUTCFullYear();
+    if (month2 > 11) {
+      month2 = 0;
+      year++;
+    }
+  } else {
+    month2 = typeof node.month === "number" ? node.month - 1 : ref.getUTCMonth();
+    year = ref.getUTCFullYear();
+    if (month2 < ref.getUTCMonth()) {
+      year++;
+    }
+  }
+  return new Date(Date.UTC(year, month2 + 1, 0));
+}
+function convertDayOnly(node, opts) {
+  const ref = opts.referenceDate;
+  const day = node.day;
+  const refDay = ref.getUTCDate();
+  const refMonth = ref.getUTCMonth();
+  const refYear = ref.getUTCFullYear();
+  let month2 = refMonth;
+  let year = refYear;
+  if (day < refDay) {
+    month2 = refMonth + 1;
+    if (month2 > 11) {
+      month2 = 0;
+      year++;
+    }
+  }
+  let date = new Date(Date.UTC(year, month2, day));
+  while (date.getUTCDate() !== day) {
+    month2++;
+    if (month2 > 11) {
+      month2 = 0;
+      year++;
+    }
+    date = new Date(Date.UTC(year, month2, day));
+  }
+  if (node.time) {
+    applyTime(date, node.time);
+  }
+  return date;
+}
 function convertRelativePeriod(node, opts) {
   const ref = opts.referenceDate;
   const period = node.period.toLowerCase();
@@ -1269,6 +1472,9 @@ function convertDateNode(node, opts) {
   if (node.timeOnly && node.time) {
     return convertTimeOnly(node, opts);
   }
+  if (node.ordinalWeekday !== void 0 && node.weekday !== void 0) {
+    return convertOrdinalWeekdayOfMonth(node, opts);
+  }
   if (node.weekday) {
     return convertWeekday(node, opts);
   }
@@ -1278,6 +1484,23 @@ function convertDateNode(node, opts) {
   if (node.month !== void 0 && node.day !== void 0) {
     return convertMonthDay(node, opts);
   }
+  if (node.dayOnly && node.day !== void 0) {
+    return convertDayOnly(node, opts);
+  }
+  if (node.lastDayOfMonth) {
+    return convertLastDayOfMonth(node, opts);
+  }
+  if (node.dayOfMonth && node.nextMonth) {
+    const ref = opts.referenceDate;
+    let month2 = ref.getUTCMonth() + 1;
+    let year = ref.getUTCFullYear();
+    if (month2 > 11) {
+      month2 = 0;
+      year++;
+    }
+    const day = node.ordinalWeekday || 1;
+    return new Date(Date.UTC(year, month2, day));
+  }
   if (node.relative && node.period) {
     return convertRelativePeriod(node, opts);
   }
@@ -1349,7 +1572,7 @@ function getHalfDates(half2, year, fiscalYearStart) {
   const start = new Date(Date.UTC(startYear, halfStartMonth, 1));
   const endMonth = (halfStartMonth + 6) % 12;
   let endYear = startYear;
-  if (endMonth < halfStartMonth || endMonth === halfStartMonth) {
+  if (endMonth <= halfStartMonth) {
     endYear++;
   }
   const end = new Date(Date.UTC(endYear, endMonth, 0));
@@ -1422,8 +1645,115 @@ function getModifiedPeriod(start, end, modifier) {
 }
 
 // src/converters/fuzzy.ts
+function getWeekendDates(ref, relative, opts) {
+  const currentDay = ref.getUTCDay();
+  const saturdayOffset = (6 - currentDay + 7) % 7;
+  let saturday = new Date(
+    Date.UTC(
+      ref.getUTCFullYear(),
+      ref.getUTCMonth(),
+      ref.getUTCDate() + saturdayOffset
+    )
+  );
+  if (relative === "next") {
+    saturday = new Date(saturday.getTime() + MS_PER_WEEK);
+  } else if (relative === "last") {
+    if (currentDay === 6 || currentDay === 0) {
+      saturday = new Date(saturday.getTime() - MS_PER_WEEK);
+    }
+    saturday = new Date(saturday.getTime() - MS_PER_WEEK);
+  }
+  const sunday = new Date(saturday.getTime() + MS_PER_DAY);
+  const sundayEnd = new Date(
+    Date.UTC(
+      sunday.getUTCFullYear(),
+      sunday.getUTCMonth(),
+      sunday.getUTCDate(),
+      23,
+      59
+    )
+  );
+  return { start: saturday, end: sundayEnd };
+}
+function getNightDates(ref, relative, weekday2) {
+  let baseDate = new Date(ref);
+  if (relative === "last") {
+    baseDate = new Date(
+      Date.UTC(
+        ref.getUTCFullYear(),
+        ref.getUTCMonth(),
+        ref.getUTCDate() - 1
+      )
+    );
+  } else if (relative === "tomorrow") {
+    baseDate = new Date(
+      Date.UTC(
+        ref.getUTCFullYear(),
+        ref.getUTCMonth(),
+        ref.getUTCDate() + 1
+      )
+    );
+  } else if (weekday2) {
+    const targetDay = WEEKDAY_MAP[weekday2.toLowerCase()];
+    if (targetDay !== void 0) {
+      const currentDay = ref.getUTCDay();
+      let daysToAdd = (targetDay - currentDay + 7) % 7;
+      if (daysToAdd === 0) {
+        daysToAdd = 7;
+      }
+      baseDate = new Date(
+        Date.UTC(
+          ref.getUTCFullYear(),
+          ref.getUTCMonth(),
+          ref.getUTCDate() + daysToAdd
+        )
+      );
+    }
+  }
+  const start = new Date(
+    Date.UTC(
+      baseDate.getUTCFullYear(),
+      baseDate.getUTCMonth(),
+      baseDate.getUTCDate(),
+      18,
+      0
+    )
+  );
+  const end = new Date(
+    Date.UTC(
+      baseDate.getUTCFullYear(),
+      baseDate.getUTCMonth(),
+      baseDate.getUTCDate(),
+      23,
+      59
+    )
+  );
+  return { start, end };
+}
 function getBasePeriodDates(node, opts, year) {
   const ref = opts.referenceDate;
+  if (node.period === "weekend") {
+    return getWeekendDates(ref, node.relative || "this", opts);
+  }
+  if (node.period === "tonight") {
+    return getNightDates(ref, void 0, void 0);
+  }
+  if (node.period === "night") {
+    return getNightDates(ref, node.relative, node.weekday);
+  }
+  if (node.period === "fortnight") {
+    const count = node.count || 1;
+    const relative = node.relative;
+    const twoWeeks = 14 * MS_PER_DAY;
+    if (relative === "last") {
+      const end2 = new Date(ref);
+      const start2 = new Date(ref.getTime() - twoWeeks);
+      return { start: start2, end: end2 };
+    }
+    const start = new Date(ref);
+    const end = new Date(ref.getTime() + count * twoWeeks);
+    return { start, end };
+  }
   if (node.period === "quarter" && node.quarter) {
     return getQuarterDates(
       node.quarter,
@@ -1586,7 +1916,7 @@ function convertASTToResult(ast, opts, originalInput) {
           end = new Date(Date.UTC(year, month2 + 1, 0));
         }
         if (endNode.yearOnly) {
-          const year = endNode.year;
+          const year = endNode.year ?? opts.referenceDate.getUTCFullYear();
           end = new Date(Date.UTC(year, 11, 31));
         }
       } else if (endNode.nodeType === "fuzzy") {
@@ -1617,6 +1947,7 @@ function convertASTToResult(ast, opts, originalInput) {
     case "fuzzy": {
       const { start, end } = convertFuzzyNode(expression, opts);
       const mod = expression.modifier;
+      const period = expression.period;
       if (mod === "start" || mod === "beginning") {
         const periodDates = convertFuzzyNodeWithoutModifier(expression, opts);
         return { type: "date", date: periodDates.start, title };
@@ -1625,6 +1956,10 @@ function convertASTToResult(ast, opts, originalInput) {
         const periodDates = convertFuzzyNodeWithoutModifier(expression, opts);
         return { type: "date", date: periodDates.end, title };
       }
+      if (period === "weekend" || period === "night" || period === "tonight" || period === "fortnight") {
+        const duration = end.getTime() - start.getTime();
+        return { type: "span", start, end, duration, title };
+      }
       return { type: "fuzzy", start, end, approximate: true, title };
     }
     case "relative": {
@@ -1641,6 +1976,81 @@ function convertASTToResult(ast, opts, originalInput) {
       }
       return { type: "span", start, end, duration, title };
     }
+    case "relativeDate": {
+      const durationNode = expression.duration;
+      const baseNode = expression.baseDate;
+      const timeSpec = expression.time;
+      let baseDate;
+      if (baseNode) {
+        baseDate = convertDateNode(baseNode, opts);
+      } else {
+        baseDate = new Date(opts.referenceDate);
+      }
+      const durationValue = durationNode.value;
+      const durationUnit = durationNode.unit;
+      const direction = expression.direction === "past" ? -1 : 1;
+      let resultDate;
+      if (durationUnit === "month") {
+        resultDate = new Date(
+          Date.UTC(
+            baseDate.getUTCFullYear(),
+            baseDate.getUTCMonth() + direction * durationValue,
+            baseDate.getUTCDate(),
+            baseDate.getUTCHours(),
+            baseDate.getUTCMinutes()
+          )
+        );
+      } else if (durationUnit === "year") {
+        resultDate = new Date(
+          Date.UTC(
+            baseDate.getUTCFullYear() + direction * durationValue,
+            baseDate.getUTCMonth(),
+            baseDate.getUTCDate(),
+            baseDate.getUTCHours(),
+            baseDate.getUTCMinutes()
+          )
+        );
+      } else {
+        const durationMs = convertDurationNode(durationNode);
+        resultDate = new Date(baseDate.getTime() + direction * durationMs);
+      }
+      if (timeSpec) {
+        if ("special" in timeSpec) {
+          if (timeSpec.special === "noon") {
+            resultDate = new Date(
+              Date.UTC(
+                resultDate.getUTCFullYear(),
+                resultDate.getUTCMonth(),
+                resultDate.getUTCDate(),
+                12,
+                0
+              )
+            );
+          } else if (timeSpec.special === "midnight") {
+            resultDate = new Date(
+              Date.UTC(
+                resultDate.getUTCFullYear(),
+                resultDate.getUTCMonth(),
+                resultDate.getUTCDate(),
+                0,
+                0
+              )
+            );
+          }
+        } else {
+          resultDate = new Date(
+            Date.UTC(
+              resultDate.getUTCFullYear(),
+              resultDate.getUTCMonth(),
+              resultDate.getUTCDate(),
+              timeSpec.hour,
+              timeSpec.minute
+            )
+          );
+        }
+      }
+      return { type: "date", date: resultDate, title };
+    }
     default:
       return null;
   }
@@ -1663,13 +2073,13 @@ function stripUnmatchedPunctuation(input) {
   openParens = (result.match(/\(/g) || []).length;
   closeParens = (result.match(/\)/g) || []).length;
   while (openParens > closeParens) {
-    result = result.replace("(", "");
+    result = result.replace(/\(/, "");
     openParens--;
   }
   openBrackets = (result.match(/\[/g) || []).length;
   closeBrackets = (result.match(/]/g) || []).length;
   while (openBrackets > closeBrackets) {
-    result = result.replace("[", "");
+    result = result.replace(/\[/, "");
     openBrackets--;
   }
   return {