@supercmd/calculator 1.0.0 → 1.0.1

package/dist/index.js

@@ -931,7 +931,7 @@ for (const cat of UNIT_CATEGORIES) {
   }
 }
 function lookupUnit(token) {
-  return _unitIndex.get(token.toLowerCase());
+  return _unitIndex.get(normalizeUnitToken(token));
 }
 function convertUnit(value, from, to) {
   if (from.category !== to.category) {
@@ -946,6 +946,9 @@ function convertUnit(value, from, to) {
   const baseValue = value * from.def.factor;
   return baseValue / to.def.factor;
 }
+function normalizeUnitToken(token) {
+  return token.toLowerCase().trim().replace(/\s+/g, " ").replace(/²/g, "2").replace(/³/g, "3");
+}
 
 // src/data/timezones.ts
 var TIMEZONE_MAP = {
@@ -1018,8 +1021,11 @@ var TIMEZONE_MAP = {
   "buenos aires": "America/Argentina/Buenos_Aires",
   argentina: "America/Argentina/Buenos_Aires",
   lima: "America/Lima",
+  peru: "America/Lima",
   bogota: "America/Bogota",
+  colombia: "America/Bogota",
   santiago: "America/Santiago",
+  chile: "America/Santiago",
   caracas: "America/Caracas",
   quito: "America/Guayaquil",
   // ─── Europe ───────────────────────────────────────────
@@ -1303,6 +1309,9 @@ var COUNTRY_TZ = {
   canada: "America/Toronto",
   mexico: "America/Mexico_City",
   brazil: "America/Sao_Paulo",
+  colombia: "America/Bogota",
+  peru: "America/Lima",
+  chile: "America/Santiago",
   uk: "Europe/London",
   "united kingdom": "Europe/London",
   britain: "Europe/London",
@@ -1373,6 +1382,58 @@ function resolveTimezone(name) {
 }
 
 // src/providers/default.ts
+var STATIC_FIAT_PER_USD = {
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  INR: 83.1,
+  JPY: 150,
+  CNY: 7.2,
+  AUD: 1.52,
+  CAD: 1.35,
+  CHF: 0.88,
+  KRW: 1330,
+  SGD: 1.34,
+  HKD: 7.8,
+  NZD: 1.64,
+  SEK: 10.5,
+  NOK: 10.7,
+  DKK: 6.85,
+  MXN: 17.1,
+  BRL: 5,
+  THB: 35.8,
+  PHP: 56.2,
+  IDR: 15700,
+  MYR: 4.48,
+  ZAR: 18.4,
+  AED: 3.67,
+  SAR: 3.75,
+  TRY: 32.1,
+  PLN: 3.95,
+  CZK: 23.2,
+  RUB: 92
+};
+var STATIC_CRYPTO_USD = {
+  BTC: 92e3,
+  ETH: 3500,
+  SOL: 180,
+  XRP: 2.3,
+  DOGE: 0.18,
+  ADA: 0.8,
+  MATIC: 0.95,
+  DOT: 7.5,
+  LTC: 95,
+  AVAX: 42,
+  LINK: 20,
+  UNI: 12,
+  ATOM: 10,
+  XLM: 0.12,
+  TON: 6,
+  SHIB: 25e-6,
+  BNB: 650,
+  USDT: 1,
+  USDC: 1
+};
 async function fetchJSON(url, timeoutMs = 8e3) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1395,6 +1456,30 @@ async function withFallback(fns) {
   }
   throw lastError ?? new Error("All providers failed");
 }
+async function staticFiatRate(base, target) {
+  const from = STATIC_FIAT_PER_USD[base];
+  const to = STATIC_FIAT_PER_USD[target];
+  if (from === void 0 || to === void 0) {
+    throw new Error(`Static fiat rate unavailable for ${base}/${target}`);
+  }
+  return to / from;
+}
+async function staticCryptoRate(from, to) {
+  const fromCrypto = STATIC_CRYPTO_USD[from];
+  const toCrypto = STATIC_CRYPTO_USD[to];
+  if (fromCrypto !== void 0 && toCrypto !== void 0) {
+    return fromCrypto / toCrypto;
+  }
+  if (fromCrypto !== void 0) {
+    const usdToTarget = await staticFiatRate("USD", to);
+    return fromCrypto * usdToTarget;
+  }
+  if (toCrypto !== void 0) {
+    const fromToUsd = await staticFiatRate(from, "USD");
+    return fromToUsd / toCrypto;
+  }
+  throw new Error(`Static crypto rate unavailable for ${from}/${to}`);
+}
 async function frankfurterRate(base, target) {
   const data = await fetchJSON(
     `https://api.frankfurter.dev/v1/latest?base=${base}&symbols=${target}`
@@ -1644,7 +1729,8 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
     return await withFallback([
       () => coingeckoRate(from, to),
       () => binanceRate(from, to),
-      () => coincapRate(from, to)
+      () => coincapRate(from, to),
+      () => staticCryptoRate(from, to)
     ]);
   } catch {
   }
@@ -1652,7 +1738,8 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
     const cryptoToUsd = await withFallback([
       () => coingeckoRate(from, "USD"),
       () => binanceRate(from, "USDT"),
-      () => coincapRate(from, "USD")
+      () => coincapRate(from, "USD"),
+      () => staticCryptoRate(from, "USD")
     ]);
     if (to === "USD" || to === "USDT" || to === "USDC") return cryptoToUsd;
     const usdToFiat = await getFiat("USD", to);
@@ -1669,11 +1756,12 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
       async () => {
         const p = await coincapRate(to, "USD");
         return p === 0 ? Promise.reject("zero") : 1 / p;
-      }
+      },
+      () => staticCryptoRate("USD", to)
     ]);
     return fiatToUsd * usdToCrypto;
   }
-  throw new Error(`Could not resolve rate for ${from} \u2192 ${to}`);
+  return staticCryptoRate(from, to);
 }
 function createDefaultProvider() {
   return {
@@ -1681,14 +1769,16 @@ function createDefaultProvider() {
       return withFallback([
         () => frankfurterRate(base, target),
         () => exchangeRateApiRate(base, target),
-        () => fawazCurrencyRate(base, target)
+        () => fawazCurrencyRate(base, target),
+        () => staticFiatRate(base, target)
       ]);
     },
     async getCryptoRate(base, target) {
       const getFiat = (b, t) => withFallback([
         () => frankfurterRate(b, t),
         () => exchangeRateApiRate(b, t),
-        () => fawazCurrencyRate(b, t)
+        () => fawazCurrencyRate(b, t),
+        () => staticFiatRate(b, t)
       ]);
       return getCryptoRateWithFiatFallback(base, target, getFiat);
     }
@@ -1697,23 +1787,41 @@ function createDefaultProvider() {
 
 // src/parser/intent.ts
 function detectIntent(input) {
-  const trimmed = input.trim();
+  const trimmed = normalizeWhitespace(input);
   if (!trimmed) {
     return { kind: "math", expression: "0" };
   }
   return tryTimeIntent(trimmed) ?? tryDateIntent(trimmed) ?? tryCurrencyOrCryptoIntent(trimmed) ?? tryUnitIntent(trimmed) ?? { kind: "math", expression: trimmed };
 }
-var TIME_IN_PATTERN = /^(?:what(?:'s| is) )?(?:the )?(?:current )?time (?:in|at) (.+)$/i;
-var TIME_CONVERT_PATTERN = /^(.+?) to (.+?) time$/i;
+var TIME_IN_PATTERNS = [
+  /^(?:what(?:'s| is) )?(?:the )?(?:current )?time (?:in|at) (.+)$/i,
+  /^(?:what time is it|whats the time|what is the time|current time|time now) (?:in|at) (.+)$/i,
+  /^(?:now|current time) in (.+)$/i
+];
+var TIME_EXPLICIT_CONVERT_PATTERN = /^(midnight|noon|\d{1,2}(?::\d{2})?(?:\s*(?:am|pm))?)\s+(.+?)\s+to\s+(.+?)$/i;
+var TIME_CONVERT_PATTERN = /^(.+?) to (.+?)(?: time)?$/i;
 var TIME_NOW_PATTERN = /^(?:what(?:'s| is) )?(?:the )?(?:current )?time(?: now)?$/i;
 function tryTimeIntent(input) {
   let match;
-  match = input.match(TIME_IN_PATTERN);
+  for (const pattern of TIME_IN_PATTERNS) {
+    match = input.match(pattern);
+    if (match) {
+      const place = match[1].trim();
+      const tz2 = resolveTimezone(place);
+      if (tz2) return { kind: "time", query: input, to: tz2 };
+      return { kind: "time", query: input, to: place };
+    }
+  }
+  match = input.match(TIME_EXPLICIT_CONVERT_PATTERN);
   if (match) {
-    const place = match[1].trim();
-    const tz2 = resolveTimezone(place);
-    if (tz2) return { kind: "time", query: place, to: tz2 };
-    return { kind: "time", query: place, to: place };
+    const time = match[1].trim();
+    const from = match[2].trim();
+    const to = match[3].trim();
+    const fromTz = resolveTimezone(from);
+    const toTz = resolveTimezone(to);
+    if (fromTz && toTz) {
+      return { kind: "time", query: input, from: fromTz, to: toTz, time };
+    }
   }
   match = input.match(TIME_CONVERT_PATTERN);
   if (match) {
@@ -1747,11 +1855,12 @@ function tryTimeIntent(input) {
 var DATE_PATTERNS = [
   // Relative dates
   /^(today|now|tomorrow|yesterday)$/i,
+  /^(date|day after tomorrow|day before yesterday)$/i,
   /^(next|last|this)\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|week|month|year)$/i,
   /^(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?|seconds?)\s+(from now|ago|from today|from tomorrow)$/i,
   /^in\s+(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?|seconds?)$/i,
   // Unix timestamp
-  /^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13})$/i,
+  /^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13}|0)$/i,
   /^(?:unix|timestamp|epoch)\s+(\d{10,13})$/i,
   // "to unix" / "to timestamp"
   /^.+\s+(?:to|in)\s+(?:unix|timestamp|epoch)$/i,
@@ -1759,6 +1868,7 @@ var DATE_PATTERNS = [
   /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2})?/,
   // "date" queries
   /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/i,
+  /^(?:(?:what(?:'s|s| is))\s+today|(?:what(?:'s|s| is))\s+today'?s date|what day is it|what date is .+|todays date|today'?s date|date today|current date|what day is .+|when is .+)$/i,
   // Days between dates
   /^(?:days?\s+)?(?:between|from)\s+.+\s+(?:to|and|until)\s+.+$/i
 ];
@@ -1772,7 +1882,8 @@ function tryDateIntent(input) {
 }
 var CONVERSION_PATTERN = /^([\d.,]+)?\s*([a-zA-Z$€£¥₹₩₽₺₦₵₪฿]+(?:\s+[a-zA-Z]+)?)\s+(?:to|in|into|as|=)\s+([a-zA-Z$€£¥₹₩₽₺₦₵₪฿]+(?:\s+[a-zA-Z]+)?)$/i;
 function tryCurrencyOrCryptoIntent(input) {
-  const match = input.match(CONVERSION_PATTERN);
+  const normalized = normalizeConversionInput(input);
+  const match = normalized.match(CONVERSION_PATTERN);
   if (!match) return null;
   const amount = match[1] ? parseFloat(match[1].replace(/,/g, "")) : 1;
   const fromToken = match[2].trim();
@@ -1795,13 +1906,12 @@ function tryCurrencyOrCryptoIntent(input) {
 var UNIT_PATTERN = /^(-?[\d.,]+)\s*([a-zA-Z°/µμ'"²³]+(?:\s+[a-zA-Z]+(?:\s+[a-zA-Z]+)?)?)\s+(?:to|in|into|as|=)\s+([a-zA-Z°/µμ'"²³]+(?:\s+[a-zA-Z]+(?:\s+[a-zA-Z]+)?)?)$/i;
 var UNIT_PATTERN_NO_SPACE = /^(-?[\d.,]+)([a-zA-Z°]+)\s+(?:to|in|into|as)\s+([a-zA-Z°]+(?:\s+[a-zA-Z]+)?)$/i;
 function tryUnitIntent(input) {
-  const match = input.match(UNIT_PATTERN) || input.match(UNIT_PATTERN_NO_SPACE);
+  const normalized = normalizeConversionInput(input);
+  const match = normalized.match(UNIT_PATTERN) || normalized.match(UNIT_PATTERN_NO_SPACE);
   if (!match) return null;
   const amount = parseFloat(match[1].replace(/,/g, ""));
   const fromToken = match[2].trim().toLowerCase();
   const toToken = match[3].trim().toLowerCase();
-  if (resolveFiat(fromToken) || resolveCrypto(fromToken)) return null;
-  if (resolveFiat(toToken) || resolveCrypto(toToken)) return null;
   const fromUnit = lookupUnit(fromToken);
   const toUnit = lookupUnit(toToken);
   if (fromUnit && toUnit && fromUnit.category === toUnit.category) {
@@ -1813,8 +1923,19 @@ function tryUnitIntent(input) {
       category: fromUnit.category.name
     };
   }
+  if (resolveFiat(fromToken) || resolveCrypto(fromToken)) return null;
+  if (resolveFiat(toToken) || resolveCrypto(toToken)) return null;
   return null;
 }
+function normalizeWhitespace(input) {
+  return input.trim().replace(/\s+/g, " ");
+}
+function normalizeConversionInput(input) {
+  let normalized = normalizeWhitespace(input);
+  normalized = normalized.replace(/^convert\s+/i, "").replace(/^how much is\s+/i, "").replace(/^what(?:'s|s| is)\s+/i, "");
+  normalized = normalized.replace(/^([$€£¥₹₩₽₺₦₵₪฿])\s*([\d.,]+)/, "$2 $1");
+  return normalized;
+}
 
 // src/evaluators/math.ts
 var CONSTANTS = {
@@ -1965,19 +2086,10 @@ var Parser = class {
         if (right === 0) throw new Error("Division by zero");
         left /= right;
       } else if (op === "%") {
-        const savedPos = this.pos;
-        this.skipWhitespace();
-        this.pos++;
-        this.skipWhitespace();
-        const next = this.expr[this.pos];
-        if (next === void 0 || /[+\-*/^)|&<>]/.test(next)) {
-          this.pos = savedPos;
-          break;
-        } else {
-          this.pos = savedPos;
-          this.consume();
-          left = left % this.parseExponentiation();
-        }
+        this.consume();
+        left = left % this.parseExponentiation();
+      } else if (op && /[([a-zA-Zπτφ_]/.test(op)) {
+        left *= this.parseExponentiation();
       } else {
         break;
       }
@@ -2019,7 +2131,7 @@ var Parser = class {
       if (this.expr[this.pos] === "!") {
         this.pos++;
         value = factorial(value);
-      } else if (this.expr[this.pos] === "%") {
+      } else if (this.expr[this.pos] === "%" && this.shouldTreatAsPercentage()) {
         this.pos++;
         value = value / 100;
       } else {
@@ -2045,6 +2157,12 @@ var Parser = class {
     }
     throw new Error(`Unexpected character: '${this.expr[this.pos]}' at position ${this.pos}`);
   }
+  shouldTreatAsPercentage() {
+    let i = this.pos + 1;
+    while (i < this.expr.length && /\s/.test(this.expr[i])) i++;
+    const next = this.expr[i];
+    return next === void 0 || /[+\-*/^)%|&<>]/.test(next);
+  }
   charAt(i) {
     return i < this.expr.length ? this.expr[i] : "";
   }
@@ -2088,13 +2206,15 @@ var Parser = class {
     const name = this.expr.slice(start, this.pos).toLowerCase();
     this.skipWhitespace();
     if (this.expr[this.pos] === "(") {
+      if (name === "max" || name === "min") {
+        const args = this.parseArguments();
+        if (args.length === 0) throw new Error(`Function '${name}' requires at least one argument`);
+        return name === "max" ? Math.max(...args) : Math.min(...args);
+      }
       if (FUNCTIONS2[name]) {
-        this.consume("(");
-        const a = this.parseBitwiseOr();
-        this.consume(",");
-        const b = this.parseBitwiseOr();
-        this.consume(")");
-        return FUNCTIONS2[name](a, b);
+        const args = this.parseArguments();
+        if (args.length !== 2) throw new Error(`Function '${name}' expects 2 arguments`);
+        return FUNCTIONS2[name](args[0], args[1]);
       }
       if (FUNCTIONS[name]) {
         this.consume("(");
@@ -2107,6 +2227,26 @@ var Parser = class {
     if (CONSTANTS[name] !== void 0) return CONSTANTS[name];
     throw new Error(`Unknown identifier: '${name}'`);
   }
+  parseArguments() {
+    const args = [];
+    this.consume("(");
+    this.skipWhitespace();
+    if (this.expr[this.pos] === ")") {
+      this.consume(")");
+      return args;
+    }
+    while (true) {
+      args.push(this.parseBitwiseOr());
+      this.skipWhitespace();
+      if (this.expr[this.pos] === ",") {
+        this.pos++;
+        continue;
+      }
+      break;
+    }
+    this.consume(")");
+    return args;
+  }
 };
 function factorial(n) {
   if (n < 0) throw new Error("Factorial of negative number");
@@ -2118,7 +2258,8 @@ function factorial(n) {
 }
 function evaluateMath(expression, locale = "en-US", precision = 10) {
   try {
-    const parser = new Parser(expression);
+    const normalizedExpression = normalizeMathExpression(expression);
+    const parser = new Parser(normalizedExpression);
     const result = parser.parse();
     let formatted;
     if (Number.isInteger(result) && Math.abs(result) < Number.MAX_SAFE_INTEGER) {
@@ -2143,7 +2284,10 @@ function evaluateMath(expression, locale = "en-US", precision = 10) {
       input: expression,
       result,
       formatted,
-      metadata
+      metadata: {
+        ...metadata,
+        normalizedExpression
+      }
     };
   } catch (err) {
     return {
@@ -2153,6 +2297,41 @@ function evaluateMath(expression, locale = "en-US", precision = 10) {
     };
   }
 }
+function normalizeMathExpression(expression) {
+  let normalized = expression.trim().replace(/\s+/g, " ");
+  normalized = normalized.replace(/^(?:(?:what(?:'s|s| is))\s+the\s+|(?:what(?:'s|s| is))\s+|calculate\s+)/i, "");
+  normalized = normalized.replace(/^the\s+/i, "");
+  const wrappers = [
+    [/^square root of (.+)$/i, "sqrt($1)"],
+    [/^cube root of (.+)$/i, "cbrt($1)"],
+    [/^log of (.+)$/i, "log($1)"],
+    [/^sine of (.+)$/i, "sin($1)"],
+    [/^cosine of (.+)$/i, "cos($1)"],
+    [/^tangent of (.+)$/i, "tan($1)"],
+    [/^absolute value of (.+)$/i, "abs($1)"],
+    [/^factorial of (.+)$/i, "($1)!"],
+    [/^half of (.+)$/i, "($1) / 2"],
+    [/^double (.+)$/i, "2 * ($1)"],
+    [/^triple (.+)$/i, "3 * ($1)"],
+    [/^one third of (.+)$/i, "($1) / 3"],
+    [/^one quarter of (.+)$/i, "($1) / 4"],
+    [/^remainder of (.+?) divided by (.+)$/i, "($1) % ($2)"],
+    [/^(.+?) to the power of (.+)$/i, "($1) ^ ($2)"],
+    [/^(.+?) raised to (.+)$/i, "($1) ^ ($2)"],
+    [/^(.+?) squared$/i, "($1) ^ 2"],
+    [/^(.+?) cubed$/i, "($1) ^ 3"],
+    [/^(\d+(?:\.\d+)?) percent of (.+)$/i, "($1%) * ($2)"],
+    [/^(.+?%) of (.+)$/i, "($1) * ($2)"]
+  ];
+  for (const [pattern, replacement] of wrappers) {
+    if (pattern.test(normalized)) {
+      normalized = normalized.replace(pattern, replacement);
+      break;
+    }
+  }
+  normalized = normalized.replace(/\bdivided by\b/gi, "/").replace(/\btimes\b/gi, "*").replace(/\bplus\b/gi, "+").replace(/\bminus\b/gi, "-");
+  return normalized.replace(/\s+/g, " ").trim();
+}
 
 // src/evaluators/unit.ts
 function evaluateUnit(amount, fromToken, toToken, locale = "en-US", precision = 10) {
@@ -2190,7 +2369,7 @@ function evaluateUnit(amount, fromToken, toToken, locale = "en-US", precision =
 }
 
 // src/evaluators/time.ts
-function evaluateTime(query, fromTz, toTz, localTz) {
+function evaluateTime(query, fromTz, toTz, explicitTime, localTz) {
   const now = /* @__PURE__ */ new Date();
   const userTz = localTz ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
   try {
@@ -2223,18 +2402,20 @@ function evaluateTime(query, fromTz, toTz, localTz) {
       const resolvedFrom = resolveTimezone(fromTz) ?? fromTz;
       const resolvedTo = resolveTimezone(toTz) ?? toTz;
       try {
-        const fromTime = formatTimeInZone(now, resolvedFrom);
-        const toTime = formatTimeInZone(now, resolvedTo);
-        const formatted = `${fromTime} \u2192 ${toTime}`;
+        const sourceDate = explicitTime ? buildDateInZone(explicitTime, resolvedFrom, now) : now;
+        const fromTime = explicitTime ? `${explicitTime} (${getShortTzName(resolvedFrom)})` : formatTimeInZone(sourceDate, resolvedFrom);
+        const toTime = formatTimeInZone(sourceDate, resolvedTo);
+        const formatted = toTime;
         return {
           type: "time",
           input: query,
           result: formatted,
           formatted,
           metadata: {
+            explicitTime,
             from: { timezone: resolvedFrom, time: fromTime },
             to: { timezone: resolvedTo, time: toTime },
-            iso: now.toISOString()
+            iso: sourceDate.toISOString()
           }
         };
       } catch {
@@ -2254,6 +2435,55 @@ function evaluateTime(query, fromTz, toTz, localTz) {
     };
   }
 }
+function buildDateInZone(timeExpression, timezone, anchor) {
+  const { hour, minute } = parseTimeExpression(timeExpression);
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(anchor);
+  const year = Number(parts.find((p) => p.type === "year")?.value);
+  const month = Number(parts.find((p) => p.type === "month")?.value);
+  const day = Number(parts.find((p) => p.type === "day")?.value);
+  const utcGuess = new Date(Date.UTC(year, month - 1, day, hour, minute, 0));
+  const offset = getTimeZoneOffsetMs(utcGuess, timezone);
+  return new Date(utcGuess.getTime() - offset);
+}
+function parseTimeExpression(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "midnight") return { hour: 0, minute: 0 };
+  if (trimmed === "noon") return { hour: 12, minute: 0 };
+  const match = trimmed.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (!match) throw new Error(`Invalid time: '${value}'`);
+  let hour = parseInt(match[1], 10);
+  const minute = parseInt(match[2] ?? "0", 10);
+  const meridiem = match[3];
+  if (meridiem === "am" && hour === 12) hour = 0;
+  if (meridiem === "pm" && hour < 12) hour += 12;
+  if (hour > 23 || minute > 59) throw new Error(`Invalid time: '${value}'`);
+  return { hour, minute };
+}
+function getTimeZoneOffsetMs(date, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).formatToParts(date);
+  const year = Number(parts.find((p) => p.type === "year")?.value);
+  const month = Number(parts.find((p) => p.type === "month")?.value);
+  const day = Number(parts.find((p) => p.type === "day")?.value);
+  const rawHour = Number(parts.find((p) => p.type === "hour")?.value);
+  const hour = rawHour % 24;
+  const minute = Number(parts.find((p) => p.type === "minute")?.value);
+  const second = Number(parts.find((p) => p.type === "second")?.value);
+  return Date.UTC(year, month - 1, day, hour, minute, second) - date.getTime();
+}
 function formatTimeInZone(date, timezone) {
   const timePart = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
@@ -2290,7 +2520,7 @@ var DAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday
 function evaluateDate(query) {
   const lower = query.toLowerCase().trim();
   try {
-    if (lower === "today" || lower === "now" || /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/.test(lower)) {
+    if (lower === "today" || lower === "now" || lower === "date" || /^(?:(?:what(?:'s|s| is))\s+today|(?:what(?:'s|s| is))\s+today'?s date|what day is it|todays date|today'?s date|date today|current date|what is the date today)$/.test(lower) || /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/.test(lower)) {
       return formatDateResult(query, /* @__PURE__ */ new Date());
     }
     if (lower === "tomorrow") {
@@ -2303,6 +2533,26 @@ function evaluateDate(query) {
       d.setDate(d.getDate() - 1);
       return formatDateResult(query, d);
     }
+    if (lower === "day after tomorrow") {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() + 2);
+      return formatDateResult(query, d);
+    }
+    if (lower === "day before yesterday") {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() - 2);
+      return formatDateResult(query, d);
+    }
+    const whatDateMatch = lower.match(/^what date is (.+)$/);
+    if (whatDateMatch) {
+      const d = parseFlexibleDate(whatDateMatch[1]);
+      if (d) return formatDateResult(query, d);
+    }
+    const whenIsMatch = lower.match(/^(?:what day is|when is)\s+(.+)$/);
+    if (whenIsMatch) {
+      const d = parseFlexibleDate(whenIsMatch[1]);
+      if (d) return formatDateResult(query, d);
+    }
     const nextLastMatch = lower.match(/^(next|last|this)\s+(.+)$/);
     if (nextLastMatch) {
       const direction = nextLastMatch[1];
@@ -2350,7 +2600,7 @@ function evaluateDate(query) {
       const d = applyOffset(/* @__PURE__ */ new Date(), amount, unit);
       return formatDateResult(query, d);
     }
-    const unixMatch = lower.match(/^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13})$/);
+    const unixMatch = lower.match(/^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13}|0)$/);
     if (unixMatch) {
       const ts = parseInt(unixMatch[1]);
       const ms = ts > 9999999999 ? ts : ts * 1e3;
@@ -2370,14 +2620,11 @@ function evaluateDate(query) {
     if (toUnixMatch) {
       const dateStr = toUnixMatch[1].trim();
       let d;
-      if (dateStr === "now" || dateStr === "today") {
-        d = /* @__PURE__ */ new Date();
-      } else {
-        d = new Date(dateStr);
-      }
-      if (isNaN(d.getTime())) {
+      const parsed = parseFlexibleDate(dateStr);
+      if (!parsed) {
         return { type: "error", input: query, error: `Cannot parse date: '${dateStr}'` };
       }
+      d = parsed;
       const unix = Math.floor(d.getTime() / 1e3);
       return {
         type: "date",
@@ -2486,7 +2733,7 @@ function formatDateResult(input, d, extraMeta) {
   };
 }
 function parseFlexibleDate(str) {
-  if (str === "today" || str === "now") return /* @__PURE__ */ new Date();
+  if (str === "today" || str === "now" || str === "date") return /* @__PURE__ */ new Date();
   if (str === "tomorrow") {
     const d2 = /* @__PURE__ */ new Date();
     d2.setDate(d2.getDate() + 1);
@@ -2497,6 +2744,22 @@ function parseFlexibleDate(str) {
     d2.setDate(d2.getDate() - 1);
     return d2;
   }
+  if (str === "day after tomorrow") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() + 2);
+    return d2;
+  }
+  if (str === "day before yesterday") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() - 2);
+    return d2;
+  }
+  const relativeDay = str.match(/^(next|last|this)\s+(.+)$/);
+  if (relativeDay) {
+    const direction = relativeDay[1];
+    const dayIndex = DAY_NAMES.indexOf(relativeDay[2]);
+    if (dayIndex !== -1) return getRelativeDay(dayIndex, direction);
+  }
   const d = new Date(str);
   return isNaN(d.getTime()) ? null : d;
 }
@@ -2614,6 +2877,7 @@ async function calculate(input, options) {
         intent.query,
         intent.from,
         intent.to,
+        intent.time,
         options?.timezone
       );
     case "date":

package/dist/index.mjs

@@ -894,7 +894,7 @@ for (const cat of UNIT_CATEGORIES) {
   }
 }
 function lookupUnit(token) {
-  return _unitIndex.get(token.toLowerCase());
+  return _unitIndex.get(normalizeUnitToken(token));
 }
 function convertUnit(value, from, to) {
   if (from.category !== to.category) {
@@ -909,6 +909,9 @@ function convertUnit(value, from, to) {
   const baseValue = value * from.def.factor;
   return baseValue / to.def.factor;
 }
+function normalizeUnitToken(token) {
+  return token.toLowerCase().trim().replace(/\s+/g, " ").replace(/²/g, "2").replace(/³/g, "3");
+}
 
 // src/data/timezones.ts
 var TIMEZONE_MAP = {
@@ -981,8 +984,11 @@ var TIMEZONE_MAP = {
   "buenos aires": "America/Argentina/Buenos_Aires",
   argentina: "America/Argentina/Buenos_Aires",
   lima: "America/Lima",
+  peru: "America/Lima",
   bogota: "America/Bogota",
+  colombia: "America/Bogota",
   santiago: "America/Santiago",
+  chile: "America/Santiago",
   caracas: "America/Caracas",
   quito: "America/Guayaquil",
   // ─── Europe ───────────────────────────────────────────
@@ -1266,6 +1272,9 @@ var COUNTRY_TZ = {
   canada: "America/Toronto",
   mexico: "America/Mexico_City",
   brazil: "America/Sao_Paulo",
+  colombia: "America/Bogota",
+  peru: "America/Lima",
+  chile: "America/Santiago",
   uk: "Europe/London",
   "united kingdom": "Europe/London",
   britain: "Europe/London",
@@ -1336,6 +1345,58 @@ function resolveTimezone(name) {
 }
 
 // src/providers/default.ts
+var STATIC_FIAT_PER_USD = {
+  USD: 1,
+  EUR: 0.92,
+  GBP: 0.79,
+  INR: 83.1,
+  JPY: 150,
+  CNY: 7.2,
+  AUD: 1.52,
+  CAD: 1.35,
+  CHF: 0.88,
+  KRW: 1330,
+  SGD: 1.34,
+  HKD: 7.8,
+  NZD: 1.64,
+  SEK: 10.5,
+  NOK: 10.7,
+  DKK: 6.85,
+  MXN: 17.1,
+  BRL: 5,
+  THB: 35.8,
+  PHP: 56.2,
+  IDR: 15700,
+  MYR: 4.48,
+  ZAR: 18.4,
+  AED: 3.67,
+  SAR: 3.75,
+  TRY: 32.1,
+  PLN: 3.95,
+  CZK: 23.2,
+  RUB: 92
+};
+var STATIC_CRYPTO_USD = {
+  BTC: 92e3,
+  ETH: 3500,
+  SOL: 180,
+  XRP: 2.3,
+  DOGE: 0.18,
+  ADA: 0.8,
+  MATIC: 0.95,
+  DOT: 7.5,
+  LTC: 95,
+  AVAX: 42,
+  LINK: 20,
+  UNI: 12,
+  ATOM: 10,
+  XLM: 0.12,
+  TON: 6,
+  SHIB: 25e-6,
+  BNB: 650,
+  USDT: 1,
+  USDC: 1
+};
 async function fetchJSON(url, timeoutMs = 8e3) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1358,6 +1419,30 @@ async function withFallback(fns) {
   }
   throw lastError ?? new Error("All providers failed");
 }
+async function staticFiatRate(base, target) {
+  const from = STATIC_FIAT_PER_USD[base];
+  const to = STATIC_FIAT_PER_USD[target];
+  if (from === void 0 || to === void 0) {
+    throw new Error(`Static fiat rate unavailable for ${base}/${target}`);
+  }
+  return to / from;
+}
+async function staticCryptoRate(from, to) {
+  const fromCrypto = STATIC_CRYPTO_USD[from];
+  const toCrypto = STATIC_CRYPTO_USD[to];
+  if (fromCrypto !== void 0 && toCrypto !== void 0) {
+    return fromCrypto / toCrypto;
+  }
+  if (fromCrypto !== void 0) {
+    const usdToTarget = await staticFiatRate("USD", to);
+    return fromCrypto * usdToTarget;
+  }
+  if (toCrypto !== void 0) {
+    const fromToUsd = await staticFiatRate(from, "USD");
+    return fromToUsd / toCrypto;
+  }
+  throw new Error(`Static crypto rate unavailable for ${from}/${to}`);
+}
 async function frankfurterRate(base, target) {
   const data = await fetchJSON(
     `https://api.frankfurter.dev/v1/latest?base=${base}&symbols=${target}`
@@ -1607,7 +1692,8 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
     return await withFallback([
       () => coingeckoRate(from, to),
       () => binanceRate(from, to),
-      () => coincapRate(from, to)
+      () => coincapRate(from, to),
+      () => staticCryptoRate(from, to)
     ]);
   } catch {
   }
@@ -1615,7 +1701,8 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
     const cryptoToUsd = await withFallback([
       () => coingeckoRate(from, "USD"),
       () => binanceRate(from, "USDT"),
-      () => coincapRate(from, "USD")
+      () => coincapRate(from, "USD"),
+      () => staticCryptoRate(from, "USD")
     ]);
     if (to === "USD" || to === "USDT" || to === "USDC") return cryptoToUsd;
     const usdToFiat = await getFiat("USD", to);
@@ -1632,11 +1719,12 @@ async function getCryptoRateWithFiatFallback(from, to, getFiat) {
       async () => {
         const p = await coincapRate(to, "USD");
         return p === 0 ? Promise.reject("zero") : 1 / p;
-      }
+      },
+      () => staticCryptoRate("USD", to)
     ]);
     return fiatToUsd * usdToCrypto;
   }
-  throw new Error(`Could not resolve rate for ${from} \u2192 ${to}`);
+  return staticCryptoRate(from, to);
 }
 function createDefaultProvider() {
   return {
@@ -1644,14 +1732,16 @@ function createDefaultProvider() {
       return withFallback([
         () => frankfurterRate(base, target),
         () => exchangeRateApiRate(base, target),
-        () => fawazCurrencyRate(base, target)
+        () => fawazCurrencyRate(base, target),
+        () => staticFiatRate(base, target)
       ]);
     },
     async getCryptoRate(base, target) {
       const getFiat = (b, t) => withFallback([
         () => frankfurterRate(b, t),
         () => exchangeRateApiRate(b, t),
-        () => fawazCurrencyRate(b, t)
+        () => fawazCurrencyRate(b, t),
+        () => staticFiatRate(b, t)
       ]);
       return getCryptoRateWithFiatFallback(base, target, getFiat);
     }
@@ -1660,23 +1750,41 @@ function createDefaultProvider() {
 
 // src/parser/intent.ts
 function detectIntent(input) {
-  const trimmed = input.trim();
+  const trimmed = normalizeWhitespace(input);
   if (!trimmed) {
     return { kind: "math", expression: "0" };
   }
   return tryTimeIntent(trimmed) ?? tryDateIntent(trimmed) ?? tryCurrencyOrCryptoIntent(trimmed) ?? tryUnitIntent(trimmed) ?? { kind: "math", expression: trimmed };
 }
-var TIME_IN_PATTERN = /^(?:what(?:'s| is) )?(?:the )?(?:current )?time (?:in|at) (.+)$/i;
-var TIME_CONVERT_PATTERN = /^(.+?) to (.+?) time$/i;
+var TIME_IN_PATTERNS = [
+  /^(?:what(?:'s| is) )?(?:the )?(?:current )?time (?:in|at) (.+)$/i,
+  /^(?:what time is it|whats the time|what is the time|current time|time now) (?:in|at) (.+)$/i,
+  /^(?:now|current time) in (.+)$/i
+];
+var TIME_EXPLICIT_CONVERT_PATTERN = /^(midnight|noon|\d{1,2}(?::\d{2})?(?:\s*(?:am|pm))?)\s+(.+?)\s+to\s+(.+?)$/i;
+var TIME_CONVERT_PATTERN = /^(.+?) to (.+?)(?: time)?$/i;
 var TIME_NOW_PATTERN = /^(?:what(?:'s| is) )?(?:the )?(?:current )?time(?: now)?$/i;
 function tryTimeIntent(input) {
   let match;
-  match = input.match(TIME_IN_PATTERN);
+  for (const pattern of TIME_IN_PATTERNS) {
+    match = input.match(pattern);
+    if (match) {
+      const place = match[1].trim();
+      const tz2 = resolveTimezone(place);
+      if (tz2) return { kind: "time", query: input, to: tz2 };
+      return { kind: "time", query: input, to: place };
+    }
+  }
+  match = input.match(TIME_EXPLICIT_CONVERT_PATTERN);
   if (match) {
-    const place = match[1].trim();
-    const tz2 = resolveTimezone(place);
-    if (tz2) return { kind: "time", query: place, to: tz2 };
-    return { kind: "time", query: place, to: place };
+    const time = match[1].trim();
+    const from = match[2].trim();
+    const to = match[3].trim();
+    const fromTz = resolveTimezone(from);
+    const toTz = resolveTimezone(to);
+    if (fromTz && toTz) {
+      return { kind: "time", query: input, from: fromTz, to: toTz, time };
+    }
   }
   match = input.match(TIME_CONVERT_PATTERN);
   if (match) {
@@ -1710,11 +1818,12 @@ function tryTimeIntent(input) {
 var DATE_PATTERNS = [
   // Relative dates
   /^(today|now|tomorrow|yesterday)$/i,
+  /^(date|day after tomorrow|day before yesterday)$/i,
   /^(next|last|this)\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|week|month|year)$/i,
   /^(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?|seconds?)\s+(from now|ago|from today|from tomorrow)$/i,
   /^in\s+(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?|seconds?)$/i,
   // Unix timestamp
-  /^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13})$/i,
+  /^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13}|0)$/i,
   /^(?:unix|timestamp|epoch)\s+(\d{10,13})$/i,
   // "to unix" / "to timestamp"
   /^.+\s+(?:to|in)\s+(?:unix|timestamp|epoch)$/i,
@@ -1722,6 +1831,7 @@ var DATE_PATTERNS = [
   /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2})?/,
   // "date" queries
   /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/i,
+  /^(?:(?:what(?:'s|s| is))\s+today|(?:what(?:'s|s| is))\s+today'?s date|what day is it|what date is .+|todays date|today'?s date|date today|current date|what day is .+|when is .+)$/i,
   // Days between dates
   /^(?:days?\s+)?(?:between|from)\s+.+\s+(?:to|and|until)\s+.+$/i
 ];
@@ -1735,7 +1845,8 @@ function tryDateIntent(input) {
 }
 var CONVERSION_PATTERN = /^([\d.,]+)?\s*([a-zA-Z$€£¥₹₩₽₺₦₵₪฿]+(?:\s+[a-zA-Z]+)?)\s+(?:to|in|into|as|=)\s+([a-zA-Z$€£¥₹₩₽₺₦₵₪฿]+(?:\s+[a-zA-Z]+)?)$/i;
 function tryCurrencyOrCryptoIntent(input) {
-  const match = input.match(CONVERSION_PATTERN);
+  const normalized = normalizeConversionInput(input);
+  const match = normalized.match(CONVERSION_PATTERN);
   if (!match) return null;
   const amount = match[1] ? parseFloat(match[1].replace(/,/g, "")) : 1;
   const fromToken = match[2].trim();
@@ -1758,13 +1869,12 @@ function tryCurrencyOrCryptoIntent(input) {
 var UNIT_PATTERN = /^(-?[\d.,]+)\s*([a-zA-Z°/µμ'"²³]+(?:\s+[a-zA-Z]+(?:\s+[a-zA-Z]+)?)?)\s+(?:to|in|into|as|=)\s+([a-zA-Z°/µμ'"²³]+(?:\s+[a-zA-Z]+(?:\s+[a-zA-Z]+)?)?)$/i;
 var UNIT_PATTERN_NO_SPACE = /^(-?[\d.,]+)([a-zA-Z°]+)\s+(?:to|in|into|as)\s+([a-zA-Z°]+(?:\s+[a-zA-Z]+)?)$/i;
 function tryUnitIntent(input) {
-  const match = input.match(UNIT_PATTERN) || input.match(UNIT_PATTERN_NO_SPACE);
+  const normalized = normalizeConversionInput(input);
+  const match = normalized.match(UNIT_PATTERN) || normalized.match(UNIT_PATTERN_NO_SPACE);
   if (!match) return null;
   const amount = parseFloat(match[1].replace(/,/g, ""));
   const fromToken = match[2].trim().toLowerCase();
   const toToken = match[3].trim().toLowerCase();
-  if (resolveFiat(fromToken) || resolveCrypto(fromToken)) return null;
-  if (resolveFiat(toToken) || resolveCrypto(toToken)) return null;
   const fromUnit = lookupUnit(fromToken);
   const toUnit = lookupUnit(toToken);
   if (fromUnit && toUnit && fromUnit.category === toUnit.category) {
@@ -1776,8 +1886,19 @@ function tryUnitIntent(input) {
       category: fromUnit.category.name
     };
   }
+  if (resolveFiat(fromToken) || resolveCrypto(fromToken)) return null;
+  if (resolveFiat(toToken) || resolveCrypto(toToken)) return null;
   return null;
 }
+function normalizeWhitespace(input) {
+  return input.trim().replace(/\s+/g, " ");
+}
+function normalizeConversionInput(input) {
+  let normalized = normalizeWhitespace(input);
+  normalized = normalized.replace(/^convert\s+/i, "").replace(/^how much is\s+/i, "").replace(/^what(?:'s|s| is)\s+/i, "");
+  normalized = normalized.replace(/^([$€£¥₹₩₽₺₦₵₪฿])\s*([\d.,]+)/, "$2 $1");
+  return normalized;
+}
 
 // src/evaluators/math.ts
 var CONSTANTS = {
@@ -1928,19 +2049,10 @@ var Parser = class {
         if (right === 0) throw new Error("Division by zero");
         left /= right;
       } else if (op === "%") {
-        const savedPos = this.pos;
-        this.skipWhitespace();
-        this.pos++;
-        this.skipWhitespace();
-        const next = this.expr[this.pos];
-        if (next === void 0 || /[+\-*/^)|&<>]/.test(next)) {
-          this.pos = savedPos;
-          break;
-        } else {
-          this.pos = savedPos;
-          this.consume();
-          left = left % this.parseExponentiation();
-        }
+        this.consume();
+        left = left % this.parseExponentiation();
+      } else if (op && /[([a-zA-Zπτφ_]/.test(op)) {
+        left *= this.parseExponentiation();
       } else {
         break;
       }
@@ -1982,7 +2094,7 @@ var Parser = class {
       if (this.expr[this.pos] === "!") {
         this.pos++;
         value = factorial(value);
-      } else if (this.expr[this.pos] === "%") {
+      } else if (this.expr[this.pos] === "%" && this.shouldTreatAsPercentage()) {
         this.pos++;
         value = value / 100;
       } else {
@@ -2008,6 +2120,12 @@ var Parser = class {
     }
     throw new Error(`Unexpected character: '${this.expr[this.pos]}' at position ${this.pos}`);
   }
+  shouldTreatAsPercentage() {
+    let i = this.pos + 1;
+    while (i < this.expr.length && /\s/.test(this.expr[i])) i++;
+    const next = this.expr[i];
+    return next === void 0 || /[+\-*/^)%|&<>]/.test(next);
+  }
   charAt(i) {
     return i < this.expr.length ? this.expr[i] : "";
   }
@@ -2051,13 +2169,15 @@ var Parser = class {
     const name = this.expr.slice(start, this.pos).toLowerCase();
     this.skipWhitespace();
     if (this.expr[this.pos] === "(") {
+      if (name === "max" || name === "min") {
+        const args = this.parseArguments();
+        if (args.length === 0) throw new Error(`Function '${name}' requires at least one argument`);
+        return name === "max" ? Math.max(...args) : Math.min(...args);
+      }
       if (FUNCTIONS2[name]) {
-        this.consume("(");
-        const a = this.parseBitwiseOr();
-        this.consume(",");
-        const b = this.parseBitwiseOr();
-        this.consume(")");
-        return FUNCTIONS2[name](a, b);
+        const args = this.parseArguments();
+        if (args.length !== 2) throw new Error(`Function '${name}' expects 2 arguments`);
+        return FUNCTIONS2[name](args[0], args[1]);
       }
       if (FUNCTIONS[name]) {
         this.consume("(");
@@ -2070,6 +2190,26 @@ var Parser = class {
     if (CONSTANTS[name] !== void 0) return CONSTANTS[name];
     throw new Error(`Unknown identifier: '${name}'`);
   }
+  parseArguments() {
+    const args = [];
+    this.consume("(");
+    this.skipWhitespace();
+    if (this.expr[this.pos] === ")") {
+      this.consume(")");
+      return args;
+    }
+    while (true) {
+      args.push(this.parseBitwiseOr());
+      this.skipWhitespace();
+      if (this.expr[this.pos] === ",") {
+        this.pos++;
+        continue;
+      }
+      break;
+    }
+    this.consume(")");
+    return args;
+  }
 };
 function factorial(n) {
   if (n < 0) throw new Error("Factorial of negative number");
@@ -2081,7 +2221,8 @@ function factorial(n) {
 }
 function evaluateMath(expression, locale = "en-US", precision = 10) {
   try {
-    const parser = new Parser(expression);
+    const normalizedExpression = normalizeMathExpression(expression);
+    const parser = new Parser(normalizedExpression);
     const result = parser.parse();
     let formatted;
     if (Number.isInteger(result) && Math.abs(result) < Number.MAX_SAFE_INTEGER) {
@@ -2106,7 +2247,10 @@ function evaluateMath(expression, locale = "en-US", precision = 10) {
       input: expression,
       result,
       formatted,
-      metadata
+      metadata: {
+        ...metadata,
+        normalizedExpression
+      }
     };
   } catch (err) {
     return {
@@ -2116,6 +2260,41 @@ function evaluateMath(expression, locale = "en-US", precision = 10) {
     };
   }
 }
+function normalizeMathExpression(expression) {
+  let normalized = expression.trim().replace(/\s+/g, " ");
+  normalized = normalized.replace(/^(?:(?:what(?:'s|s| is))\s+the\s+|(?:what(?:'s|s| is))\s+|calculate\s+)/i, "");
+  normalized = normalized.replace(/^the\s+/i, "");
+  const wrappers = [
+    [/^square root of (.+)$/i, "sqrt($1)"],
+    [/^cube root of (.+)$/i, "cbrt($1)"],
+    [/^log of (.+)$/i, "log($1)"],
+    [/^sine of (.+)$/i, "sin($1)"],
+    [/^cosine of (.+)$/i, "cos($1)"],
+    [/^tangent of (.+)$/i, "tan($1)"],
+    [/^absolute value of (.+)$/i, "abs($1)"],
+    [/^factorial of (.+)$/i, "($1)!"],
+    [/^half of (.+)$/i, "($1) / 2"],
+    [/^double (.+)$/i, "2 * ($1)"],
+    [/^triple (.+)$/i, "3 * ($1)"],
+    [/^one third of (.+)$/i, "($1) / 3"],
+    [/^one quarter of (.+)$/i, "($1) / 4"],
+    [/^remainder of (.+?) divided by (.+)$/i, "($1) % ($2)"],
+    [/^(.+?) to the power of (.+)$/i, "($1) ^ ($2)"],
+    [/^(.+?) raised to (.+)$/i, "($1) ^ ($2)"],
+    [/^(.+?) squared$/i, "($1) ^ 2"],
+    [/^(.+?) cubed$/i, "($1) ^ 3"],
+    [/^(\d+(?:\.\d+)?) percent of (.+)$/i, "($1%) * ($2)"],
+    [/^(.+?%) of (.+)$/i, "($1) * ($2)"]
+  ];
+  for (const [pattern, replacement] of wrappers) {
+    if (pattern.test(normalized)) {
+      normalized = normalized.replace(pattern, replacement);
+      break;
+    }
+  }
+  normalized = normalized.replace(/\bdivided by\b/gi, "/").replace(/\btimes\b/gi, "*").replace(/\bplus\b/gi, "+").replace(/\bminus\b/gi, "-");
+  return normalized.replace(/\s+/g, " ").trim();
+}
 
 // src/evaluators/unit.ts
 function evaluateUnit(amount, fromToken, toToken, locale = "en-US", precision = 10) {
@@ -2153,7 +2332,7 @@ function evaluateUnit(amount, fromToken, toToken, locale = "en-US", precision =
 }
 
 // src/evaluators/time.ts
-function evaluateTime(query, fromTz, toTz, localTz) {
+function evaluateTime(query, fromTz, toTz, explicitTime, localTz) {
   const now = /* @__PURE__ */ new Date();
   const userTz = localTz ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
   try {
@@ -2186,18 +2365,20 @@ function evaluateTime(query, fromTz, toTz, localTz) {
       const resolvedFrom = resolveTimezone(fromTz) ?? fromTz;
       const resolvedTo = resolveTimezone(toTz) ?? toTz;
       try {
-        const fromTime = formatTimeInZone(now, resolvedFrom);
-        const toTime = formatTimeInZone(now, resolvedTo);
-        const formatted = `${fromTime} \u2192 ${toTime}`;
+        const sourceDate = explicitTime ? buildDateInZone(explicitTime, resolvedFrom, now) : now;
+        const fromTime = explicitTime ? `${explicitTime} (${getShortTzName(resolvedFrom)})` : formatTimeInZone(sourceDate, resolvedFrom);
+        const toTime = formatTimeInZone(sourceDate, resolvedTo);
+        const formatted = toTime;
         return {
           type: "time",
           input: query,
           result: formatted,
           formatted,
           metadata: {
+            explicitTime,
             from: { timezone: resolvedFrom, time: fromTime },
             to: { timezone: resolvedTo, time: toTime },
-            iso: now.toISOString()
+            iso: sourceDate.toISOString()
           }
         };
       } catch {
@@ -2217,6 +2398,55 @@ function evaluateTime(query, fromTz, toTz, localTz) {
     };
   }
 }
+function buildDateInZone(timeExpression, timezone, anchor) {
+  const { hour, minute } = parseTimeExpression(timeExpression);
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(anchor);
+  const year = Number(parts.find((p) => p.type === "year")?.value);
+  const month = Number(parts.find((p) => p.type === "month")?.value);
+  const day = Number(parts.find((p) => p.type === "day")?.value);
+  const utcGuess = new Date(Date.UTC(year, month - 1, day, hour, minute, 0));
+  const offset = getTimeZoneOffsetMs(utcGuess, timezone);
+  return new Date(utcGuess.getTime() - offset);
+}
+function parseTimeExpression(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "midnight") return { hour: 0, minute: 0 };
+  if (trimmed === "noon") return { hour: 12, minute: 0 };
+  const match = trimmed.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (!match) throw new Error(`Invalid time: '${value}'`);
+  let hour = parseInt(match[1], 10);
+  const minute = parseInt(match[2] ?? "0", 10);
+  const meridiem = match[3];
+  if (meridiem === "am" && hour === 12) hour = 0;
+  if (meridiem === "pm" && hour < 12) hour += 12;
+  if (hour > 23 || minute > 59) throw new Error(`Invalid time: '${value}'`);
+  return { hour, minute };
+}
+function getTimeZoneOffsetMs(date, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).formatToParts(date);
+  const year = Number(parts.find((p) => p.type === "year")?.value);
+  const month = Number(parts.find((p) => p.type === "month")?.value);
+  const day = Number(parts.find((p) => p.type === "day")?.value);
+  const rawHour = Number(parts.find((p) => p.type === "hour")?.value);
+  const hour = rawHour % 24;
+  const minute = Number(parts.find((p) => p.type === "minute")?.value);
+  const second = Number(parts.find((p) => p.type === "second")?.value);
+  return Date.UTC(year, month - 1, day, hour, minute, second) - date.getTime();
+}
 function formatTimeInZone(date, timezone) {
   const timePart = new Intl.DateTimeFormat("en-US", {
     timeZone: timezone,
@@ -2253,7 +2483,7 @@ var DAY_NAMES = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday
 function evaluateDate(query) {
   const lower = query.toLowerCase().trim();
   try {
-    if (lower === "today" || lower === "now" || /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/.test(lower)) {
+    if (lower === "today" || lower === "now" || lower === "date" || /^(?:(?:what(?:'s|s| is))\s+today|(?:what(?:'s|s| is))\s+today'?s date|what day is it|todays date|today'?s date|date today|current date|what is the date today)$/.test(lower) || /^(?:what(?:'s| is) )?(?:the )?(?:current )?date(?: today)?$/.test(lower)) {
       return formatDateResult(query, /* @__PURE__ */ new Date());
     }
     if (lower === "tomorrow") {
@@ -2266,6 +2496,26 @@ function evaluateDate(query) {
       d.setDate(d.getDate() - 1);
       return formatDateResult(query, d);
     }
+    if (lower === "day after tomorrow") {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() + 2);
+      return formatDateResult(query, d);
+    }
+    if (lower === "day before yesterday") {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() - 2);
+      return formatDateResult(query, d);
+    }
+    const whatDateMatch = lower.match(/^what date is (.+)$/);
+    if (whatDateMatch) {
+      const d = parseFlexibleDate(whatDateMatch[1]);
+      if (d) return formatDateResult(query, d);
+    }
+    const whenIsMatch = lower.match(/^(?:what day is|when is)\s+(.+)$/);
+    if (whenIsMatch) {
+      const d = parseFlexibleDate(whenIsMatch[1]);
+      if (d) return formatDateResult(query, d);
+    }
     const nextLastMatch = lower.match(/^(next|last|this)\s+(.+)$/);
     if (nextLastMatch) {
       const direction = nextLastMatch[1];
@@ -2313,7 +2563,7 @@ function evaluateDate(query) {
       const d = applyOffset(/* @__PURE__ */ new Date(), amount, unit);
       return formatDateResult(query, d);
     }
-    const unixMatch = lower.match(/^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13})$/);
+    const unixMatch = lower.match(/^(?:unix\s+)?(?:timestamp\s+)?(\d{10,13}|0)$/);
     if (unixMatch) {
       const ts = parseInt(unixMatch[1]);
       const ms = ts > 9999999999 ? ts : ts * 1e3;
@@ -2333,14 +2583,11 @@ function evaluateDate(query) {
     if (toUnixMatch) {
       const dateStr = toUnixMatch[1].trim();
       let d;
-      if (dateStr === "now" || dateStr === "today") {
-        d = /* @__PURE__ */ new Date();
-      } else {
-        d = new Date(dateStr);
-      }
-      if (isNaN(d.getTime())) {
+      const parsed = parseFlexibleDate(dateStr);
+      if (!parsed) {
         return { type: "error", input: query, error: `Cannot parse date: '${dateStr}'` };
       }
+      d = parsed;
       const unix = Math.floor(d.getTime() / 1e3);
       return {
         type: "date",
@@ -2449,7 +2696,7 @@ function formatDateResult(input, d, extraMeta) {
   };
 }
 function parseFlexibleDate(str) {
-  if (str === "today" || str === "now") return /* @__PURE__ */ new Date();
+  if (str === "today" || str === "now" || str === "date") return /* @__PURE__ */ new Date();
   if (str === "tomorrow") {
     const d2 = /* @__PURE__ */ new Date();
     d2.setDate(d2.getDate() + 1);
@@ -2460,6 +2707,22 @@ function parseFlexibleDate(str) {
     d2.setDate(d2.getDate() - 1);
     return d2;
   }
+  if (str === "day after tomorrow") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() + 2);
+    return d2;
+  }
+  if (str === "day before yesterday") {
+    const d2 = /* @__PURE__ */ new Date();
+    d2.setDate(d2.getDate() - 2);
+    return d2;
+  }
+  const relativeDay = str.match(/^(next|last|this)\s+(.+)$/);
+  if (relativeDay) {
+    const direction = relativeDay[1];
+    const dayIndex = DAY_NAMES.indexOf(relativeDay[2]);
+    if (dayIndex !== -1) return getRelativeDay(dayIndex, direction);
+  }
   const d = new Date(str);
   return isNaN(d.getTime()) ? null : d;
 }
@@ -2577,6 +2840,7 @@ async function calculate(input, options) {
         intent.query,
         intent.from,
         intent.to,
+        intent.time,
         options?.timezone
       );
     case "date":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supercmd/calculator",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Powerful natural language calculator — math, units, currency, crypto, time zones, dates",
   "main": "dist/index.js",
   "module": "dist/index.mjs",