solve-engine 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/{chunk-3PPFLFH4.js → chunk-FIFQPKBA.js}

@@ -1,17 +1,18 @@
-import { BindingPower, BytecodeBuilder } from './chunk-5YEMOYSE.js';
-import { createFusedToken, isInsideRangeContext } from './chunk-64W6GLLZ.js';
+import { BindingPower, BytecodeBuilder } from './chunk-6GCKCWLB.js';
+import { createFusedToken, isInsideRangeContext } from './chunk-OFXOTECC.js';
 import { stripQuotes } from './chunk-PFSDGGYL.js';
-import { CurrencyAsyncResolver, nextInstruction } from './chunk-EPOXXJBK.js';
+import { CurrencyAsyncResolver, nextInstruction } from './chunk-YU2CUNFO.js';
 import { getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-4QADQTWS.js';
+import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-KHJUSHFU.js';
 import { createTimeoutSignal } from './chunk-Z4X2RWOF.js';
-import { resolveCurrencyAlias } from './chunk-RFYD5TJE.js';
+import { resolveCurrencyAlias } from './chunk-CYFK5SY2.js';
 import { errorValue, numberValue, stringValue, boolValue, uomValue, datetimeValue, timecodeUnit, ValueType } from './chunk-BVAR5J2F.js';
-import { getMeasure, convertUnit } from './chunk-NH2O2AUR.js';
-import { LexerToken } from './chunk-XVWCOTR6.js';
-import { tokenTypeId } from './chunk-RIN643A3.js';
-import { getLocale } from './chunk-GOLDJNMZ.js';
-import { isKnownUnit } from './chunk-LIPPNDBE.js';
+import { getMeasure, convertUnit } from './chunk-WC5FFSHB.js';
+import { LexerToken } from './chunk-SFQWJMKT.js';
+import { tokenTypeId } from './chunk-GPPLSM2Z.js';
+import { getLocale } from './chunk-XBTEO4OB.js';
+import { isKnownUnit } from './chunk-M5E34VG5.js';
+import { UNIT_TABLE } from './chunk-PCPX42KL.js';
 import { ErrorFactory } from './chunk-6RDSQURE.js';
 
 // src/packages/arithmetic/parselets/NumberParselet.ts
@@ -124,6 +125,19 @@ var SUFFIX_MAGNITUDE = {
   B: 9,
   T: 12
 };
+var WORD_MAGNITUDE = {
+  thousand: 3,
+  thousands: 3,
+  million: 6,
+  millions: 6,
+  mn: 6,
+  billion: 9,
+  billions: 9,
+  bn: 9,
+  trillion: 12,
+  trillions: 12,
+  tn: 12
+};
 var PLAIN_DECIMAL = /^\d+(\.\d+)?$/;
 function scaleDecimalString(raw, magnitude) {
   const dotIdx = raw.indexOf(".");
@@ -147,8 +161,8 @@ function largeNumberSuffixNormalizerRule(priority = 65) {
       const suffixToken = tokens[pos + 1];
       if (!suffixToken) return null;
       if (suffixToken.type !== "IDENT" && suffixToken.type !== "UNIT") return null;
-      if (numberToken.offset + numberToken.text.length !== suffixToken.offset) return null;
-      const magnitude = SUFFIX_MAGNITUDE[suffixToken.value];
+      const adjacent = numberToken.offset + numberToken.text.length === suffixToken.offset;
+      const magnitude = adjacent ? SUFFIX_MAGNITUDE[suffixToken.value] ?? WORD_MAGNITUDE[suffixToken.value.toLowerCase()] : WORD_MAGNITUDE[suffixToken.value.toLowerCase()];
       if (magnitude === void 0) return null;
       const scaled = scaleDecimalString(numberToken.text, magnitude);
       return {
@@ -177,6 +191,10 @@ var ARITHMETIC_PACKAGE = {
   ],
   infixParselets: [
     { tokenType: "PLUS", parselet: new BinaryOpParselet(BindingPower.Sum, 20 /* ADD */) },
+    // The word "and", which adds exactly like "+" but at a looser binding
+    // power so a phrase parselet can use it as a list separator. See
+    // Token.ts's AND_CONJ comment for why it is not simply mapped to PLUS.
+    { tokenType: "AND_CONJ", parselet: new BinaryOpParselet(BindingPower.Conjunction, 20 /* ADD */) },
     { tokenType: "MINUS", parselet: new BinaryOpParselet(BindingPower.Sum, 21 /* SUB */) },
     { tokenType: "STAR", parselet: new BinaryOpParselet(BindingPower.Product, 22 /* MUL */) },
     { tokenType: "SLASH", parselet: new BinaryOpParselet(BindingPower.Product, 23 /* DIV */) },
@@ -205,9 +223,167 @@ var PercentParselet = class {
     builder.emitOpcode(10 /* PUSH_NUMBER */);
     builder.emitNumber(100);
     builder.emitOpcode(23 /* DIV */);
+    builder.emitOpcode(74 /* TO_PERCENTAGE */);
+  }
+};
+
+// src/packages/percentage/parselets/IsWhatParselet.ts
+var IsWhatParselet = class {
+  constructor() {
+    this.category = "Percentage";
+    // Below arithmetic, so the whole expression to the left is the value being
+    // asked about: `10 + 10 is what % of 200` asks about 20.
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    if (nextWordIs(parser, "what")) {
+      parser.consume();
+      this.parseWhatRate(parser, builder);
+      return;
+    }
+    this.parseWhatBase(parser, builder);
+  }
+  /**
+   * `<part> is what % of|off|on <base>`, solving for the rate.
+   */
+  parseWhatRate(parser, builder) {
+    if (!parser.match("PERCENT")) {
+      throw ErrorFactory.parsing(
+        "IS_WHAT_EXPECTED_PERCENT",
+        'Expected "%" after "is what", as in "20 is what % of 200"'
+      );
+    }
+    const preposition = readPreposition(parser);
+    if (preposition === null) {
+      builder.emitOpcode(74 /* TO_PERCENTAGE */);
+      return;
+    }
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(23 /* DIV */);
+    if (preposition === "off") {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(1);
+      builder.emitOpcode(2 /* SWAP */);
+      builder.emitOpcode(21 /* SUB */);
+    } else if (preposition === "on") {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(1);
+      builder.emitOpcode(21 /* SUB */);
+    }
+    builder.emitOpcode(74 /* TO_PERCENTAGE */);
+  }
+  /**
+   * `<part> is <rate> of|off|on what`, solving for the base.
+   */
+  parseWhatBase(parser, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (parser.match("TO")) {
+      expectWord(parser, "what", '"81 is 9 to what power"');
+      expectWord(parser, "power", '"81 is 9 to what power"');
+      builder.emitOpcode(51 /* CALL_BUILTIN */);
+      builder.emitIndex(LOG_BUILTIN);
+      builder.emitIndex(1);
+      builder.emitOpcode(2 /* SWAP */);
+      builder.emitOpcode(51 /* CALL_BUILTIN */);
+      builder.emitIndex(LOG_BUILTIN);
+      builder.emitIndex(1);
+      builder.emitOpcode(2 /* SWAP */);
+      builder.emitOpcode(23 /* DIV */);
+      return;
+    }
+    const preposition = parser.match("OF_WHAT") ? "of" : parser.match("OFF_WHAT") ? "off" : parser.match("ON_WHAT") ? "on" : null;
+    if (preposition === null) {
+      throw ErrorFactory.parsing(
+        "IS_WHAT_EXPECTED_PREPOSITION",
+        'Expected "of what", "off what" or "on what", as in "20 is 10% of what"'
+      );
+    }
+    if (preposition === "of") {
+      builder.emitOpcode(23 /* DIV */);
+      return;
+    }
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(1);
+    if (preposition === "off") {
+      builder.emitOpcode(2 /* SWAP */);
+      builder.emitOpcode(21 /* SUB */);
+    } else {
+      builder.emitOpcode(20 /* ADD */);
+    }
+    builder.emitOpcode(23 /* DIV */);
+  }
+};
+var LOG_BUILTIN = 5;
+function nextWordIs(parser, word) {
+  return (parser.peek()?.text ?? "").toLowerCase() === word;
+}
+function expectWord(parser, word, example) {
+  if (!nextWordIs(parser, word)) {
+    throw ErrorFactory.parsing(
+      "IS_WHAT_EXPECTED_WORD",
+      `Expected "${word}" here, as in ${example}`
+    );
+  }
+  parser.consume();
+}
+function readPreposition(parser) {
+  if (parser.match("OF")) return "of";
+  const word = (parser.peek()?.text ?? "").toLowerCase();
+  if (word === "off" || word === "on") {
+    parser.consume();
+    return word;
+  }
+  return null;
+}
+
+// src/packages/percentage/parselets/OnOffBaseParselet.ts
+var OnOffBaseParselet = class {
+  /** @param sign - `1` for a markup (`on`), `-1` for a discount (`off`). */
+  constructor(sign) {
+    this.sign = sign;
+    this.category = "Percentage";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(2 /* SWAP */);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(1);
+    if (this.sign === 1) {
+      builder.emitOpcode(20 /* ADD */);
+    } else {
+      builder.emitOpcode(2 /* SWAP */);
+      builder.emitOpcode(21 /* SUB */);
+    }
+    builder.emitOpcode(22 /* MUL */);
   }
 };
 
+// src/packages/percentage/normalizer/PercentOnOffNormalizerRule.ts
+function percentOnOffNormalizerRule(priority = 68) {
+  return {
+    name: "percentage:on-off",
+    priority,
+    match(tokens, pos) {
+      if (tokens[pos]?.type !== "PERCENT") return null;
+      const word = tokens[pos + 1];
+      if (word?.type !== "IDENT") return null;
+      const text = (word.text ?? word.value ?? "").toLowerCase();
+      if (text !== "on" && text !== "off") return null;
+      const after = (tokens[pos + 2]?.text ?? "").toLowerCase();
+      if (after === "what") return null;
+      return {
+        consumed: 2,
+        replacement: [
+          tokens[pos],
+          createFusedToken(text === "on" ? "PCT_ON" : "PCT_OFF", text, [word])
+        ],
+        ruleName: "percentage:on-off"
+      };
+    }
+  };
+}
+
 // src/packages/percentage/parselets/OfParselet.ts
 var OfParselet = class {
   constructor() {
@@ -326,11 +502,22 @@ var PERCENTAGE_PACKAGE = {
   name: "solve-percentage",
   phrases: {
     "of what is": "OF_WHAT_IS",
+    // Fused so that parsing the rate cannot swallow the "of": it is an infix
+    // operator in its own right ("10% of 200"), so a sub-expression would
+    // consume it and the trailing "what" before this parselet ever looked.
+    "of what": "OF_WHAT",
+    "off what": "OFF_WHAT",
+    "on what": "ON_WHAT",
     "on what is": "ON_WHAT_IS",
     "off what is": "OFF_WHAT_IS"
   },
   infixParselets: [
     { tokenType: "PERCENT", parselet: new PercentParselet() },
+    { tokenType: "IS", parselet: new IsWhatParselet() },
+    // "10% on 200" is 220 and "10% off 200" is 180: the percentage comes
+    // first, the base second. The reverse of "200 + 10%".
+    { tokenType: "PCT_ON", parselet: new OnOffBaseParselet(1) },
+    { tokenType: "PCT_OFF", parselet: new OnOffBaseParselet(-1) },
     { tokenType: "OF", parselet: new OfParselet() },
     { tokenType: "OF_WHAT_IS", parselet: new OfWhatIsParselet() },
     { tokenType: "ON_WHAT_IS", parselet: new OnOffWhatIsParselet(1) },
@@ -342,6 +529,9 @@ var PERCENTAGE_PACKAGE = {
   prefixParselets: [
     { tokenType: "INCREASE", parselet: new IncreaseDecreaseParselet(1) },
     { tokenType: "DECREASE", parselet: new IncreaseDecreaseParselet(-1) }
+  ],
+  normalizerRules: [
+    percentOnOffNormalizerRule()
   ]
 };
 
@@ -368,6 +558,13 @@ var builtinNameToIndex = {
   arcsin: 11,
   arccos: 12,
   arctan: 13,
+  // Degree-taking variants (VMBuiltins.ts 87-92).
+  sind: 87,
+  cosd: 88,
+  tand: 89,
+  asind: 90,
+  acosd: 91,
+  atand: 92,
   sinh: 15,
   cosh: 16,
   tanh: 17,
@@ -560,18 +757,18 @@ function parseIso8601(s) {
 }
 function formatIso8601Local(epochMs) {
   const d = new Date(epochMs);
-  const pad = (n) => String(n).padStart(2, "0");
+  const pad3 = (n) => String(n).padStart(2, "0");
   const year = d.getFullYear();
-  const month = pad(d.getMonth() + 1);
-  const day = pad(d.getDate());
-  const hours = pad(d.getHours());
-  const minutes = pad(d.getMinutes());
-  const seconds = pad(d.getSeconds());
+  const month = pad3(d.getMonth() + 1);
+  const day = pad3(d.getDate());
+  const hours = pad3(d.getHours());
+  const minutes = pad3(d.getMinutes());
+  const seconds = pad3(d.getSeconds());
   const offsetMinutesTotal = -d.getTimezoneOffset();
   const sign = offsetMinutesTotal >= 0 ? "+" : "-";
   const absOffset = Math.abs(offsetMinutesTotal);
-  const offsetHours = pad(Math.floor(absOffset / 60));
-  const offsetMinutes = pad(absOffset % 60);
+  const offsetHours = pad3(Math.floor(absOffset / 60));
+  const offsetMinutes = pad3(absOffset % 60);
   return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${sign}${offsetHours}:${offsetMinutes}`;
 }
 var MS_TIMESTAMP_THRESHOLD = 1e12;
@@ -762,7 +959,7 @@ var DurationBetweenParselet = class {
   parse(parser, token, builder) {
     const unit = token.value;
     parser.parseExpression(BindingPower.Product, builder);
-    parser.consume("PLUS");
+    parser.consume("AND_CONJ");
     parser.parseExpression(BindingPower.Lowest, builder);
     builder.emitOpcode(50 /* CALL_PLUGIN */);
     builder.emitIndex(SPAN_BETWEEN_FN_IDX);
@@ -1006,6 +1203,201 @@ function dateLiteralNormalizerRule() {
   };
 }
 
+// src/packages/datetime/normalizer/MonthNameDateNormalizerRule.ts
+var MONTHS = {
+  january: 1,
+  jan: 1,
+  february: 2,
+  feb: 2,
+  march: 3,
+  mar: 3,
+  april: 4,
+  apr: 4,
+  may: 5,
+  june: 6,
+  jun: 6,
+  july: 7,
+  jul: 7,
+  august: 8,
+  aug: 8,
+  september: 9,
+  sep: 9,
+  sept: 9,
+  october: 10,
+  oct: 10,
+  november: 11,
+  nov: 11,
+  december: 12,
+  dec: 12
+};
+function monthOf(token) {
+  if (token === void 0) return 0;
+  if (token.type !== "IDENT" && token.type !== "UNIT") return 0;
+  return MONTHS[(token.text ?? token.value ?? "").toLowerCase()] ?? 0;
+}
+var PLAIN_INTEGER2 = /^\d+$/;
+function looksLikeYear(digits) {
+  return digits.length === 4;
+}
+function monthNameDateNormalizerRule(priority = 64) {
+  return {
+    name: "datetime:month-name-date",
+    priority,
+    match(tokens, pos) {
+      const RULE = "datetime:month-name-date";
+      const first = tokens[pos];
+      if (first?.type === "NUMBER" && PLAIN_INTEGER2.test(first.text ?? "")) {
+        const month2 = monthOf(tokens[pos + 1]);
+        if (month2 === 0) return null;
+        const day2 = Number(first.text);
+        if (day2 < 1 || day2 > 31) return null;
+        const yearToken2 = tokens[pos + 2];
+        if (yearToken2?.type === "NUMBER" && PLAIN_INTEGER2.test(yearToken2.text ?? "") && looksLikeYear(yearToken2.text ?? "")) {
+          return buildDateToken(day2, month2, Number(yearToken2.text), tokens.slice(pos, pos + 3), RULE);
+        }
+        return buildDateToken(day2, month2, (/* @__PURE__ */ new Date()).getFullYear(), tokens.slice(pos, pos + 2), RULE);
+      }
+      const month = monthOf(first);
+      if (month === 0) return null;
+      const second = tokens[pos + 1];
+      if (second?.type !== "NUMBER" || !PLAIN_INTEGER2.test(second.text ?? "")) return null;
+      if (looksLikeYear(second.text ?? "")) {
+        return buildDateToken(1, month, Number(second.text), tokens.slice(pos, pos + 2), RULE);
+      }
+      const day = Number(second.text);
+      const comma = tokens[pos + 2];
+      const yearToken = tokens[pos + 3];
+      if (comma?.type === "COMMA" && yearToken?.type === "NUMBER" && PLAIN_INTEGER2.test(yearToken.text ?? "") && looksLikeYear(yearToken.text ?? "")) {
+        return buildDateToken(day, month, Number(yearToken.text), tokens.slice(pos, pos + 4), RULE);
+      }
+      if (comma?.type === "NUMBER" && PLAIN_INTEGER2.test(comma.text ?? "") && looksLikeYear(comma.text ?? "")) {
+        return buildDateToken(day, month, Number(comma.text), tokens.slice(pos, pos + 3), RULE);
+      }
+      return buildDateToken(day, month, (/* @__PURE__ */ new Date()).getFullYear(), tokens.slice(pos, pos + 2), RULE);
+    }
+  };
+}
+
+// src/packages/datetime/parselets/DaysInPeriodParselet.ts
+var DAYS_COUNT_BUILTIN = 93;
+var QUARTERS = {
+  q1: [1, 3],
+  q2: [4, 6],
+  q3: [7, 9],
+  q4: [10, 12]
+};
+function daysInMonth(year, month) {
+  return new Date(year, month, 0).getDate();
+}
+function daysInYear(year) {
+  return daysInMonth(year, 2) === 29 ? 366 : 365;
+}
+var DaysInPeriodParselet = class {
+  constructor() {
+    this.category = "Datetime";
+  }
+  parse(parser, _token, builder) {
+    const total = this.readPeriodDays(parser);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(total);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(DAYS_COUNT_BUILTIN);
+    builder.emitIndex(1);
+  }
+  /** The number of days in the period written after `days in`. */
+  readPeriodDays(parser) {
+    const next = parser.peek();
+    const word = (next?.text ?? next?.value ?? "").toLowerCase();
+    const quarter = QUARTERS[word];
+    if (quarter !== void 0) {
+      parser.consume();
+      const year2 = this.readOptionalYear(parser) ?? (/* @__PURE__ */ new Date()).getFullYear();
+      let total = 0;
+      for (let month = quarter[0]; month <= quarter[1]; month++) {
+        total += daysInMonth(year2, month);
+      }
+      return total;
+    }
+    if (next?.type === "DATETIME_LITERAL") {
+      parser.consume();
+      const date = new Date(Number(next.value));
+      return daysInMonth(date.getFullYear(), date.getMonth() + 1);
+    }
+    const year = this.readOptionalYear(parser);
+    if (year !== null) return daysInYear(year);
+    throw ErrorFactory.parsing(
+      "DAYS_IN_EXPECTED_PERIOD",
+      'Expected a month, quarter or year, as in "days in February 2020" or "days in Q3"'
+    );
+  }
+  /** A four-digit year sitting at the cursor, consumed if present. */
+  readOptionalYear(parser) {
+    const token = parser.peek();
+    if (token?.type !== "NUMBER") return null;
+    const text = token.text ?? token.value ?? "";
+    if (!/^\d{4}$/.test(text)) return null;
+    parser.consume();
+    return Number(text);
+  }
+};
+
+// src/packages/datetime/normalizer/DaysInPeriodNormalizerRule.ts
+var QUARTERS2 = /* @__PURE__ */ new Set(["q1", "q2", "q3", "q4"]);
+var MONTHS2 = /* @__PURE__ */ new Set([
+  "january",
+  "jan",
+  "february",
+  "feb",
+  "march",
+  "mar",
+  "april",
+  "apr",
+  "may",
+  "june",
+  "jun",
+  "july",
+  "jul",
+  "august",
+  "aug",
+  "september",
+  "sep",
+  "sept",
+  "october",
+  "oct",
+  "november",
+  "nov",
+  "december",
+  "dec"
+]);
+function startsPeriod(token) {
+  if (token === void 0) return false;
+  if (token.type === "DATETIME_LITERAL") return true;
+  const word = (token.text ?? token.value ?? "").toLowerCase();
+  if (token.type === "IDENT" || token.type === "UNIT") {
+    return QUARTERS2.has(word) || MONTHS2.has(word);
+  }
+  return token.type === "NUMBER" && /^\d{4}$/.test(token.text ?? "");
+}
+function daysInPeriodNormalizerRule(priority = 60) {
+  return {
+    name: "datetime:days-in-period",
+    priority,
+    match(tokens, pos) {
+      const days = tokens[pos];
+      if (days === void 0) return null;
+      if ((days.text ?? days.value ?? "").toLowerCase() !== "days") return null;
+      if (days.type !== "UNIT" && days.type !== "IDENT") return null;
+      if (tokens[pos + 1]?.type !== "IN") return null;
+      if (!startsPeriod(tokens[pos + 2])) return null;
+      return {
+        consumed: 2,
+        replacement: [createFusedToken("DAYS_IN_PERIOD", "days in", [days, tokens[pos + 1]])],
+        ruleName: "datetime:days-in-period"
+      };
+    }
+  };
+}
+
 // src/packages/datetime/normalizer/DailyNoteLinkNormalizerRule.ts
 function dailyNoteLinkNormalizerRule() {
   return {
@@ -1054,6 +1446,10 @@ var DATETIME_PACKAGE = {
     "what week is it": "WEEK_ON",
     "what week is it on": "WEEK_ON",
     "week of": "WEEK_ON",
+    // The spelling Soulver documents. Same question, same handler.
+    "week number on": "WEEK_ON",
+    "week number of": "WEEK_ON",
+    "week number": "WEEK_ON",
     "what week is it in": "WEEK_IN",
     "what week will it be in": "WEEK_IN",
     // Postfix day-type predicates.
@@ -1064,6 +1460,7 @@ var DATETIME_PACKAGE = {
     "is a business day": "IS_WORKDAY"
   },
   prefixParselets: [
+    { tokenType: "DAYS_IN_PERIOD", parselet: new DaysInPeriodParselet() },
     { tokenType: "NOW", parselet: new NowParselet(0) },
     { tokenType: "TODAY", parselet: new NowParselet(0) },
     { tokenType: "TOMORROW", parselet: new NowParselet(1) },
@@ -1094,6 +1491,11 @@ var DATETIME_PACKAGE = {
     betweenUnitNormalizerRule(),
     workdayRateDenominatorNormalizerRule(),
     dateLiteralNormalizerRule(),
+    // Dates with the month spelled out ("March 9, 2024"). Priority 64, just
+    // under the numeric rule, so an all-numeric literal is still claimed by
+    // the rule that has always claimed it.
+    monthNameDateNormalizerRule(),
+    daysInPeriodNormalizerRule(),
     dailyNoteLinkNormalizerRule()
   ],
   pluginFunctions: [
@@ -1606,7 +2008,7 @@ var TimeDifferenceParselet = class {
         `Expected a city or zone name after "time difference between" (e.g. "time difference between Seattle and Moscow")`
       );
     }
-    parser.consume("PLUS");
+    parser.consume("AND_CONJ");
     const zone2 = tryConsumeZoneReference(parser);
     if (zone2 === null) {
       throw ErrorFactory.parsing(
@@ -1684,14 +2086,14 @@ var VideoTimecodeParselet = class {
 // src/packages/time/timecode/TimecodeMath.ts
 function framesToTimecodeString(totalFrames, fps) {
   const fpsWhole = Math.max(1, Math.round(fps));
-  const pad = (n) => String(n).padStart(2, "0");
+  const pad3 = (n) => String(n).padStart(2, "0");
   const frameCount = Math.trunc(totalFrames);
   const frames = (frameCount % fpsWhole + fpsWhole) % fpsWhole;
   const totalSeconds = Math.floor(frameCount / fpsWhole);
   const hours = Math.floor(totalSeconds / 3600);
   const minutes = Math.floor(totalSeconds % 3600 / 60);
   const seconds = totalSeconds % 60;
-  return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}:${pad(frames)}`;
+  return `${pad3(hours)}:${pad3(minutes)}:${pad3(seconds)}:${pad3(frames)}`;
 }
 
 // src/packages/time/parselets/FrameCountParselet.ts
@@ -1911,9 +2313,72 @@ function frameCountNormalizerRule(priority = 65) {
   };
 }
 
+// src/packages/time/TimespanConverters.ts
+var TIME_KIND = 14;
+var TIMESPAN_PARTS = [
+  ["week", "weeks", 604800],
+  ["day", "days", 86400],
+  ["hour", "hours", 3600],
+  ["minute", "minutes", 60],
+  ["second", "seconds", 1]
+];
+function durationSeconds(value) {
+  if (value.type === 0 /* Number */) return value.toNumber();
+  if (value.type !== 6 /* Uom */ || value.unit === void 0) return null;
+  const entry = UNIT_TABLE[value.unit.toLowerCase()];
+  if (entry === void 0 || entry[0] !== TIME_KIND) return null;
+  return value.toNumber() * entry[1];
+}
+function toTimespanString(value) {
+  const total = durationSeconds(value);
+  if (total === null) {
+    return stringValue(`"as timespan" needs a duration, got ${value.unit ?? "a non-duration"}`);
+  }
+  const negative = total < 0;
+  let remaining = Math.abs(total);
+  const parts = [];
+  for (const [singular, plural, seconds] of TIMESPAN_PARTS) {
+    if (seconds === 1) break;
+    const count = Math.floor(remaining / seconds);
+    if (count > 0) {
+      parts.push(`${count} ${count === 1 ? singular : plural}`);
+      remaining -= count * seconds;
+    }
+  }
+  const secondsLeft = Math.round(remaining * 1e3) / 1e3;
+  if (secondsLeft > 0 || parts.length === 0) {
+    parts.push(`${secondsLeft} ${secondsLeft === 1 ? "second" : "seconds"}`);
+  }
+  return stringValue((negative ? "-" : "") + parts.join(" "));
+}
+function toLaptimeString(value) {
+  const total = durationSeconds(value);
+  if (total === null) {
+    return stringValue(`"as laptime" needs a duration, got ${value.unit ?? "a non-duration"}`);
+  }
+  const negative = total < 0;
+  const rounded = Math.round(Math.abs(total) * 1e3) / 1e3;
+  const hours = Math.floor(rounded / 3600);
+  const minutes = Math.floor(rounded % 3600 / 60);
+  const seconds = rounded % 60;
+  const whole = Math.floor(seconds);
+  const fraction = Math.round((seconds - whole) * 1e3);
+  const base = `${pad(hours)}:${pad(minutes)}:${pad(whole)}`;
+  return stringValue((negative ? "-" : "") + (fraction > 0 ? `${base}.${String(fraction).padStart(3, "0")}` : base));
+}
+function pad(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+
 // src/packages/time/TimePackage.ts
 var TIME_PACKAGE = {
   name: "solve-time",
+  asConverters: {
+    // The two ways of writing a duration out. See TimespanConverters.ts.
+    timespan: toTimespanString,
+    laptime: toLaptimeString,
+    lap: toLaptimeString
+  },
   phrases: {
     "time in": "TIME_IN",
     "date in": "DATE_IN",
@@ -2017,7 +2482,7 @@ var keywordLedRollPattern = definePhrasePattern({
         // separator's token type (a bare `parser.consume()`), so it never
         // surfaced this; matching that real lexer behavior explicitly here
         // rather than the aspirational "AND" the old code's comment implied.
-        { kind: "keyword", tokenTypes: ["PLUS"] },
+        { kind: "keyword", tokenTypes: ["AND_CONJ"] },
         { kind: "expr" }
       ],
       emit: emitDiceRollCall
@@ -2345,99 +2810,403 @@ function uomPossibilitiesNormalizerRule(priority = 60) {
   };
 }
 
-// src/packages/uom/data/IngredientDensities.ts
-var INGREDIENT_DENSITIES = {
-  water: 1,
-  milk: 1.03,
-  "whole milk": 1.03,
-  "skim milk": 1.035,
-  buttermilk: 1.03,
-  "heavy cream": 1,
-  "whipping cream": 1,
-  "sour cream": 0.96,
-  yogurt: 1.03,
-  "greek yogurt": 1.05,
-  "cream cheese": 1.01,
-  "condensed milk": 1.3,
-  "evaporated milk": 1.06,
-  "coconut milk": 0.97,
-  "almond milk": 1.03,
-  "soy milk": 1.03,
-  butter: 0.9595,
-  margarine: 0.96,
-  "vegetable oil": 0.92,
-  "olive oil": 0.913,
-  "canola oil": 0.92,
-  "coconut oil": 0.92,
-  "sunflower oil": 0.92,
-  "sesame oil": 0.92,
-  mayonnaise: 0.91,
-  sugar: 0.845,
-  "granulated sugar": 0.845,
-  "brown sugar": 0.93,
-  "powdered sugar": 0.51,
-  "icing sugar": 0.51,
-  honey: 1.42,
-  "maple syrup": 1.32,
-  "corn syrup": 1.38,
-  molasses: 1.4,
-  nutella: 1.14,
-  "peanut butter": 1.09,
-  flour: 0.53,
-  "all-purpose flour": 0.53,
-  "all purpose flour": 0.53,
-  "bread flour": 0.54,
-  "cake flour": 0.47,
-  "whole wheat flour": 0.55,
-  cornstarch: 0.53,
-  cornmeal: 0.65,
-  semolina: 0.6,
-  rice: 0.79,
-  "white rice": 0.79,
-  "brown rice": 0.8,
-  oats: 0.34,
-  "rolled oats": 0.38,
-  breadcrumbs: 0.43,
-  yeast: 0.68,
-  "dry yeast": 0.68,
-  salt: 1.2,
-  "table salt": 1.2,
-  "kosher salt": 0.96,
-  "baking powder": 0.9,
-  "baking soda": 0.99,
-  "cream of tartar": 0.68,
-  cinnamon: 0.56,
-  ginger: 0.5,
-  "vanilla extract": 0.88,
-  "lemon juice": 1.03,
-  "lime juice": 1.02,
-  "orange juice": 1.04,
-  vinegar: 1.01,
-  cocoa: 0.41,
-  "cocoa powder": 0.41,
-  "chocolate chips": 0.72,
-  "chocolate chunks": 0.72,
-  coconut: 0.35,
-  "shredded coconut": 0.35,
-  raisins: 0.68,
-  almonds: 0.55,
-  walnuts: 0.5,
-  pecans: 0.5,
-  pistachios: 0.55,
-  peanuts: 0.6,
-  "shredded cheese": 0.4,
-  parmesan: 0.44,
-  "tomato paste": 1.06,
-  "tomato sauce": 1.02,
-  ketchup: 1.14,
-  broth: 1,
-  stock: 1,
-  wine: 0.99,
-  beer: 1.01
-};
-var MAX_INGREDIENT_NAME_WORDS = 2;
-function getIngredientDensity(name) {
-  return INGREDIENT_DENSITIES[name.toLowerCase().trim()];
+// src/packages/uom/normalizer/CompoundQuantityNormalizerRule.ts
+var TIME_KIND2 = 14;
+function unitEntry(token, previousKind) {
+  if (token === void 0 || token.type !== "UNIT") return void 0;
+  const spelling = (token.value ?? "").toLowerCase();
+  if (spelling === "m" && previousKind === TIME_KIND2) {
+    return { kind: TIME_KIND2, ratio: 60, spelling: "minutes" };
+  }
+  const entry = UNIT_TABLE[spelling];
+  return entry === void 0 ? void 0 : { kind: entry[0], ratio: entry[1], spelling };
+}
+var PLAIN_NUMBER = /^\d+(\.\d+)?$/;
+function compoundQuantityNormalizerRule(priority = 63) {
+  return {
+    name: "uom:compound-quantity",
+    priority,
+    match(tokens, pos) {
+      const firstNumber = tokens[pos];
+      if (firstNumber?.type !== "NUMBER" || !PLAIN_NUMBER.test(firstNumber.text ?? "")) return null;
+      const firstUnit = unitEntry(tokens[pos + 1]);
+      if (firstUnit === void 0) return null;
+      const kind = firstUnit.kind;
+      let lastRatio = firstUnit.ratio;
+      let total = Number(firstNumber.text) * lastRatio;
+      let smallestUnit = firstUnit.spelling;
+      let smallestUnitToken = tokens[pos + 1];
+      let consumed = 2;
+      for (; ; ) {
+        const number = tokens[pos + consumed];
+        if (number?.type !== "NUMBER" || !PLAIN_NUMBER.test(number.text ?? "")) break;
+        const entry = unitEntry(tokens[pos + consumed + 1], kind);
+        if (entry === void 0) break;
+        if (entry.kind !== kind || entry.ratio >= lastRatio) break;
+        total += Number(number.text) * entry.ratio;
+        lastRatio = entry.ratio;
+        smallestUnit = entry.spelling;
+        smallestUnitToken = tokens[pos + consumed + 1];
+        consumed += 2;
+      }
+      if (consumed === 2) return null;
+      const source = tokens.slice(pos, pos + consumed);
+      const scaled = total / lastRatio;
+      return {
+        consumed,
+        replacement: [
+          createFusedToken("NUMBER", String(scaled), source),
+          createFusedToken("UNIT", smallestUnit, [smallestUnitToken])
+        ],
+        ruleName: "uom:compound-quantity"
+      };
+    }
+  };
+}
+
+// src/packages/uom/normalizer/TwoUnitConversionNormalizerRule.ts
+function isUnit(token) {
+  if (token === void 0 || token.type !== "UNIT") return false;
+  return UNIT_TABLE[(token.value ?? "").toLowerCase()] !== void 0;
+}
+function twoUnitConversionNormalizerRule(priority = 59) {
+  return {
+    name: "uom:two-unit-conversion",
+    priority,
+    match(tokens, pos) {
+      const preposition = tokens[pos];
+      if (preposition?.type !== "IN" && preposition?.type !== "TO") return null;
+      if (!isUnit(tokens[pos + 1])) return null;
+      if (tokens[pos + 2]?.type !== "AND_CONJ") return null;
+      if (!isUnit(tokens[pos + 3])) return null;
+      const major = tokens[pos + 1].value;
+      const minor = tokens[pos + 3].value;
+      return {
+        consumed: 4,
+        replacement: [
+          createFusedToken("IN_TWO_UNITS", `${major} ${minor}`, tokens.slice(pos, pos + 4))
+        ],
+        ruleName: "uom:two-unit-conversion"
+      };
+    }
+  };
+}
+
+// src/packages/uom/normalizer/DegreeSymbolNormalizerRule.ts
+function degreeSymbolNormalizerRule(priority = 74) {
+  return {
+    name: "uom:degree-symbol",
+    priority,
+    match(tokens, pos) {
+      const number = tokens[pos];
+      if (number?.type !== "NUMBER") return null;
+      const symbol = tokens[pos + 1];
+      if (symbol === void 0 || symbol.type !== "IDENT") return null;
+      if ((symbol.text ?? symbol.value ?? "") !== "\xB0") return null;
+      return {
+        consumed: 2,
+        replacement: [number, createFusedToken("UNIT", "degrees", [symbol])],
+        ruleName: "uom:degree-symbol"
+      };
+    }
+  };
+}
+
+// src/packages/uom/parselets/TwoUnitConversionParselet.ts
+var TwoUnitConversionParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Uom";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(_parser, _left, token, builder) {
+    const [major, minor] = String(token.value).split(" ");
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(major);
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(minor);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(3);
+  }
+};
+
+// src/packages/uom/normalizer/BareRateDenominatorNormalizerRule.ts
+function isUnit2(token) {
+  if (token === void 0 || token.type !== "UNIT") return false;
+  return UNIT_TABLE[(token.value ?? "").toLowerCase()] !== void 0;
+}
+var PER_WORDS = /* @__PURE__ */ new Set(["per", "a", "an", "each", "every"]);
+function isCountLabel(token) {
+  if (token === void 0 || token.type !== "IDENT") return false;
+  const word = (token.text ?? token.value ?? "").toLowerCase();
+  if (PER_WORDS.has(word)) return false;
+  return /^[a-z][a-z_]{2,}$/.test(word) && UNIT_TABLE[word] === void 0;
+}
+function bareRateDenominatorNormalizerRule(priority = 75) {
+  return {
+    name: "uom:bare-rate-denominator",
+    priority,
+    match(tokens, pos) {
+      const head = tokens[pos];
+      if (head === void 0) return null;
+      if (head.type === "NUMBER" && isCountLabel(tokens[pos + 1])) {
+        const label = tokens[pos + 1];
+        const after = tokens[pos + 2];
+        const introduces = after?.type === "SLASH" || after?.type === "IDENT" && PER_WORDS.has((after.text ?? after.value ?? "").toLowerCase());
+        if (introduces && isUnit2(tokens[pos + 3])) {
+          return {
+            consumed: 2,
+            replacement: [head, createFusedToken("UNIT", label.value, [label])],
+            ruleName: "uom:bare-rate-denominator"
+          };
+        }
+      }
+      if (!isUnit2(tokens[pos + 1])) return null;
+      const isSlash = head.type === "SLASH";
+      const word = (head.text ?? head.value ?? "").toLowerCase();
+      const isPerWord = head.type === "IDENT" && PER_WORDS.has(word);
+      if (!isSlash && !isPerWord) return null;
+      const unitToken = tokens[pos + 1];
+      return {
+        consumed: 2,
+        replacement: [
+          createFusedToken("PER_UNIT", unitToken.value, [head, unitToken])
+        ],
+        ruleName: "uom:bare-rate-denominator"
+      };
+    }
+  };
+}
+
+// src/packages/uom/parselets/PerUnitParselet.ts
+var PerUnitParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Uom";
+    this.bindingPower = BindingPower.Product;
+  }
+  parse(_parser, _left, token, builder) {
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(String(token.value));
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(2);
+  }
+};
+
+// src/packages/uom/parselets/AtRateParselet.ts
+var AtRateParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Uom";
+    this.bindingPower = BindingPower.Product;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(2);
+  }
+};
+
+// src/packages/uom/normalizer/AtRateNormalizerRule.ts
+function isUnit3(token) {
+  if (token === void 0 || token.type !== "UNIT") return false;
+  return UNIT_TABLE[(token.value ?? "").toLowerCase()] !== void 0;
+}
+var PER_WORDS2 = /* @__PURE__ */ new Set(["per", "a", "an", "each", "every"]);
+function hasRateAhead(tokens, from) {
+  for (let i = from; i < tokens.length && i < from + 5; i++) {
+    const token = tokens[i];
+    if (token.type === "PER_UNIT") return true;
+    if (token.type === "EOF" || token.type === "COMMA" || token.type === "RATE_AT") return false;
+    const word = (token.text ?? token.value ?? "").toLowerCase();
+    const introducesDenominator = token.type === "SLASH" || token.type === "IDENT" && PER_WORDS2.has(word);
+    if (introducesDenominator && isUnit3(tokens[i + 1])) return true;
+  }
+  return false;
+}
+function atRateNormalizerRule(priority = 73) {
+  return {
+    name: "uom:at-rate",
+    priority,
+    match(tokens, pos) {
+      if (tokens[pos]?.type !== "RATE_AT") return null;
+      if (!hasRateAhead(tokens, pos + 1)) return null;
+      return {
+        consumed: 1,
+        replacement: [createFusedToken("AT_RATE", "at", [tokens[pos]])],
+        ruleName: "uom:at-rate"
+      };
+    }
+  };
+}
+
+// src/packages/uom/normalizer/ForDurationNormalizerRule.ts
+function isUnit4(token) {
+  if (token === void 0 || token.type !== "UNIT") return false;
+  return UNIT_TABLE[(token.value ?? "").toLowerCase()] !== void 0;
+}
+var ARTICLES = /* @__PURE__ */ new Set(["a", "an"]);
+function forDurationNormalizerRule(priority = 76) {
+  return {
+    name: "uom:for-duration",
+    priority,
+    match(tokens, pos) {
+      const head = tokens[pos];
+      if (head?.type !== "FOR_DURATION") return null;
+      const article = tokens[pos + 1];
+      if (article?.type !== "IDENT") return null;
+      if (!ARTICLES.has((article.text ?? article.value ?? "").toLowerCase())) return null;
+      if (!isUnit4(tokens[pos + 2])) return null;
+      return {
+        consumed: 3,
+        replacement: [
+          createFusedToken("STAR", "*", [head]),
+          createFusedToken("NUMBER", "1", [article]),
+          tokens[pos + 2]
+        ],
+        ruleName: "uom:for-duration"
+      };
+    }
+  };
+}
+
+// src/packages/uom/normalizer/ReversedConversionNormalizerRule.ts
+function isUnit5(token) {
+  if (token === void 0 || token.type !== "UNIT") return false;
+  return UNIT_TABLE[(token.value ?? "").toLowerCase()] !== void 0;
+}
+var ARTICLES2 = /* @__PURE__ */ new Set(["a", "an"]);
+function reversedConversionNormalizerRule(priority = 61) {
+  return {
+    name: "uom:reversed-conversion",
+    priority,
+    match(tokens, pos) {
+      if (pos !== 0 || !isUnit5(tokens[pos])) return null;
+      if (tokens[pos + 1]?.type !== "IN") return null;
+      const target = tokens[pos];
+      const third = tokens[pos + 2];
+      if (third === void 0) return null;
+      if (third.type === "NUMBER" && isUnit5(tokens[pos + 3])) {
+        return {
+          consumed: 4,
+          replacement: [third, tokens[pos + 3], tokens[pos + 1], target],
+          ruleName: "uom:reversed-conversion"
+        };
+      }
+      const word = (third.text ?? third.value ?? "").toLowerCase();
+      if (third.type === "IDENT" && ARTICLES2.has(word) && isUnit5(tokens[pos + 3])) {
+        return {
+          consumed: 4,
+          replacement: [
+            createFusedToken("NUMBER", "1", [third]),
+            tokens[pos + 3],
+            tokens[pos + 1],
+            target
+          ],
+          ruleName: "uom:reversed-conversion"
+        };
+      }
+      return null;
+    }
+  };
+}
+
+// src/packages/uom/data/IngredientDensities.ts
+var INGREDIENT_DENSITIES = {
+  water: 1,
+  milk: 1.03,
+  "whole milk": 1.03,
+  "skim milk": 1.035,
+  buttermilk: 1.03,
+  "heavy cream": 1,
+  "whipping cream": 1,
+  "sour cream": 0.96,
+  yogurt: 1.03,
+  "greek yogurt": 1.05,
+  "cream cheese": 1.01,
+  "condensed milk": 1.3,
+  "evaporated milk": 1.06,
+  "coconut milk": 0.97,
+  "almond milk": 1.03,
+  "soy milk": 1.03,
+  butter: 0.9595,
+  margarine: 0.96,
+  "vegetable oil": 0.92,
+  "olive oil": 0.913,
+  "canola oil": 0.92,
+  "coconut oil": 0.92,
+  "sunflower oil": 0.92,
+  "sesame oil": 0.92,
+  mayonnaise: 0.91,
+  sugar: 0.845,
+  "granulated sugar": 0.845,
+  "brown sugar": 0.93,
+  "powdered sugar": 0.51,
+  "icing sugar": 0.51,
+  honey: 1.42,
+  "maple syrup": 1.32,
+  "corn syrup": 1.38,
+  molasses: 1.4,
+  nutella: 1.14,
+  "peanut butter": 1.09,
+  flour: 0.53,
+  "all-purpose flour": 0.53,
+  "all purpose flour": 0.53,
+  "bread flour": 0.54,
+  "cake flour": 0.47,
+  "whole wheat flour": 0.55,
+  cornstarch: 0.53,
+  cornmeal: 0.65,
+  semolina: 0.6,
+  rice: 0.79,
+  "white rice": 0.79,
+  "brown rice": 0.8,
+  oats: 0.34,
+  "rolled oats": 0.38,
+  breadcrumbs: 0.43,
+  yeast: 0.68,
+  "dry yeast": 0.68,
+  salt: 1.2,
+  "table salt": 1.2,
+  "kosher salt": 0.96,
+  "baking powder": 0.9,
+  "baking soda": 0.99,
+  "cream of tartar": 0.68,
+  cinnamon: 0.56,
+  ginger: 0.5,
+  "vanilla extract": 0.88,
+  "lemon juice": 1.03,
+  "lime juice": 1.02,
+  "orange juice": 1.04,
+  vinegar: 1.01,
+  cocoa: 0.41,
+  "cocoa powder": 0.41,
+  "chocolate chips": 0.72,
+  "chocolate chunks": 0.72,
+  coconut: 0.35,
+  "shredded coconut": 0.35,
+  raisins: 0.68,
+  almonds: 0.55,
+  walnuts: 0.5,
+  pecans: 0.5,
+  pistachios: 0.55,
+  peanuts: 0.6,
+  "shredded cheese": 0.4,
+  parmesan: 0.44,
+  "tomato paste": 1.06,
+  "tomato sauce": 1.02,
+  ketchup: 1.14,
+  broth: 1,
+  stock: 1,
+  wine: 0.99,
+  beer: 1.01
+};
+var MAX_INGREDIENT_NAME_WORDS = 2;
+function getIngredientDensity(name) {
+  return INGREDIENT_DENSITIES[name.toLowerCase().trim()];
 }
 
 // src/packages/uom/parselets/CookingPluginFunctions.ts
@@ -2548,11 +3317,21 @@ var UOM_PACKAGE = {
     { tokenType: "UOM_POSSIBILITIES_QUERY", parselet: new PossibilitiesParselet() }
   ],
   infixParselets: [
+    { tokenType: "IN_TWO_UNITS", parselet: new TwoUnitConversionParselet(94) },
+    { tokenType: "PER_UNIT", parselet: new PerUnitParselet(95) },
+    { tokenType: "AT_RATE", parselet: new AtRateParselet(96) },
     { tokenType: "UNIT", parselet: new UomLiteralParselet() },
     { tokenType: "INGREDIENT_NAME", parselet: new CookingConversionParselet() }
   ],
   normalizerRules: [
     uomPossibilitiesNormalizerRule(),
+    compoundQuantityNormalizerRule(),
+    twoUnitConversionNormalizerRule(),
+    degreeSymbolNormalizerRule(),
+    atRateNormalizerRule(),
+    forDurationNormalizerRule(),
+    bareRateDenominatorNormalizerRule(),
+    reversedConversionNormalizerRule(),
     ingredientNameNormalizerRule()
   ],
   pluginFunctions: [
@@ -3587,6 +4366,9 @@ var BUILTIN_CONVERTERS = {
   hex: 71 /* TO_HEX */,
   fraction: 140 /* TO_FRACTION */,
   multiplier: 141 /* TO_MULTIPLIER */,
+  // "20 to 40 as x". Only reachable in converter position, immediately after
+  // "as", so a variable named x is unaffected.
+  x: 141 /* TO_MULTIPLIER */,
   sci: 142 /* TO_SCI */,
   scientific: 142 /* TO_SCI */,
   binary: 143 /* TO_BINARY */,
@@ -3594,6 +4376,11 @@ var BUILTIN_CONVERTERS = {
   octal: 144 /* TO_OCTAL */,
   oct: 144 /* TO_OCTAL */
 };
+var BASE_CONVERTERS = {
+  2: 143 /* TO_BINARY */,
+  8: 144 /* TO_OCTAL */,
+  16: 71 /* TO_HEX */
+};
 var AsConverterParselet = class {
   constructor() {
     this.category = "Converters";
@@ -3614,8 +4401,26 @@ var AsConverterParselet = class {
     }
     parser.consume();
     const name = nextToken.value.toLowerCase();
+    if (name === "base") {
+      const radixToken = parser.peek();
+      const radix = radixToken?.type === "NUMBER" ? Number(radixToken.value) : NaN;
+      const opcode = BASE_CONVERTERS[radix];
+      if (opcode === void 0) {
+        throw ErrorFactory.parsing(
+          "AS_CONVERTER_UNSUPPORTED_BASE",
+          `"as base ${radixToken?.value ?? "?"}": only bases ${Object.keys(BASE_CONVERTERS).join(", ")} can be written out`
+        );
+      }
+      parser.consume();
+      builder.emitOpcode(opcode);
+      return;
+    }
     const builtinOp = BUILTIN_CONVERTERS[name];
     if (builtinOp !== void 0) {
+      if (builtinOp === 141 /* TO_MULTIPLIER */ && parser.match("OF")) {
+        parser.parseExpression(BindingPower.Conditional, builder);
+        builder.emitOpcode(23 /* DIV */);
+      }
       builder.emitOpcode(builtinOp);
       return;
     }
@@ -3625,11 +4430,181 @@ var AsConverterParselet = class {
   }
 };
 
+// src/packages/converters/parselets/RoundingParselets.ts
+var INCREMENT_WORDS = {
+  ten: 10,
+  hundred: 100,
+  thousand: 1e3,
+  million: 1e6,
+  billion: 1e9
+};
+function emitRoundToIncrement(builder, increment, direction) {
+  builder.emitOpcode(10 /* PUSH_NUMBER */);
+  builder.emitNumber(increment);
+  builder.emitOpcode(23 /* DIV */);
+  emitRoundDirection(builder, direction);
+  builder.emitOpcode(10 /* PUSH_NUMBER */);
+  builder.emitNumber(increment);
+  builder.emitOpcode(22 /* MUL */);
+}
+function emitRoundDirection(builder, direction) {
+  const builtin = direction === "up" ? CEIL_BUILTIN : direction === "down" ? FLOOR_BUILTIN : ROUND_BUILTIN;
+  builder.emitOpcode(51 /* CALL_BUILTIN */);
+  builder.emitIndex(builtin);
+  builder.emitIndex(1);
+}
+var ROUND_BUILTIN = 8;
+var CEIL_BUILTIN = 6;
+var FLOOR_BUILTIN = 7;
+function readDirection(parser) {
+  const next = parser.peek();
+  const word = (next?.text ?? "").toLowerCase();
+  if (word === "up") {
+    parser.consume();
+    return "up";
+  }
+  if (word === "down") {
+    parser.consume();
+    return "down";
+  }
+  return "nearest";
+}
+var RoundedParselet = class {
+  constructor() {
+    this.category = "Converters";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    const direction = readDirection(parser);
+    if (parser.match("TO_NEAREST")) {
+      emitRoundToIncrement(builder, readIncrement(parser), direction);
+      return;
+    }
+    emitRoundDirection(builder, direction);
+  }
+};
+var ToNearestParselet = class {
+  constructor() {
+    this.category = "Converters";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    emitRoundToIncrement(builder, readIncrement(parser), "nearest");
+  }
+};
+function readIncrement(parser) {
+  const next = parser.peek();
+  const word = (next?.text ?? "").toLowerCase();
+  const magnitude = INCREMENT_WORDS[word];
+  if (magnitude !== void 0) {
+    parser.consume();
+    return magnitude;
+  }
+  if (next?.type === "NUMBER") {
+    parser.consume();
+    const value = Number(next.value);
+    if (Number.isFinite(value) && value > 0) return value;
+  }
+  throw ErrorFactory.parsing(
+    "INVALID_ROUNDING_INCREMENT",
+    `"to nearest ${next?.value ?? "?"}": expected a positive number or one of ${Object.keys(INCREMENT_WORDS).join(", ")}`
+  );
+}
+var DecimalPlacesParselet = class {
+  constructor() {
+    this.category = "Converters";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(_parser, _left, token, builder) {
+    const places = Number(token.value);
+    if (!Number.isFinite(places) || places < 0 || places > 100) {
+      throw ErrorFactory.parsing(
+        "INVALID_DECIMAL_PLACES",
+        `"to ${token.value} dp": expected a place count between 0 and 100`
+      );
+    }
+    const scale = Math.pow(10, places);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(scale);
+    builder.emitOpcode(22 /* MUL */);
+    emitRoundDirection(builder, "nearest");
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(scale);
+    builder.emitOpcode(23 /* DIV */);
+  }
+};
+
+// src/packages/converters/normalizer/DecimalPlacesNormalizerRule.ts
+var PLACE_WORDS = /* @__PURE__ */ new Set(["dp", "dps", "decimals", "digits", "digit"]);
+var PLACE_PHRASES = /* @__PURE__ */ new Set(["decimal"]);
+function decimalPlacesNormalizerRule(priority = 66) {
+  return {
+    name: "converters:decimal-places",
+    priority,
+    match(tokens, pos) {
+      if (tokens[pos]?.type !== "TO") return null;
+      const count = tokens[pos + 1];
+      if (count?.type !== "NUMBER") return null;
+      const unitToken = tokens[pos + 2];
+      if (!unitToken) return null;
+      const word = (unitToken.text ?? unitToken.value ?? "").toLowerCase();
+      let consumed = 3;
+      if (PLACE_PHRASES.has(word)) {
+        const tail = tokens[pos + 3];
+        const tailWord = (tail?.text ?? "").toLowerCase();
+        if (tailWord !== "place" && tailWord !== "places") return null;
+        consumed = 4;
+      } else if (!PLACE_WORDS.has(word)) {
+        return null;
+      }
+      return {
+        consumed,
+        replacement: [
+          createFusedToken("DECIMAL_PLACES", count.value, tokens.slice(pos, pos + consumed))
+        ],
+        ruleName: "converters:decimal-places"
+      };
+    }
+  };
+}
+
+// src/packages/converters/normalizer/ConverterPrepositionNormalizerRule.ts
+function converterPrepositionNormalizerRule(priority = 67) {
+  return {
+    name: "converters:preposition",
+    priority,
+    match(tokens, pos) {
+      const preposition = tokens[pos];
+      if (preposition?.type !== "IN" && preposition?.type !== "TO") return null;
+      if (tokens[pos + 1]?.type !== "CONVERTER_NAME") return null;
+      return {
+        consumed: 1,
+        replacement: [createFusedToken("AS", "as", [preposition])],
+        ruleName: "converters:preposition"
+      };
+    }
+  };
+}
+
 // src/packages/converters/ConvertersPackage.ts
 var CONVERTERS_PACKAGE = {
   name: "solve-converters",
+  phrases: {
+    // A phrase, not a bare "nearest": "to" is already an infix operator
+    // (percentage change), so the two words have to arrive as one token for
+    // the parser to tell the grammars apart. See RoundingParselets.ts.
+    "to nearest": "TO_NEAREST",
+    "to the nearest": "TO_NEAREST"
+  },
   infixParselets: [
-    { tokenType: "AS", parselet: new AsConverterParselet() }
+    { tokenType: "AS", parselet: new AsConverterParselet() },
+    { tokenType: "ROUNDED", parselet: new RoundedParselet() },
+    { tokenType: "TO_NEAREST", parselet: new ToNearestParselet() },
+    { tokenType: "DECIMAL_PLACES", parselet: new DecimalPlacesParselet() }
+  ],
+  normalizerRules: [
+    decimalPlacesNormalizerRule(),
+    converterPrepositionNormalizerRule()
   ]
 };
 
@@ -3641,10 +4616,10 @@ var VariadicAggregateParselet = class {
   }
   parse(parser, token, builder) {
     let argCount = 0;
-    parser.parseExpression(BindingPower.Lowest, builder);
+    parser.parseExpression(BindingPower.Conjunction, builder);
     argCount++;
-    while (parser.match("COMMA")) {
-      parser.parseExpression(BindingPower.Lowest, builder);
+    while (parser.match("COMMA") || parser.match("AND_CONJ")) {
+      parser.parseExpression(BindingPower.Conjunction, builder);
       argCount++;
     }
     builder.emitOpcode(51 /* CALL_BUILTIN */);
@@ -3653,13 +4628,125 @@ var VariadicAggregateParselet = class {
   }
 };
 
+// src/packages/mathphrases/parselets/UnaryPhraseParselet.ts
+function unaryPhraseParselet(builtinIndex) {
+  return {
+    category: "MathPhrases",
+    parse(parser, _token, builder) {
+      parser.parseExpression(BindingPower.Lowest, builder);
+      builder.emitOpcode(51 /* CALL_BUILTIN */);
+      builder.emitIndex(builtinIndex);
+      builder.emitIndex(1);
+    }
+  };
+}
+
+// src/packages/mathphrases/parselets/RemainderRootParselets.ts
+var remainderOfParselet = {
+  category: "MathPhrases",
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Product, builder);
+    if (!parser.match("DIVIDE_BY") && !parser.match("SLASH")) {
+      throw ErrorFactory.parsing(
+        "REMAINDER_EXPECTED_DIVIDED_BY",
+        'Expected "divided by" or "/", as in "remainder of 21 divided by 5"'
+      );
+    }
+    parser.parseExpression(BindingPower.Product, builder);
+    builder.emitOpcode(24 /* MOD */);
+  }
+};
+var nthRootParselet = {
+  category: "MathPhrases",
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Product, builder);
+    if (!parser.match("OF")) {
+      throw ErrorFactory.parsing(
+        "ROOT_EXPECTED_OF",
+        'Expected "of", as in "root 5 of 100"'
+      );
+    }
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(2 /* SWAP */);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(1);
+    builder.emitOpcode(2 /* SWAP */);
+    builder.emitOpcode(23 /* DIV */);
+    builder.emitOpcode(25 /* EXP */);
+  }
+};
+var logBaseParselet = {
+  category: "MathPhrases",
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    emitNaturalLog(builder);
+    if (!parser.match("LOG_BASE")) {
+      throw ErrorFactory.parsing(
+        "LOG_EXPECTED_BASE",
+        'Expected "base", as in "log 20 base 4"'
+      );
+    }
+    parser.parseExpression(BindingPower.Conditional, builder);
+    emitNaturalLog(builder);
+    builder.emitOpcode(23 /* DIV */);
+  }
+};
+var LOG_BUILTIN2 = 5;
+function emitNaturalLog(builder) {
+  builder.emitOpcode(51 /* CALL_BUILTIN */);
+  builder.emitIndex(LOG_BUILTIN2);
+  builder.emitIndex(1);
+}
+
+// src/packages/mathphrases/normalizer/FunctionPhraseNormalizerRule.ts
+function functionPhraseNormalizerRule(priority = 69) {
+  return {
+    name: "mathphrases:function-phrase",
+    priority,
+    match(tokens, pos) {
+      const head = tokens[pos];
+      if (head?.type !== "FUNC") return null;
+      const word = (head.value ?? "").toLowerCase();
+      if (word !== "root" && word !== "log") return null;
+      if (tokens[pos + 1]?.type === "LPAREN") return null;
+      if (word === "root") {
+        return {
+          consumed: 1,
+          replacement: [createFusedToken("NTH_ROOT", "root", [head])],
+          ruleName: "mathphrases:function-phrase"
+        };
+      }
+      const baseAt = findBase(tokens, pos + 1);
+      if (baseAt === -1) return null;
+      const replacement = tokens.slice(pos, baseAt + 1).map((token, index) => {
+        if (index === 0) return createFusedToken("LOG_PHRASE", "log", [token]);
+        if (index === baseAt - pos) return createFusedToken("LOG_BASE", "base", [token]);
+        return token;
+      });
+      return {
+        consumed: baseAt - pos + 1,
+        replacement,
+        ruleName: "mathphrases:function-phrase"
+      };
+    }
+  };
+}
+function findBase(tokens, from) {
+  for (let i = from; i < tokens.length && i < from + 8; i++) {
+    const token = tokens[i];
+    if (token.type === "EOF" || token.type === "COMMA" || token.type === "RPAREN") return -1;
+    if ((token.text ?? token.value ?? "").toLowerCase() === "base") return i;
+  }
+  return -1;
+}
+
 // src/packages/mathphrases/parselets/LargerSmallerParselet.ts
 function largerSmallerParselet(builtinIndex) {
   return {
     category: "MathPhrases",
     parse(parser, token, builder) {
-      parser.parseExpression(BindingPower.Product, builder);
-      parser.consume("PLUS");
+      parser.parseExpression(BindingPower.Conjunction, builder);
+      parser.consume("AND_CONJ");
       parser.parseExpression(BindingPower.Lowest, builder);
       builder.emitOpcode(51 /* CALL_BUILTIN */);
       builder.emitIndex(builtinIndex);
@@ -3683,8 +4770,8 @@ var halfParselet = {
 var midpointParselet = {
   category: "MathPhrases",
   parse(parser, token, builder) {
-    parser.parseExpression(BindingPower.Product, builder);
-    parser.consume("PLUS");
+    parser.parseExpression(BindingPower.Conjunction, builder);
+    parser.consume("AND_CONJ");
     parser.parseExpression(BindingPower.Lowest, builder);
     builder.emitOpcode(20 /* ADD */);
     builder.emitOpcode(10 /* PUSH_NUMBER */);
@@ -3701,7 +4788,7 @@ var randomNumberParselet = definePhrasePattern({
       slots: [
         { kind: "keyword", tokenTypes: ["BETWEEN"] },
         { kind: "expr", bindingPower: BindingPower.Product },
-        { kind: "keyword", tokenTypes: ["PLUS"] },
+        { kind: "keyword", tokenTypes: ["AND_CONJ"] },
         { kind: "expr" }
       ],
       emit: (builder) => {
@@ -3725,7 +4812,7 @@ var ClampParselet = class {
     if (mid?.type === "BETWEEN") {
       parser.consume();
       parser.parseExpression(BindingPower.Product, builder);
-      parser.consume("PLUS");
+      parser.consume("AND_CONJ");
       parser.parseExpression(BindingPower.Lowest, builder);
     } else if (mid?.type === "FROM") {
       parser.consume();
@@ -3776,6 +4863,10 @@ var TOTAL = 44;
 var COUNT = 45;
 var MIN = 9;
 var MAX = 10;
+var GCD = 38;
+var LCM = 39;
+var SQRT = 0;
+var CBRT = 21;
 var MATHPHRASES_PACKAGE = {
   name: "solve-mathphrases",
   phrases: {
@@ -3784,11 +4875,20 @@ var MATHPHRASES_PACKAGE = {
     "total of": "TOTAL_OF",
     "count of": "COUNT_OF",
     "larger of": "LARGER_OF",
+    "greater of": "LARGER_OF",
     "smaller of": "SMALLER_OF",
+    "lesser of": "SMALLER_OF",
     "half of": "HALF_OF",
     "midpoint between": "MIDPOINT_BETWEEN",
     "random number": "RANDOM_NUMBER",
-    "is to": "IS_TO"
+    "is to": "IS_TO",
+    // Two-operand phrases reusing the gcd/lcm builtins.
+    "remainder of": "REMAINDER_OF",
+    "gcd of": "GCD_OF",
+    "lcm of": "LCM_OF",
+    // sqrt/cbrt spelled the way they are said.
+    "square root of": "SQUARE_ROOT_OF",
+    "cube root of": "CUBE_ROOT_OF"
   },
   prefixParselets: [
     { tokenType: "AVERAGE_OF", parselet: new VariadicAggregateParselet(AVERAGE) },
@@ -3800,29 +4900,168 @@ var MATHPHRASES_PACKAGE = {
     { tokenType: "HALF_OF", parselet: halfParselet },
     { tokenType: "MIDPOINT_BETWEEN", parselet: midpointParselet },
     { tokenType: "RANDOM_NUMBER", parselet: randomNumberParselet },
+    { tokenType: "REMAINDER_OF", parselet: remainderOfParselet },
+    { tokenType: "NTH_ROOT", parselet: nthRootParselet },
+    { tokenType: "LOG_PHRASE", parselet: logBaseParselet },
+    { tokenType: "GCD_OF", parselet: largerSmallerParselet(GCD) },
+    { tokenType: "LCM_OF", parselet: largerSmallerParselet(LCM) },
+    { tokenType: "SQUARE_ROOT_OF", parselet: unaryPhraseParselet(SQRT) },
+    { tokenType: "CUBE_ROOT_OF", parselet: unaryPhraseParselet(CBRT) },
     { tokenType: "CLAMP", parselet: new ClampParselet() }
   ],
   infixParselets: [
     { tokenType: "IS_TO", parselet: new ProportionParselet() }
+  ],
+  normalizerRules: [
+    functionPhraseNormalizerRule()
   ]
 };
 
+// src/packages/finance/parselets/InvestmentParselets.ts
+var PERIODS_PER_YEAR = {
+  annually: 1,
+  yearly: 1,
+  // Semi-annual is not on Soulver's page, but it is the one interval a
+  // reader of the other four would expect to exist, and leaving it out makes
+  // the set look arbitrary rather than deliberate.
+  "semi-annually": 2,
+  quarterly: 4,
+  monthly: 12,
+  fortnightly: 26,
+  weekly: 52,
+  daily: 365
+};
+function readCompoundingInterval(parser) {
+  if (!parser.match("COMPOUNDING")) return 1;
+  const token = parser.peek();
+  const name = (token?.text ?? token?.value ?? "").toLowerCase();
+  const periods = PERIODS_PER_YEAR[name];
+  if (periods === void 0) {
+    throw ErrorFactory.parsing(
+      "UNKNOWN_COMPOUNDING_INTERVAL",
+      `compounding ${name || "?"}: expected one of ${Object.keys(PERIODS_PER_YEAR).join(", ")}`
+    );
+  }
+  parser.consume();
+  return periods;
+}
+var InvestmentGrowthParselet = class {
+  /**
+   * @param annualIndex - Builtin for the annual case, so the common form
+   * keeps using the same code path (and the same rounding) it always did.
+   * @param intervalIndex - Builtin taking an explicit periods-per-year.
+   */
+  constructor(annualIndex, intervalIndex) {
+    this.annualIndex = annualIndex;
+    this.intervalIndex = intervalIndex;
+    this.category = "Finance";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (!parser.match("RATE_AT")) parser.consume("AT");
+    parser.parseExpression(BindingPower.Conditional, builder);
+    const periods = readCompoundingInterval(parser);
+    builder.emitOpcode(2 /* SWAP */);
+    if (periods === 1) {
+      builder.emitOpcode(51 /* CALL_BUILTIN */);
+      builder.emitIndex(this.annualIndex);
+      builder.emitIndex(3);
+      return;
+    }
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(periods);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.intervalIndex);
+    builder.emitIndex(4);
+  }
+};
+var PresentValueParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (!parser.match("AFTER") && !parser.match("OVER") && !parser.match("IN")) {
+      parser.consume("AFTER");
+    }
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (!parser.match("RATE_AT")) parser.consume("AT");
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(2 /* SWAP */);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(3);
+  }
+};
+var ReturnOnInvestmentParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    parser.consume("RETURNED");
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(2);
+  }
+};
+var AnnualReturnParselet = class {
+  constructor(builtinIndex) {
+    this.builtinIndex = builtinIndex;
+    this.category = "Finance";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    parser.consume("INVESTED");
+    parser.parseExpression(BindingPower.Conditional, builder);
+    parser.consume("RETURNED");
+    if (!parser.match("AFTER") && !parser.match("OVER") && !parser.match("IN")) {
+      parser.consume("AFTER");
+    }
+    parser.parseExpression(BindingPower.Conditional, builder);
+    builder.emitOpcode(51 /* CALL_BUILTIN */);
+    builder.emitIndex(this.builtinIndex);
+    builder.emitIndex(3);
+  }
+};
+
 // src/packages/finance/parselets/CompoundInterestParselet.ts
 var CompoundInterestParselet = class {
-  constructor(builtinIndex) {
+  /**
+   * @param builtinIndex - Annual-compounding builtin.
+   * @param intervalIndex - Builtin taking an explicit periods-per-year, used
+   * when the expression ends in "compounding monthly" or similar.
+   */
+  constructor(builtinIndex, intervalIndex) {
     this.builtinIndex = builtinIndex;
+    this.intervalIndex = intervalIndex;
     this.category = "Finance";
   }
   parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Conditional, builder);
+    if (!parser.match("AFTER") && !parser.match("FOR_DURATION")) {
+      parser.consume("OVER");
+    }
     parser.parseExpression(BindingPower.Lowest, builder);
-    parser.consume("OVER");
-    parser.parseExpression(BindingPower.Lowest, builder);
-    parser.consume("RATE_AT");
+    if (!parser.match("RATE_AT")) parser.consume("AT");
     parser.parseExpression(BindingPower.Lowest, builder);
+    const periods = readCompoundingInterval(parser);
     builder.emitOpcode(2 /* SWAP */);
+    if (periods === 1) {
+      builder.emitOpcode(51 /* CALL_BUILTIN */);
+      builder.emitIndex(this.builtinIndex);
+      builder.emitIndex(3);
+      return;
+    }
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(periods);
     builder.emitOpcode(51 /* CALL_BUILTIN */);
-    builder.emitIndex(this.builtinIndex);
-    builder.emitIndex(3);
+    builder.emitIndex(this.intervalIndex);
+    builder.emitIndex(4);
   }
 };
 
@@ -3837,7 +5076,7 @@ var LoanRepaymentParselet = class {
     parser.parseExpression(BindingPower.Lowest, builder);
     parser.consume("OVER");
     parser.parseExpression(BindingPower.Lowest, builder);
-    parser.consume("RATE_AT");
+    if (!parser.match("RATE_AT")) parser.consume("AT");
     parser.parseExpression(BindingPower.Lowest, builder);
     builder.emitOpcode(2 /* SWAP */);
     builder.emitOpcode(10 /* PUSH_NUMBER */);
@@ -3899,8 +5138,8 @@ function inflationFutureValueHandler(args) {
     return errorValue("INVALID_RATE", `inflationFutureValue: rate ${rate} makes (1 + rate) non-positive`);
   }
   const amount = amountValue.toNumber();
-  const fv = amount * Math.pow(1 + rate, years);
-  return amountValue.type === 6 /* Uom */ ? uomValue(fv, amountValue.unit) : numberValue(fv);
+  const worth = amount / Math.pow(1 + rate, years);
+  return amountValue.type === 6 /* Uom */ ? uomValue(worth, amountValue.unit) : numberValue(worth);
 }
 
 // src/packages/finance/parselets/InflationQueryParselet.ts
@@ -4018,8 +5257,14 @@ var COMPOUND_FV = 51;
 var COMPOUND_INTEREST = 52;
 var LOAN_REPAYMENT = 55;
 var LOAN_INTEREST = 56;
-var TAX_ADD = 58;
+var COMPOUND_FV_EVERY = 80;
+var COMPOUND_INTEREST_EVERY = 81;
+var PRESENT_VALUE = 82;
+var ROI = 83;
+var ANNUAL_RETURN = 84;
 var TAX_REMOVE = 59;
+var TAX_IN = 85;
+var TAX_ON = 86;
 var FINANCE_PACKAGE = {
   name: "solve-finance",
   phrases: {
@@ -4035,17 +5280,29 @@ var FINANCE_PACKAGE = {
     "total interest on": "TOTAL_LOAN_INTEREST_ON",
     "tax on": "TAX_ON",
     "tax off": "TAX_OFF",
+    // The tax already inside a gross amount. Soulver documents "VAT in",
+    // "VAT of" and "VAT from" as three spellings of one thing.
+    "tax in": "TAX_IN_PHRASE",
+    "tax of": "TAX_IN_PHRASE",
+    "tax from": "TAX_IN_PHRASE",
+    "vat in": "TAX_IN_PHRASE",
+    "vat of": "TAX_IN_PHRASE",
+    "vat from": "TAX_IN_PHRASE",
     "vat on": "TAX_ON",
     "vat off": "TAX_OFF",
     "what is": "WHAT_IS",
     "what was": "WHAT_WAS",
+    "present value of": "PRESENT_VALUE_OF",
+    "annual return on": "ANNUAL_RETURN_ON",
     "value of": "VALUE_OF",
     "worth in": "WORTH_IN",
     "assuming": "ASSUMING"
   },
   prefixParselets: [
-    { tokenType: "COMPOUND_INTEREST_ON", parselet: new CompoundInterestParselet(COMPOUND_FV) },
-    { tokenType: "INTEREST_ON", parselet: new CompoundInterestParselet(COMPOUND_INTEREST) },
+    { tokenType: "PRESENT_VALUE_OF", parselet: new PresentValueParselet(PRESENT_VALUE) },
+    { tokenType: "ANNUAL_RETURN_ON", parselet: new AnnualReturnParselet(ANNUAL_RETURN) },
+    { tokenType: "COMPOUND_INTEREST_ON", parselet: new CompoundInterestParselet(COMPOUND_FV, COMPOUND_FV_EVERY) },
+    { tokenType: "INTEREST_ON", parselet: new CompoundInterestParselet(COMPOUND_INTEREST, COMPOUND_INTEREST_EVERY) },
     { tokenType: "DAILY_REPAYMENT_ON", parselet: new LoanRepaymentParselet(LOAN_REPAYMENT, 365) },
     { tokenType: "MONTHLY_REPAYMENT_ON", parselet: new LoanRepaymentParselet(LOAN_REPAYMENT, 12) },
     { tokenType: "ANNUAL_REPAYMENT_ON", parselet: new LoanRepaymentParselet(LOAN_REPAYMENT, 1) },
@@ -4054,13 +5311,20 @@ var FINANCE_PACKAGE = {
     { tokenType: "MONTHLY_LOAN_INTEREST_ON", parselet: new LoanRepaymentParselet(LOAN_INTEREST, 12) },
     { tokenType: "ANNUAL_LOAN_INTEREST_ON", parselet: new LoanRepaymentParselet(LOAN_INTEREST, 1) },
     { tokenType: "TOTAL_LOAN_INTEREST_ON", parselet: new LoanRepaymentParselet(LOAN_INTEREST, 0) },
-    { tokenType: "TAX_ON", parselet: new SalesTaxParselet(TAX_ADD) },
+    { tokenType: "TAX_ON", parselet: new SalesTaxParselet(TAX_ON) },
     { tokenType: "TAX_OFF", parselet: new SalesTaxParselet(TAX_REMOVE) },
+    { tokenType: "TAX_IN_PHRASE", parselet: new SalesTaxParselet(TAX_IN) },
     { tokenType: "WHAT_IS", parselet: new InflationQueryParselet("what-is") },
     { tokenType: "WHAT_WAS", parselet: new InflationQueryParselet("what-was") },
     { tokenType: "VALUE_OF", parselet: new InflationFutureValueParselet() }
   ],
   infixParselets: [
+    // The documented bare forms: "$1,000 after 3 years at 7%" and the "for
+    // ... compounding monthly" variant. Both pivot words behave identically;
+    // Soulver uses "after" for the annual form and "for" with an interval.
+    { tokenType: "AFTER", parselet: new InvestmentGrowthParselet(COMPOUND_FV, COMPOUND_FV_EVERY) },
+    { tokenType: "FOR_DURATION", parselet: new InvestmentGrowthParselet(COMPOUND_FV, COMPOUND_FV_EVERY) },
+    { tokenType: "INVESTED", parselet: new ReturnOnInvestmentParselet(ROI) },
     { tokenType: "IN_YEAR_DOLLARS", parselet: new InYearDollarsParselet() }
   ],
   normalizerRules: [
@@ -4423,6 +5687,15 @@ function requireYear(text, raw) {
 function tryParseDatePhrase(parser) {
   const first = parser.peek();
   if (!first) return null;
+  if (first.type === "DATETIME_LITERAL") {
+    parser.consume();
+    const date = new Date(Number(first.value));
+    if (Number.isNaN(date.getTime())) return null;
+    return {
+      isoDate: `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`,
+      raw: first.text ?? first.value
+    };
+  }
   if (first.type === "NUMBER") {
     const g1 = parser.consume();
     const sepTok = parser.peek();
@@ -5093,5 +6366,5 @@ var BUILTIN_PACKAGES = [
 ];
 
 export { ARITHMETIC_PACKAGE, BIGINT_PACKAGE, BUILTIN_PACKAGES, CONDITIONALS_PACKAGE, CONVERTERS_PACKAGE, CURRENCY_PACKAGE, DATETIME_PACKAGE, DICE_PACKAGE, FINANCE_PACKAGE, FUNCTION_PACKAGE, LINES_PACKAGE, MAPREDUCE_PACKAGE, MATHPHRASES_PACKAGE, MATRIX_PACKAGE, PERCENTAGE_PACKAGE, SYMBOLIC_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, containsSymbolicCall, createKnowledgePackage, createStocksPackage };
-//# sourceMappingURL=chunk-3PPFLFH4.js.map
-//# sourceMappingURL=chunk-3PPFLFH4.js.map
+//# sourceMappingURL=chunk-FIFQPKBA.js.map
+//# sourceMappingURL=chunk-FIFQPKBA.js.map