solve-engine 1.0.1 → 1.1.0

package/dist/{chunk-HMOISHXR.js → chunk-RRLHC37V.js}

@@ -1,28 +1,32 @@
-import { BindingPower, BytecodeBuilder, bigIntLiteralDigits } from './chunk-526PMQOA.js';
-import { createFusedToken, isInsideRangeContext } from './chunk-YPPPYLSR.js';
+import { BindingPower, BytecodeBuilder, bigIntLiteralDigits } from './chunk-ENKKJYD3.js';
+import { createFusedToken, isInsideRangeContext } from './chunk-JJIXHXFQ.js';
 import { stripQuotes } from './chunk-3BOK2LDK.js';
-import { CurrencyAsyncResolver, nextInstruction } from './chunk-KV7UW6T6.js';
+import { CurrencyAsyncResolver, nextInstruction } from './chunk-7KYSUDQO.js';
 import { getActiveQueryClient } from './chunk-NLNDMWZC.js';
-import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-Y7FT4IQT.js';
+import { allocatePluginFunctionIndex, sharedGlobalVariableStore, adjustForInflation, solveForVariable, CPI_MIN_YEAR, CPI_MAX_YEAR } from './chunk-NKW7LKYU.js';
+import { sharedCurrencyExchange } from './chunk-Z7XGGLI2.js';
 import { createTimeoutSignal } from './chunk-Z4X2RWOF.js';
-import { resolveCurrencyAlias } from './chunk-O3ANBHSA.js';
-import { errorValue, numberValue, stringValue, boolValue, uomValue, datetimeValue, timecodeUnit, ValueType } from './chunk-GQCOSXMG.js';
-import { getMeasure, convertUnit } from './chunk-R3PY4G7J.js';
-import { LexerToken } from './chunk-QY25VWBF.js';
-import { tokenTypeId } from './chunk-VB37OC6I.js';
+import { parseColour, clamp255, clamp01, hslToRgb, rotateHue, complement, grayscale, invert, mix, withAlpha, contrastRatio, relativeLuminance, hsvToRgb, hwbToRgb, isDark, readableColour, wcagLevel, WCAG_THRESHOLDS, lighten, darken, saturate, desaturate, rgbToHsl, tint, shade, tone } from './chunk-5HRB36DK.js';
+import { resolveCurrencyAlias, varNode, constNode, rationalFromNumber, simplifySymbolic, rationalToNumber } from './chunk-NNQ2TYDF.js';
+import { errorValue, colourValue, numberValue, boolValue, stringValue, faultedOperand, uomValue, datetimeValue, timecodeUnit, symbolicValue, ValueType } from './chunk-267JPOTF.js';
+import { getMeasure, convertUnit } from './chunk-MVTOCRV2.js';
+import { LexerToken } from './chunk-GQMUHVE3.js';
+import { tokenTypeId } from './chunk-4D6NIHE2.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
 import { isKnownUnit } from './chunk-SBUFNJVE.js';
 import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory } from './chunk-3D7V24DG.js';
+import { ErrorFactory } from './chunk-ERCOHGXD.js';
 
 // src/packages/arithmetic/parselets/NumberParselet.ts
 var CHAINED_DOT_THOUSANDS_GROUPS = /^\d{1,3}(\.\d{3}){2,}$/;
+var PLAIN_DECIMAL = /^\d*\.\d*$/;
 var NumberParselet = class {
   constructor() {
     this.category = "Arithmetic";
   }
   parse(parser, token, builder) {
     let v;
+    let decimalText = null;
     const raw = token.value;
     if (raw.startsWith("0x") || raw.startsWith("0X")) {
       v = parseInt(raw, 16);
@@ -53,6 +57,12 @@ var NumberParselet = class {
         normalized = normalized.replace(decimalSep, ".");
       }
       v = parseFloat(normalized);
+      if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;
+    }
+    if (decimalText !== null) {
+      builder.emitOpcode(16 /* PUSH_DECIMAL */);
+      builder.emitString(decimalText);
+      return;
     }
     builder.emitOpcode(10 /* PUSH_NUMBER */);
     builder.emitNumber(v);
@@ -139,7 +149,7 @@ var WORD_MAGNITUDE = {
   trillions: 12,
   tn: 12
 };
-var PLAIN_DECIMAL = /^\d+(\.\d+)?$/;
+var PLAIN_DECIMAL2 = /^\d+(\.\d+)?$/;
 function scaleDecimalString(raw, magnitude) {
   const dotIdx = raw.indexOf(".");
   const intPart = dotIdx === -1 ? raw : raw.slice(0, dotIdx);
@@ -158,7 +168,7 @@ function largeNumberSuffixNormalizerRule(priority = 65) {
     match(tokens, pos) {
       const numberToken = tokens[pos];
       if (numberToken.type !== "NUMBER") return null;
-      if (!PLAIN_DECIMAL.test(numberToken.text)) return null;
+      if (!PLAIN_DECIMAL2.test(numberToken.text)) return null;
       const suffixToken = tokens[pos + 1];
       if (!suffixToken) return null;
       if (suffixToken.type !== "IDENT" && suffixToken.type !== "UNIT") return null;
@@ -509,6 +519,119 @@ var PercentageChangeParselet = class {
   }
 };
 
+// src/packages/percentage/parselets/UpDownParselet.ts
+var COUNT_WORDS = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12
+};
+function resolveCount(token) {
+  if (token.type === "NUMBER") {
+    const n = Number(token.value);
+    return Number.isInteger(n) && n >= 0 ? n : null;
+  }
+  if (token.type === "IDENT") {
+    return COUNT_WORDS[token.value.toLowerCase()] ?? null;
+  }
+  return null;
+}
+var UpDownParselet = class {
+  /** @param sign `1` for `up` (grow), `-1` for `down` (shrink). */
+  constructor(sign) {
+    this.sign = sign;
+    this.category = "Percentage";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(this.bindingPower, builder);
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(1);
+    builder.emitOpcode(2 /* SWAP */);
+    builder.emitOpcode(this.sign > 0 ? 20 /* ADD */ : 21 /* SUB */);
+    const repeat = this.tryConsumeRepeat(parser);
+    if (repeat !== null) {
+      builder.emitOpcode(10 /* PUSH_NUMBER */);
+      builder.emitNumber(repeat);
+      builder.emitOpcode(25 /* EXP */);
+    }
+    builder.emitOpcode(22 /* MUL */);
+    this.consumeChainThen(parser);
+  }
+  /**
+   * Consume a trailing `N times` (`3 times`, `three times`) if present,
+   * returning the count, or `null` when there is no repeat here. The word
+   * "times" lexes as the multiply token but keeps its source text, which is
+   * what tells it apart from a literal `*`.
+   */
+  tryConsumeRepeat(parser) {
+    const countTok = parser.peek();
+    const timesTok = parser.peekAt(1);
+    if (!countTok || !timesTok) return null;
+    if (timesTok.type !== "STAR" || timesTok.value.toLowerCase() !== "times") return null;
+    const count = resolveCount(countTok);
+    if (count === null) return null;
+    parser.consume();
+    parser.consume();
+    return count;
+  }
+  /** Drop a connective `then` that sits directly before the next step. */
+  consumeChainThen(parser) {
+    if (parser.peek()?.type !== "THEN") return;
+    const next = parser.peekAt(1)?.type;
+    if (next === "PCT_UP" || next === "PCT_DOWN") {
+      parser.consume();
+    }
+  }
+};
+
+// src/packages/percentage/normalizer/PercentUpDownNormalizerRule.ts
+function stepTokenAt(tokens, i) {
+  const word = tokens[i];
+  if (word?.type !== "IDENT") return null;
+  const text = (word.text ?? word.value ?? "").toLowerCase();
+  if (text !== "up" && text !== "down") return null;
+  if (tokens[i + 1]?.type !== "NUMBER") return null;
+  if (tokens[i + 2]?.type !== "PERCENT") return null;
+  return createFusedToken(text === "up" ? "PCT_UP" : "PCT_DOWN", text, [word]);
+}
+function percentUpDownNormalizerRule(priority = 68) {
+  return {
+    name: "percentage:up-down",
+    priority,
+    match(tokens, pos) {
+      const here = tokens[pos];
+      if (here && (here.type === "NUMBER" || here.type === "RPAREN")) {
+        const step2 = stepTokenAt(tokens, pos + 1);
+        if (step2) {
+          return {
+            consumed: 2,
+            replacement: [here, step2],
+            ruleName: "percentage:up-down"
+          };
+        }
+      }
+      const step = stepTokenAt(tokens, pos);
+      if (step) {
+        return {
+          consumed: 1,
+          replacement: [step],
+          ruleName: "percentage:up-down"
+        };
+      }
+      return null;
+    }
+  };
+}
+
 // src/packages/percentage/PercentagePackage.ts
 var PERCENTAGE_PACKAGE = {
   name: "solve-percentage",
@@ -536,14 +659,18 @@ var PERCENTAGE_PACKAGE = {
     { tokenType: "OFF_WHAT_IS", parselet: new OnOffWhatIsParselet(-1) },
     { tokenType: "TO", parselet: new PercentageChangeParselet() },
     { tokenType: "INCREASE_BY", parselet: new IncreaseByParselet(1) },
-    { tokenType: "DECREASE_BY", parselet: new IncreaseByParselet(-1) }
+    { tokenType: "DECREASE_BY", parselet: new IncreaseByParselet(-1) },
+    // Successive change: "120 up 10% then down 10%" is 118.80, not 120.
+    { tokenType: "PCT_UP", parselet: new UpDownParselet(1) },
+    { tokenType: "PCT_DOWN", parselet: new UpDownParselet(-1) }
   ],
   prefixParselets: [
     { tokenType: "INCREASE", parselet: new IncreaseDecreaseParselet(1) },
     { tokenType: "DECREASE", parselet: new IncreaseDecreaseParselet(-1) }
   ],
   normalizerRules: [
-    percentOnOffNormalizerRule()
+    percentOnOffNormalizerRule(),
+    percentUpDownNormalizerRule()
   ]
 };
 
@@ -945,6 +1072,34 @@ var WorkdaysInParselet = class {
   }
 };
 
+// src/packages/datetime/parselets/WorkdayOffsetParselet.ts
+var WorkdayOffsetParselet = class {
+  /** @param direction "forward" for after/from, "backward" for before. */
+  constructor(direction) {
+    this.direction = direction;
+    this.category = "Date/Time";
+    this.bindingPower = BindingPower.Conditional;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(BindingPower.Sum, builder);
+    builder.emitOpcode(96 /* DATE_WORKDAY_OFFSET */);
+    builder.emitByte(this.direction === "backward" ? 1 : 0);
+  }
+};
+
+// src/packages/datetime/parselets/WorkdaysBetweenParselet.ts
+var WorkdaysBetweenParselet = class {
+  constructor() {
+    this.category = "Date/Time";
+  }
+  parse(parser, _token, builder) {
+    parser.parseExpression(BindingPower.Product, builder);
+    parser.consume("AND_CONJ");
+    parser.parseExpression(BindingPower.Lowest, builder);
+    builder.emitOpcode(97 /* DATE_WORKDAYS_BETWEEN */);
+  }
+};
+
 // src/packages/datetime/parselets/DateFieldQueryParselet.ts
 var DateFieldQueryParselet = class {
   constructor(functionIndex, mode) {
@@ -1499,6 +1654,26 @@ var DATETIME_PACKAGE = {
   name: "solve-datetime",
   phrases: {
     "workdays in": "WORKDAYS_IN",
+    // Business-day arithmetic in words. "after"/"from" count forward, "before"
+    // back; the count is the left operand, so these fuse as INFIX tokens (see
+    // WorkdayOffsetParselet). Both "working" and "business" days, singular and
+    // plural, so "1 working day after" and "5 business days from" both read.
+    "working days after": "WORKDAYS_AFTER",
+    "business days after": "WORKDAYS_AFTER",
+    "working day after": "WORKDAYS_AFTER",
+    "business day after": "WORKDAYS_AFTER",
+    "working days from": "WORKDAYS_AFTER",
+    "business days from": "WORKDAYS_AFTER",
+    "working day from": "WORKDAYS_AFTER",
+    "business day from": "WORKDAYS_AFTER",
+    "working days before": "WORKDAYS_BEFORE",
+    "business days before": "WORKDAYS_BEFORE",
+    "working day before": "WORKDAYS_BEFORE",
+    "business day before": "WORKDAYS_BEFORE",
+    // The count form (prefix). Fusing the whole "working days between" keeps
+    // the bare `days between` rule from claiming the "days" first.
+    "working days between": "WORKDAYS_BETWEEN",
+    "business days between": "WORKDAYS_BETWEEN",
     "day of the week on": "WEEKDAY_ON",
     "weekday on": "WEEKDAY_ON",
     "current timestamp": "CURRENT_TIMESTAMP",
@@ -1546,6 +1721,7 @@ var DATETIME_PACKAGE = {
     { tokenType: "UNTIL_UNIT", parselet: new UntilSinceParselet("until") },
     { tokenType: "SINCE_UNIT", parselet: new UntilSinceParselet("since") },
     { tokenType: "WORKDAYS_IN", parselet: new WorkdaysInParselet() },
+    { tokenType: "WORKDAYS_BETWEEN", parselet: new WorkdaysBetweenParselet() },
     { tokenType: "WEEKDAY_ON", parselet: new DateFieldQueryParselet(WEEKDAY_ON_FN_IDX, "on") },
     { tokenType: "WEEKDAY_IN", parselet: new DateFieldQueryParselet(WEEKDAY_ON_FN_IDX, "in") },
     { tokenType: "MONTH_ON", parselet: new DateFieldQueryParselet(MONTH_ON_FN_IDX, "on") },
@@ -1557,6 +1733,8 @@ var DATETIME_PACKAGE = {
     { tokenType: "DATETIME_LITERAL", parselet: new DateLiteralParselet() }
   ],
   infixParselets: [
+    { tokenType: "WORKDAYS_AFTER", parselet: new WorkdayOffsetParselet("forward") },
+    { tokenType: "WORKDAYS_BEFORE", parselet: new WorkdayOffsetParselet("backward") },
     { tokenType: "TO_DATE", parselet: new ToDateParselet() },
     { tokenType: "TO_TIMESTAMP", parselet: new ToTimestampParselet() },
     { tokenType: "IS_WEEKEND", parselet: new DayTypePredicateParselet(IS_WEEKEND_FN_IDX) },
@@ -2767,6 +2945,159 @@ var VARIABLES_PACKAGE = {
   ]
 };
 
+// src/uom/HistoricalCurrency.ts
+var HISTORICAL_CURRENCY_NS = "currency-historical";
+var HISTORICAL_CURRENCY_FN_IDX = allocatePluginFunctionIndex();
+var HistoricalCurrencyErrorCodes = {
+  /** No {@link HistoricalRateProvider} was supplied, so `on <date>` conversions cannot be answered. NOT a fall back to today's rate. */
+  NOT_CONFIGURED: "HISTORICAL_RATES_NOT_CONFIGURED",
+  /** The host provider threw or timed out for one pair/date. Transient, evicted after a cooldown so a retry can happen. */
+  QUERY_FAILED: "HISTORICAL_RATE_QUERY_FAILED",
+  /** The VM reached the conversion before preflight cached its rate, a "shouldn't happen" invariant break, not a user error. */
+  NOT_PREFLIGHTED: "HISTORICAL_RATE_NOT_PREFLIGHTED",
+  /** The amount being converted was not a currency Value (bad bytecode, or a non-currency left operand). */
+  INVALID_OPERAND: "HISTORICAL_CURRENCY_INVALID_OPERAND"
+};
+var FAILURE_COOLDOWN_MS = 3e4;
+var HISTORICAL_RATE_STALE_TIME_MS = Infinity;
+var FETCH_TIMEOUT_MS = 1e4;
+function historicalRateQueryKey(from, to, isoDate) {
+  return [HISTORICAL_CURRENCY_NS, `${from.toUpperCase()}:${to.toUpperCase()}:${isoDate}`];
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function tryConsumeCurrencyOnDate(parser, to, from) {
+  if (!sharedCurrencyExchange.isCurrency(to)) return null;
+  if (from !== void 0 && !sharedCurrencyExchange.isCurrency(from)) return null;
+  const onToken = parser.peek();
+  if (!onToken || onToken.type !== "IDENT" || onToken.value.toLowerCase() !== "on") return null;
+  const dateToken = parser.peekAt(1);
+  if (!dateToken || dateToken.type !== "DATETIME_LITERAL") return null;
+  parser.consume();
+  parser.consume();
+  const date = new Date(Number(dateToken.value));
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+async function fetchHistoricalRate(provider, from, to, isoDate, signal, queryClient) {
+  const fromUpper = from.toUpperCase();
+  const toUpper = to.toUpperCase();
+  if (!provider) {
+    return errorValue(
+      HistoricalCurrencyErrorCodes.NOT_CONFIGURED,
+      `Historical exchange rates are not configured. Supply historicalRateProvider via createCurrencyPackage({ ... }) to convert ${fromUpper} to ${toUpper} on ${isoDate}.`
+    );
+  }
+  const { signal: fetchSignal, cleanup } = createTimeoutSignal(signal, FETCH_TIMEOUT_MS, "Historical currency rate fetch");
+  try {
+    const rate = await provider(fromUpper, toUpper, isoDate, fetchSignal);
+    return numberValue(rate);
+  } catch (error) {
+    const failedValue = errorValue(
+      HistoricalCurrencyErrorCodes.QUERY_FAILED,
+      `Failed to resolve the historical rate for ${fromUpper} to ${toUpper} on ${isoDate}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    const key = historicalRateQueryKey(from, to, isoDate);
+    const cooldownTimer = setTimeout(() => {
+      if (queryClient.getQueryData(key) === failedValue) {
+        queryClient.removeQueries({ queryKey: key, exact: true });
+      }
+    }, FAILURE_COOLDOWN_MS);
+    cooldownTimer.unref?.();
+    return failedValue;
+  } finally {
+    cleanup();
+  }
+}
+function createHistoricalCurrencyPluginFunction(provider) {
+  return (args) => {
+    const amount = args[0];
+    const toArg = args[1];
+    const dateArg = args[2];
+    const fault = faultedOperand(amount);
+    if (fault) return fault;
+    if (amount.type !== 6 /* Uom */ || amount.unit === void 0 || !sharedCurrencyExchange.isCurrency(amount.unit)) {
+      return errorValue(
+        HistoricalCurrencyErrorCodes.INVALID_OPERAND,
+        `Historical conversion needs an amount in a currency, for example "100 USD in GBP on 2024-01-15".`
+      );
+    }
+    const from = amount.unit;
+    const to = String(toArg.value);
+    const isoDate = String(dateArg.value);
+    if (from.toUpperCase() === to.toUpperCase()) {
+      return uomValue(amount.toNumber(), to);
+    }
+    const queryClient = getActiveQueryClient();
+    const key = historicalRateQueryKey(from, to, isoDate);
+    const cached = queryClient?.getQueryData(key);
+    if (cached === void 0) {
+      if (!queryClient) {
+        return errorValue(
+          HistoricalCurrencyErrorCodes.NOT_PREFLIGHTED,
+          `No historical rate resolved for ${from.toUpperCase()} to ${to.toUpperCase()} on ${isoDate}.`
+        );
+      }
+      return queryClient.fetchQuery({
+        queryKey: key,
+        queryFn: ({ signal }) => fetchHistoricalRate(provider, from, to, isoDate, signal, queryClient),
+        staleTime: HISTORICAL_RATE_STALE_TIME_MS
+      });
+    }
+    if (cached.type === 13 /* Error */) return cached;
+    const rate = cached.value;
+    return uomValue(amount.toNumber() * rate, to);
+  };
+}
+function createHistoricalCurrencyResolver(provider) {
+  return {
+    namespace: HISTORICAL_CURRENCY_NS,
+    preflight(_tokens, bytecode, packageId, signal, queryClient) {
+      const { opcodes, strings } = bytecode;
+      const len = opcodes.length;
+      let i = 0;
+      let stringIdxs = [];
+      while (i < len) {
+        const op = opcodes[i];
+        if (op === 13 /* PUSH_STRING */) {
+          stringIdxs.push(opcodes[i + 1]);
+        } else if (op === 50 /* CALL_PLUGIN */) {
+          const fnIdx = opcodes[i + 1];
+          const argCount = opcodes[i + 2];
+          if (fnIdx === HISTORICAL_CURRENCY_FN_IDX && argCount === 3 && stringIdxs.length >= 3) {
+            const isoDate = strings[stringIdxs[stringIdxs.length - 1]];
+            const to = strings[stringIdxs[stringIdxs.length - 2]];
+            const sources = /* @__PURE__ */ new Set();
+            for (let k = 0; k < stringIdxs.length - 2; k++) {
+              const s = strings[stringIdxs[k]];
+              if (sharedCurrencyExchange.isCurrency(s)) sources.add(s.toUpperCase());
+            }
+            if (sources.size === 1) {
+              const from = sources.values().next().value;
+              if (from !== to.toUpperCase()) {
+                const key = historicalRateQueryKey(from, to, isoDate);
+                if (queryClient.getQueryData(key) === void 0) {
+                  const resolver = queryClient.fetchQuery({
+                    queryKey: key,
+                    queryFn: ({ signal: qSignal }) => fetchHistoricalRate(provider, from, to, isoDate, qSignal, queryClient),
+                    staleTime: HISTORICAL_RATE_STALE_TIME_MS
+                  });
+                  return { queryKey: key.join(":"), resolver, packageId, signal, metadata: { from, to, isoDate } };
+                }
+              }
+            }
+          }
+          stringIdxs = [];
+        }
+        i = nextInstruction(opcodes, i);
+      }
+      return null;
+    },
+    destroy() {
+    }
+  };
+}
+
 // src/packages/uom/parselets/UomLiteralParselet.ts
 function resolveUnitAlias(rawUnit) {
   return resolveCurrencyAlias(rawUnit) ?? rawUnit;
@@ -2780,13 +3111,27 @@ var UomLiteralParselet = class {
     const unit = resolveUnitAlias(token.value);
     builder.emitOpcode(13 /* PUSH_STRING */);
     builder.emitString(unit);
-    if (parser.peek()?.type === "TO" || parser.peek()?.type === "IN") {
+    const boundInsideProduct = parser.infixMinBindingPower >= BindingPower.Product;
+    if (!boundInsideProduct && (parser.peek()?.type === "TO" || parser.peek()?.type === "IN")) {
       parser.consume();
       const targetToken = parser.peek();
       if (targetToken?.type === "UNIT" || targetToken?.type === "IN") {
         parser.consume();
+        const targetUnit = resolveUnitAlias(targetToken.value);
+        const isoDate = tryConsumeCurrencyOnDate(parser, targetUnit, unit);
+        if (isoDate !== null) {
+          builder.emitOpcode(80 /* UOM_CONVERT */);
+          builder.emitOpcode(13 /* PUSH_STRING */);
+          builder.emitString(targetUnit);
+          builder.emitOpcode(13 /* PUSH_STRING */);
+          builder.emitString(isoDate);
+          builder.emitOpcode(50 /* CALL_PLUGIN */);
+          builder.emitIndex(HISTORICAL_CURRENCY_FN_IDX);
+          builder.emitIndex(3);
+          return;
+        }
         builder.emitOpcode(13 /* PUSH_STRING */);
-        builder.emitString(resolveUnitAlias(targetToken.value));
+        builder.emitString(targetUnit);
         builder.emitOpcode(81 /* UOM_CONVERT_TO */);
         return;
       }
@@ -3406,6 +3751,28 @@ function multiWordUnitNormalizerRule(priority = 78) {
   };
 }
 
+// src/packages/uom/normalizer/CompoundUnitNormalizerRule.ts
+function compoundUnitNormalizerRule(priority = 77) {
+  return {
+    name: "uom:compound-unit",
+    priority,
+    match(tokens, pos) {
+      const numerator = tokens[pos];
+      const slash = tokens[pos + 1];
+      const denominator = tokens[pos + 2];
+      if (numerator?.type !== "UNIT") return null;
+      if (slash?.type !== "SLASH") return null;
+      if (denominator?.type !== "UNIT") return null;
+      const spelling = `${numerator.value}/${denominator.value}`;
+      return {
+        consumed: 3,
+        replacement: [createFusedToken("UNIT", spelling, [numerator, slash, denominator])],
+        ruleName: "uom:compound-unit"
+      };
+    }
+  };
+}
+
 // src/packages/uom/UomPackage.ts
 var UOM_PACKAGE = {
   name: "solve-uom",
@@ -3424,6 +3791,9 @@ var UOM_PACKAGE = {
     // Highest priority of the unit rules: a two-word spelling has to become one
     // token before anything else reads the first word as a unit on its own.
     multiWordUnitNormalizerRule(),
+    // Above the bare-denominator rule (75): a slash-notation compound unit like
+    // `km/h` is claimed whole before the slash is read as a bare denominator.
+    compoundUnitNormalizerRule(),
     uomPossibilitiesNormalizerRule(),
     compoundQuantityNormalizerRule(),
     twoUnitConversionNormalizerRule(),
@@ -3466,32 +3836,59 @@ var InParselet = class {
     const targetToken = parser.peek();
     if (targetToken && (targetToken.type === "UNIT" || targetToken.type === "DOLLAR" || targetToken.type === "POUND" || targetToken.type === "EURO" || targetToken.type === "YEN" || targetToken.type === "RUBLE" || targetToken.type === "WON" || targetToken.type === "CURRENCY_SYMBOL" || targetToken.type === "IDENT" || targetToken.type === "IN")) {
       parser.consume();
+      const targetUnit = resolveCurrencyAlias(targetToken.value) ?? targetToken.value;
+      const isoDate = tryConsumeCurrencyOnDate(parser, targetUnit);
+      if (isoDate !== null) {
+        builder.emitOpcode(13 /* PUSH_STRING */);
+        builder.emitString(targetUnit);
+        builder.emitOpcode(13 /* PUSH_STRING */);
+        builder.emitString(isoDate);
+        builder.emitOpcode(50 /* CALL_PLUGIN */);
+        builder.emitIndex(HISTORICAL_CURRENCY_FN_IDX);
+        builder.emitIndex(3);
+        return;
+      }
       builder.emitOpcode(13 /* PUSH_STRING */);
-      builder.emitString(resolveCurrencyAlias(targetToken.value) ?? targetToken.value);
+      builder.emitString(targetUnit);
       builder.emitOpcode(84 /* UOM_CONVERT_IN */);
     }
   }
 };
 
 // src/packages/currency/CurrencyPackage.ts
-var CURRENCY_PACKAGE = {
-  name: "solve-currency",
-  asyncResolvers: [new CurrencyAsyncResolver()],
-  prefixParselets: [
-    { tokenType: "DOLLAR", parselet: new CurrencySymbolParselet() },
-    { tokenType: "POUND", parselet: new CurrencySymbolParselet() },
-    { tokenType: "EURO", parselet: new CurrencySymbolParselet() },
-    { tokenType: "YEN", parselet: new CurrencySymbolParselet() },
-    { tokenType: "RUBLE", parselet: new CurrencySymbolParselet() },
-    { tokenType: "WON", parselet: new CurrencySymbolParselet() },
-    // Every currency symbol added after the original six above shares this
-    // one generic token type. See Token.ts's CURRENCY_SYMBOL doc comment.
-    { tokenType: "CURRENCY_SYMBOL", parselet: new CurrencySymbolParselet() }
-  ],
-  infixParselets: [
-    { tokenType: "IN", parselet: new InParselet() }
-  ]
-};
+function createCurrencyPackage(config = {}) {
+  return {
+    name: "solve-currency",
+    asyncResolvers: [
+      new CurrencyAsyncResolver(),
+      createHistoricalCurrencyResolver(config.historicalRateProvider)
+    ],
+    prefixParselets: [
+      { tokenType: "DOLLAR", parselet: new CurrencySymbolParselet() },
+      { tokenType: "POUND", parselet: new CurrencySymbolParselet() },
+      { tokenType: "EURO", parselet: new CurrencySymbolParselet() },
+      { tokenType: "YEN", parselet: new CurrencySymbolParselet() },
+      { tokenType: "RUBLE", parselet: new CurrencySymbolParselet() },
+      { tokenType: "WON", parselet: new CurrencySymbolParselet() },
+      // Every currency symbol added after the original six above shares this
+      // one generic token type. See Token.ts's CURRENCY_SYMBOL doc comment.
+      { tokenType: "CURRENCY_SYMBOL", parselet: new CurrencySymbolParselet() }
+    ],
+    infixParselets: [
+      { tokenType: "IN", parselet: new InParselet() }
+    ],
+    pluginFunctions: [
+      // Historical conversions (`<money> in <currency> on <date>`) compile to a
+      // CALL_PLUGIN at this shared index (see uom/HistoricalCurrency.ts). One
+      // index serves every pair and date, the query is the amount plus the
+      // target and date strings. The handler carries the same provider as the
+      // resolver, so a source currency known only at runtime (`x in GBP on
+      // <date>`) can fetch the rate the bytecode scan could not preflight.
+      { index: HISTORICAL_CURRENCY_FN_IDX, handler: createHistoricalCurrencyPluginFunction(config.historicalRateProvider) }
+    ]
+  };
+}
+var CURRENCY_PACKAGE = createCurrencyPackage();
 
 // src/packages/vector/parselets/VectorParselet.ts
 var VectorParselet = class {
@@ -5160,6 +5557,34 @@ var AnnualReturnParselet = class {
   }
 };
 
+// src/packages/finance/parselets/TermRateClauses.ts
+function parseTermAndRate(parser, builder, termWords) {
+  if (matchTerm(parser, termWords)) {
+    parser.parseExpression(BindingPower.Lowest, builder);
+    consumeRate(parser);
+    parser.parseExpression(BindingPower.Lowest, builder);
+    return { swap: true };
+  }
+  consumeRate(parser);
+  parser.parseExpression(BindingPower.Lowest, builder);
+  consumeTerm(parser, termWords);
+  parser.parseExpression(BindingPower.Lowest, builder);
+  return { swap: false };
+}
+function matchTerm(parser, termWords) {
+  for (const word of termWords) {
+    if (parser.match(word)) return true;
+  }
+  return false;
+}
+function consumeTerm(parser, termWords) {
+  if (matchTerm(parser, termWords)) return;
+  parser.consume(termWords[0]);
+}
+function consumeRate(parser) {
+  if (!parser.match("RATE_AT")) parser.consume("AT");
+}
+
 // src/packages/finance/parselets/CompoundInterestParselet.ts
 var CompoundInterestParselet = class {
   /**
@@ -5174,14 +5599,9 @@ var CompoundInterestParselet = class {
   }
   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);
-    if (!parser.match("RATE_AT")) parser.consume("AT");
-    parser.parseExpression(BindingPower.Lowest, builder);
+    const { swap } = parseTermAndRate(parser, builder, ["AFTER", "FOR_DURATION", "OVER"]);
     const periods = readCompoundingInterval(parser);
-    builder.emitOpcode(2 /* SWAP */);
+    if (swap) builder.emitOpcode(2 /* SWAP */);
     if (periods === 1) {
       builder.emitOpcode(51 /* CALL_BUILTIN */);
       builder.emitIndex(this.builtinIndex);
@@ -5205,11 +5625,8 @@ var LoanRepaymentParselet = class {
   }
   parse(parser, _token, builder) {
     parser.parseExpression(BindingPower.Lowest, builder);
-    parser.consume("OVER");
-    parser.parseExpression(BindingPower.Lowest, builder);
-    if (!parser.match("RATE_AT")) parser.consume("AT");
-    parser.parseExpression(BindingPower.Lowest, builder);
-    builder.emitOpcode(2 /* SWAP */);
+    const { swap } = parseTermAndRate(parser, builder, ["OVER"]);
+    if (swap) builder.emitOpcode(2 /* SWAP */);
     builder.emitOpcode(10 /* PUSH_NUMBER */);
     builder.emitNumber(this.periodsPerYear);
     builder.emitOpcode(51 /* CALL_BUILTIN */);
@@ -5394,6 +5811,131 @@ function inYearDollarsNormalizerRule(priority = 70) {
   };
 }
 
+// src/packages/finance/normalizer/RecurringScheduleNormalizerRule.ts
+var RecurringScheduleErrorCodes = {
+  /** `every 0 weeks` and the like: the interval a payment repeats on has to be a positive count, or the number of payments is undefined. */
+  RECURRING_INTERVAL_NOT_POSITIVE: "RECURRING_INTERVAL_NOT_POSITIVE"
+};
+var PERIODS_PER_YEAR2 = {
+  daily: 365,
+  weekly: 52,
+  monthly: 12,
+  yearly: 1,
+  // "annually" reads better than "yearly" before a duration and means the
+  // same, so it is accepted as a spelling rather than a separate period.
+  annually: 1
+};
+var UNIT_PER_YEAR = {
+  day: 365,
+  days: 365,
+  week: 52,
+  weeks: 52,
+  month: 12,
+  months: 12,
+  year: 1,
+  years: 1
+};
+var ARTICLES3 = /* @__PURE__ */ new Set(["a", "an"]);
+var VALUE_ENDERS = /* @__PURE__ */ new Set([
+  "NUMBER",
+  "FLOAT",
+  "HEX",
+  "BIGINT",
+  "RPAREN",
+  "RBRACKET",
+  "IDENT",
+  "PERCENT",
+  "STRING"
+]);
+function wordOf(token) {
+  if (token === void 0) return "";
+  return (token.text ?? token.value ?? "").toLowerCase();
+}
+function unitPerYear(token) {
+  if (token === void 0 || token.type !== "UNIT") return void 0;
+  return UNIT_PER_YEAR[wordOf(token)];
+}
+function readPeriod(tokens, i) {
+  const head = tokens[i];
+  if (head === void 0) return null;
+  if (head.type === "IDENT") {
+    const simple = PERIODS_PER_YEAR2[wordOf(head)];
+    if (simple !== void 0) return { perYear: simple, consumed: 1 };
+    if (wordOf(head) === "every") {
+      const countToken = tokens[i + 1];
+      if (countToken?.type !== "NUMBER") return null;
+      const per = unitPerYear(tokens[i + 2]);
+      if (per === void 0) return null;
+      const n = Number((countToken.value ?? "").replace(/,/g, ""));
+      if (!(n > 0)) {
+        throw ErrorFactory.parsing({
+          code: RecurringScheduleErrorCodes.RECURRING_INTERVAL_NOT_POSITIVE,
+          message: `A recurring interval must be a positive number, not "${countToken.value}".`,
+          expected: "a positive interval, e.g. every 2 weeks",
+          found: `every ${countToken.value} ${wordOf(tokens[i + 2])}`
+        });
+      }
+      return { perYear: per / n, consumed: 3 };
+    }
+  }
+  return null;
+}
+function readDuration(tokens, i) {
+  const first = tokens[i];
+  if (first === void 0) return null;
+  let count;
+  let unitIndex;
+  if (first.type === "NUMBER") {
+    count = Number((first.value ?? "").replace(/,/g, ""));
+    unitIndex = i + 1;
+  } else if (first.type === "IDENT" && ARTICLES3.has(wordOf(first))) {
+    count = 1;
+    unitIndex = i + 1;
+  } else {
+    return null;
+  }
+  const per = unitPerYear(tokens[unitIndex]);
+  if (per === void 0) return null;
+  if (!Number.isFinite(count) || count < 0) return null;
+  return { years: count / per, consumed: unitIndex - i + 1 };
+}
+function wholePayments(perYear, durationYears) {
+  const raw = perYear * durationYears;
+  const nearest = Math.round(raw);
+  return Math.abs(raw - nearest) < 1e-9 ? nearest : Math.floor(raw);
+}
+function recurringScheduleNormalizerRule(priority = 78) {
+  return {
+    name: "finance:recurring-schedule",
+    priority,
+    match(tokens, pos) {
+      const amount = tokens[pos];
+      if (amount === void 0 || !VALUE_ENDERS.has(amount.type)) return null;
+      const period = readPeriod(tokens, pos + 1);
+      if (period === null) return null;
+      const forIndex = pos + 1 + period.consumed;
+      if (tokens[forIndex]?.type !== "FOR_DURATION") return null;
+      const duration = readDuration(tokens, forIndex + 1);
+      if (duration === null) return null;
+      const count = wholePayments(period.perYear, duration.years);
+      const consumed = forIndex + 1 + duration.consumed - pos;
+      const source = tokens.slice(pos, pos + consumed);
+      return {
+        // The amount is re-emitted unchanged, then `* <count>`. The amount may
+        // be the tail of a longer expression, whose earlier tokens are before
+        // `pos` and pass through on their own.
+        replacement: [
+          amount,
+          createFusedToken("STAR", "*", source),
+          createFusedToken("NUMBER", String(count), source)
+        ],
+        consumed,
+        ruleName: "finance:recurring-schedule"
+      };
+    }
+  };
+}
+
 // src/packages/finance/FinancePackage.ts
 var COMPOUND_FV = 51;
 var COMPOUND_INTEREST = 52;
@@ -5470,7 +6012,11 @@ var FINANCE_PACKAGE = {
     { tokenType: "IN_YEAR_DOLLARS", parselet: new InYearDollarsParselet() }
   ],
   normalizerRules: [
-    inYearDollarsNormalizerRule()
+    inYearDollarsNormalizerRule(),
+    // `450 monthly for 18 months` -> `450 * 18`. A recurring schedule totalled
+    // as a plain multiplication, so a currency amount stays currency and an
+    // exact one stays exact. See RecurringScheduleNormalizerRule.ts.
+    recurringScheduleNormalizerRule()
   ],
   pluginFunctions: [
     { index: INFLATION_FROM_YEAR_TO_PRESENT_IDX, handler: inflationFromYearToPresentHandler },
@@ -5630,7 +6176,7 @@ var WeatherErrorCodes = {
 };
 var GEOCODING_API_URL = "https://geocoding-api.open-meteo.com/v1/search";
 var FORECAST_API_URL = "https://api.open-meteo.com/v1/forecast";
-var FETCH_TIMEOUT_MS = 1e4;
+var FETCH_TIMEOUT_MS2 = 1e4;
 async function geocodeCity(city, signal) {
   const url = `${GEOCODING_API_URL}?name=${encodeURIComponent(city)}&count=1&language=en&format=json`;
   const response = await fetch(url, { signal });
@@ -5695,7 +6241,7 @@ function fetchCityWeather(city, signal) {
   if (cached && cached.expiresAt > now) {
     return cached.promise;
   }
-  const { signal: fetchSignal, cleanup } = createTimeoutSignal(signal, FETCH_TIMEOUT_MS, "Open-Meteo weather query");
+  const { signal: fetchSignal, cleanup } = createTimeoutSignal(signal, FETCH_TIMEOUT_MS2, "Open-Meteo weather query");
   const promise = (async () => {
     try {
       const geo = await geocodeCity(city, fetchSignal);
@@ -5804,7 +6350,7 @@ var MONTH_NAMES2 = {
   dec: 11,
   december: 11
 };
-function pad2(n) {
+function pad22(n) {
   return n < 10 ? `0${n}` : String(n);
 }
 function validateAndFormat(year, monthIndex, day, raw) {
@@ -5815,7 +6361,7 @@ function validateAndFormat(year, monthIndex, day, raw) {
       `"${raw}" is not a valid calendar date`
     );
   }
-  return { isoDate: `${year}-${pad2(monthIndex + 1)}-${pad2(day)}`, raw };
+  return { isoDate: `${year}-${pad22(monthIndex + 1)}-${pad22(day)}`, raw };
 }
 function requireYear(text, raw) {
   if (!/^\d{4}$/.test(text)) {
@@ -5834,7 +6380,7 @@ function tryParseDatePhrase(parser) {
     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())}`,
+      isoDate: `${date.getFullYear()}-${pad22(date.getMonth() + 1)}-${pad22(date.getDate())}`,
       raw: first.text ?? first.value
     };
   }
@@ -6483,6 +7029,927 @@ var LINES_PACKAGE = {
   ]
 };
 
+// src/packages/tables/parselets/ColumnAggregateParselet.ts
+var ColumnAggregateParselet = class {
+  constructor(pluginFnIndex) {
+    this.pluginFnIndex = pluginFnIndex;
+    this.category = "Tables";
+  }
+  parse(parser, _token, builder) {
+    const next = parser.peek();
+    if (!next || next.type !== "STRING") {
+      throw ErrorFactory.parsing(
+        "TABLE_COLUMN_NAME_EXPECTED",
+        `Expected a quoted column name after "... of column" but got ${next ? `"${next.value}"` : "end of input"}`
+      );
+    }
+    const nameToken = parser.consume("STRING");
+    while (true) {
+      const t = parser.peek();
+      if (!t) break;
+      if (t.type === "IN") {
+        parser.consume();
+        continue;
+      }
+      if (t.type === "IDENT" && ADDRESS_WORDS.has(t.value.toLowerCase())) {
+        parser.consume();
+        continue;
+      }
+      break;
+    }
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(nameToken.value);
+    builder.emitOpcode(50 /* CALL_PLUGIN */);
+    builder.emitIndex(this.pluginFnIndex);
+    builder.emitIndex(1);
+  }
+};
+var ADDRESS_WORDS = /* @__PURE__ */ new Set(["the", "table", "above"]);
+
+// src/packages/tables/TableReader.ts
+function isTableRow(line) {
+  return line.trimStart().startsWith("|");
+}
+function isSeparatorRow(line) {
+  const s = line.trim();
+  if (s.length === 0) return false;
+  if (!s.includes("-") || !s.includes("|")) return false;
+  return /^[|\s:-]+$/.test(s);
+}
+function splitTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "\\" && i + 1 < s.length && s[i + 1] === "|") {
+      cell += "|";
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += ch;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+function parseNumericCell(cell) {
+  if (cell === void 0) return null;
+  const trimmed = cell.trim();
+  if (trimmed.length === 0) return null;
+  const cleaned = trimmed.replace(/,/g, "");
+  if (!/^[+-]?(\d+(\.\d+)?|\.\d+)$/.test(cleaned)) return null;
+  const n = Number.parseFloat(cleaned);
+  return Number.isFinite(n) ? n : null;
+}
+function findTableAbove(getLineText, fromLine) {
+  let bottom = -1;
+  for (let n = fromLine - 1; n >= 1; n--) {
+    const text = getLineText(n);
+    if (text === void 0) break;
+    if (isTableRow(text)) {
+      bottom = n;
+      break;
+    }
+  }
+  if (bottom === -1) return null;
+  let top = bottom;
+  while (top - 1 >= 1) {
+    const text = getLineText(top - 1);
+    if (text === void 0 || !isTableRow(text)) break;
+    top--;
+  }
+  let separator = -1;
+  for (let n = top; n <= bottom; n++) {
+    if (isSeparatorRow(getLineText(n))) {
+      separator = n;
+      break;
+    }
+  }
+  if (separator === -1 || separator === top) return null;
+  const header = splitTableRow(getLineText(separator - 1));
+  const rows = [];
+  for (let n = separator + 1; n <= bottom; n++) {
+    rows.push(splitTableRow(getLineText(n)));
+  }
+  return { header, rows };
+}
+function columnIndex(header, name) {
+  const target = name.trim().toLowerCase();
+  for (let i = 0; i < header.length; i++) {
+    if (header[i].trim().toLowerCase() === target) return i;
+  }
+  return -1;
+}
+function numericColumn(table, colIndex) {
+  const out = [];
+  for (const row of table.rows) {
+    const value = parseNumericCell(row[colIndex]);
+    if (value !== null) out.push(value);
+  }
+  return out;
+}
+
+// src/packages/tables/TablesPluginFunctions.ts
+var TablesErrorCodes = {
+  /** Cross-line table reads need a real document, absent on the single-expression path. */
+  TABLE_NO_DOCUMENT: "TABLE_NO_DOCUMENT",
+  /** No markdown table was found above the query line. */
+  TABLE_NOT_FOUND: "TABLE_NOT_FOUND",
+  /** The named column is not one of the table's headers. */
+  TABLE_COLUMN_NOT_FOUND: "TABLE_COLUMN_NOT_FOUND",
+  /** The column held no plain-number cells to aggregate. */
+  TABLE_COLUMN_NO_NUMERIC_CELLS: "TABLE_COLUMN_NO_NUMERIC_CELLS"
+};
+function reduce(op, cells) {
+  switch (op) {
+    case "sum":
+      return cells.reduce((acc, n) => acc + n, 0);
+    case "average":
+      return cells.reduce((acc, n) => acc + n, 0) / cells.length;
+    case "min":
+      return Math.min(...cells);
+    case "max":
+      return Math.max(...cells);
+    case "count":
+      return cells.length;
+    case "median": {
+      const sorted = [...cells].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    }
+  }
+}
+function aggregateColumn(op, columnName2, context) {
+  const getLineText = context?.getLineText;
+  if (!getLineText || context.lineIndex < 1) {
+    return errorValue(
+      TablesErrorCodes.TABLE_NO_DOCUMENT,
+      "Reading a table column needs a real document, which the single-expression path (evaluateExpression) does not have"
+    );
+  }
+  const table = findTableAbove(getLineText, context.lineIndex);
+  if (!table) {
+    return errorValue(
+      TablesErrorCodes.TABLE_NOT_FOUND,
+      'No markdown table found above this line (a table row starts with "|", and needs a "|---|" separator under its header)'
+    );
+  }
+  const index = columnIndex(table.header, columnName2);
+  if (index === -1) {
+    const names = table.header.map((h) => `"${h}"`).join(", ");
+    return errorValue(
+      TablesErrorCodes.TABLE_COLUMN_NOT_FOUND,
+      `The table above has no column named "${columnName2}". Its columns are: ${names}`
+    );
+  }
+  const cells = numericColumn(table, index);
+  if (op === "count") return numberValue(cells.length);
+  if (cells.length === 0) {
+    return errorValue(
+      TablesErrorCodes.TABLE_COLUMN_NO_NUMERIC_CELLS,
+      `Column "${columnName2}" has no plain-number cells to aggregate (currency and unit cells are not read yet)`
+    );
+  }
+  return numberValue(reduce(op, cells));
+}
+function columnName(args) {
+  const value = args[0];
+  if (value && value.type === 3 /* String */ && typeof value.value === "string") {
+    return value.value;
+  }
+  return String(value?.value ?? "");
+}
+var TABLE_COLUMN_SUM_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnSumHandler(args, context) {
+  return aggregateColumn("sum", columnName(args), context);
+}
+var TABLE_COLUMN_AVERAGE_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnAverageHandler(args, context) {
+  return aggregateColumn("average", columnName(args), context);
+}
+var TABLE_COLUMN_MIN_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnMinHandler(args, context) {
+  return aggregateColumn("min", columnName(args), context);
+}
+var TABLE_COLUMN_MAX_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnMaxHandler(args, context) {
+  return aggregateColumn("max", columnName(args), context);
+}
+var TABLE_COLUMN_COUNT_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnCountHandler(args, context) {
+  return aggregateColumn("count", columnName(args), context);
+}
+var TABLE_COLUMN_MEDIAN_FN_IDX = allocatePluginFunctionIndex();
+function tableColumnMedianHandler(args, context) {
+  return aggregateColumn("median", columnName(args), context);
+}
+
+// src/packages/tables/TablesPackage.ts
+var TABLES_PACKAGE = {
+  name: "solve-tables",
+  phrases: {
+    "sum of column": "TABLE_COLUMN_SUM",
+    "total of column": "TABLE_COLUMN_SUM",
+    "average of column": "TABLE_COLUMN_AVERAGE",
+    "mean of column": "TABLE_COLUMN_AVERAGE",
+    "min of column": "TABLE_COLUMN_MIN",
+    "minimum of column": "TABLE_COLUMN_MIN",
+    "max of column": "TABLE_COLUMN_MAX",
+    "maximum of column": "TABLE_COLUMN_MAX",
+    "count of column": "TABLE_COLUMN_COUNT",
+    "median of column": "TABLE_COLUMN_MEDIAN"
+  },
+  prefixParselets: [
+    { tokenType: "TABLE_COLUMN_SUM", parselet: new ColumnAggregateParselet(TABLE_COLUMN_SUM_FN_IDX) },
+    { tokenType: "TABLE_COLUMN_AVERAGE", parselet: new ColumnAggregateParselet(TABLE_COLUMN_AVERAGE_FN_IDX) },
+    { tokenType: "TABLE_COLUMN_MIN", parselet: new ColumnAggregateParselet(TABLE_COLUMN_MIN_FN_IDX) },
+    { tokenType: "TABLE_COLUMN_MAX", parselet: new ColumnAggregateParselet(TABLE_COLUMN_MAX_FN_IDX) },
+    { tokenType: "TABLE_COLUMN_COUNT", parselet: new ColumnAggregateParselet(TABLE_COLUMN_COUNT_FN_IDX) },
+    { tokenType: "TABLE_COLUMN_MEDIAN", parselet: new ColumnAggregateParselet(TABLE_COLUMN_MEDIAN_FN_IDX) }
+  ],
+  pluginFunctions: [
+    { index: TABLE_COLUMN_SUM_FN_IDX, handler: tableColumnSumHandler },
+    { index: TABLE_COLUMN_AVERAGE_FN_IDX, handler: tableColumnAverageHandler },
+    { index: TABLE_COLUMN_MIN_FN_IDX, handler: tableColumnMinHandler },
+    { index: TABLE_COLUMN_MAX_FN_IDX, handler: tableColumnMaxHandler },
+    { index: TABLE_COLUMN_COUNT_FN_IDX, handler: tableColumnCountHandler },
+    { index: TABLE_COLUMN_MEDIAN_FN_IDX, handler: tableColumnMedianHandler }
+  ]
+};
+
+// src/packages/uncertainty/parselets/UncertaintyParselet.ts
+var UncertaintyParselet = class {
+  constructor() {
+    this.category = "operator";
+    this.bindingPower = BindingPower.Uncertainty;
+  }
+  parse(parser, _left, _token, builder) {
+    parser.parseExpression(this.bindingPower, builder);
+    builder.emitOpcode(28 /* MAKE_UNCERTAIN */);
+  }
+};
+
+// src/packages/uncertainty/normalizer/AsciiPlusMinusNormalizerRule.ts
+function asciiPlusMinusNormalizerRule(priority = 90) {
+  return {
+    name: "uncertainty:ascii-plus-minus",
+    priority,
+    match(tokens, pos) {
+      const plus = tokens[pos];
+      if (plus?.type !== "PLUS") return null;
+      const slash = tokens[pos + 1];
+      if (slash?.type !== "SLASH") return null;
+      const minus = tokens[pos + 2];
+      if (minus?.type !== "MINUS") return null;
+      return {
+        consumed: 3,
+        replacement: [createFusedToken("PLUS_MINUS", "\xB1", [plus, slash, minus])],
+        ruleName: "uncertainty:ascii-plus-minus"
+      };
+    }
+  };
+}
+
+// src/packages/uncertainty/UncertaintyPackage.ts
+var UNCERTAINTY_PACKAGE = {
+  name: "solve-uncertainty",
+  infixParselets: [
+    { tokenType: "PLUS_MINUS", parselet: new UncertaintyParselet() }
+  ],
+  normalizerRules: [asciiPlusMinusNormalizerRule()]
+  // PLUS_MINUS is a core lexer token, so its highlight category lives in the
+  // built-in language/TokenCategoryMap.ts rather than being contributed here.
+};
+
+// src/packages/goalseek/GoalSeekPluginFunctions.ts
+var SEARCH_LOWER_BOUND = 1e-9;
+var SEARCH_UPPER_BOUND = 1e9;
+var FALLBACK_MAX_ITERATIONS = 100;
+var ABSOLUTE_VALUE_TOLERANCE = 1e-9;
+var RELATIVE_VALUE_TOLERANCE = 1e-9;
+var INTERVAL_COLLAPSE_WIDTH = 1e-12;
+var REAL_ROOT_IMAGINARY_TOLERANCE = 1e-9;
+var GOAL_SEEK_FN_IDX = allocatePluginFunctionIndex();
+function goalSeekHandler(args, context) {
+  const probe = context?.evaluateLineWithBinding;
+  const getLineReads = context?.getLineReads;
+  if (!probe || !getLineReads) {
+    return errorValue(
+      "GOAL_SEEK_NO_DOCUMENT",
+      "Goal seek only works inside a document, since it re-runs another line. The single-expression entry point has no document to solve against."
+    );
+  }
+  const targetLine = args[0].toNumber();
+  const varName = typeof args[1].value === "string" ? args[1].value : String(args[1].value);
+  const targetArg = args[2];
+  if (targetArg.type !== 0 /* Number */ && targetArg.type !== 6 /* Uom */) {
+    return errorValue("GOAL_SEEK_TARGET_NOT_NUMERIC", `Goal seek's target must be a number, as in "solve line ${targetLine} for ${varName} = 900".`);
+  }
+  const target = targetArg.toNumber();
+  if (!Number.isFinite(target)) {
+    return errorValue("GOAL_SEEK_TARGET_NOT_NUMERIC", "Goal seek's target is not a finite number.");
+  }
+  const reads = getLineReads(targetLine);
+  if (reads === void 0) {
+    return errorValue("GOAL_SEEK_LINE_NOT_READY", `Line ${targetLine} has no evaluated expression to solve (forward reference, out of range, or not an expression).`);
+  }
+  if (!reads.includes(varName)) {
+    return errorValue("GOAL_SEEK_VARIABLE_NOT_USED", `Line ${targetLine} does not use ${varName}, so changing ${varName} cannot move its result toward ${target}.`);
+  }
+  const symbolic = probe(targetLine, varName, symbolicValue(varNode(varName)), true);
+  if (symbolic.type === 9 /* Symbolic */) {
+    const exact = solveClosedForm(symbolic.value, target, varName);
+    if (exact !== null) return numberValue(exact);
+  }
+  const maxIterations = context.goalSeekMaxIterations ?? FALLBACK_MAX_ITERATIONS;
+  return bisect(probe, targetLine, varName, target, maxIterations);
+}
+function solveClosedForm(lhs, target, variable) {
+  const rhs = constNode(rationalFromNumber(target));
+  let outcome;
+  try {
+    outcome = solveForVariable(lhs, rhs, variable);
+  } catch {
+    return null;
+  }
+  if (outcome.kind !== "roots") return null;
+  const candidates = [];
+  for (const node of outcome.exact) {
+    const simplified = simplifySymbolic(node);
+    if (simplified.kind === "const") {
+      const value = rationalToNumber(simplified.value);
+      if (Number.isFinite(value)) candidates.push(value);
+    }
+  }
+  for (const root of outcome.approximate) {
+    if (Math.abs(root.im) <= REAL_ROOT_IMAGINARY_TOLERANCE && Number.isFinite(root.re)) candidates.push(root.re);
+  }
+  if (candidates.length === 0) return null;
+  const inDomain = candidates.filter((c) => c >= SEARCH_LOWER_BOUND && c <= SEARCH_UPPER_BOUND);
+  const pool = inDomain.length > 0 ? inDomain : candidates;
+  pool.sort((a, b) => Math.abs(a) - Math.abs(b));
+  return pool[0];
+}
+function bisect(probe, targetLine, variable, target, maxIterations) {
+  const sample = (candidate) => {
+    const result = probe(targetLine, variable, numberValue(candidate), false);
+    if (result.type === 13 /* Error */) return { error: result };
+    if (result.type !== 0 /* Number */ && result.type !== 6 /* Uom */) {
+      return { error: errorValue("GOAL_SEEK_TARGET_NOT_NUMERIC", `Line ${targetLine} did not produce a number when ${variable} was set to ${candidate}, so goal seek cannot compare it to the target.`) };
+    }
+    const numeric = result.toNumber();
+    if (!Number.isFinite(numeric)) return { error: errorValue("GOAL_SEEK_NON_FINITE", `Line ${targetLine}'s result is not finite when ${variable} is ${candidate}.`) };
+    return { value: numeric };
+  };
+  let lo = SEARCH_LOWER_BOUND;
+  let hi = SEARCH_UPPER_BOUND;
+  const loSample = sample(lo);
+  if ("error" in loSample) return loSample.error;
+  const hiSample = sample(hi);
+  if ("error" in hiSample) return hiSample.error;
+  const tolerance = Math.max(ABSOLUTE_VALUE_TOLERANCE, Math.abs(target) * RELATIVE_VALUE_TOLERANCE);
+  let flo = loSample.value - target;
+  const fhi = hiSample.value - target;
+  if (Math.abs(flo) <= tolerance) return numberValue(lo);
+  if (Math.abs(fhi) <= tolerance) return numberValue(hi);
+  if (Math.sign(flo) === Math.sign(fhi)) {
+    return errorValue(
+      "GOAL_SEEK_NO_SOLUTION",
+      `No value of ${variable} between ${lo} and ${hi} makes line ${targetLine} equal ${target}: across that whole range its result stays on one side of the target.`
+    );
+  }
+  for (let step = 0; step < maxIterations; step++) {
+    const mid = (lo + hi) / 2;
+    const midSample = sample(mid);
+    if ("error" in midSample) return midSample.error;
+    const fmid = midSample.value - target;
+    if (Math.abs(fmid) <= tolerance) return numberValue(mid);
+    if (hi - lo <= INTERVAL_COLLAPSE_WIDTH) {
+      return errorValue(
+        "GOAL_SEEK_DID_NOT_CONVERGE",
+        `Goal seek narrowed ${variable} to a single point near ${mid} without line ${targetLine} reaching ${target}: the relationship jumps across the target rather than passing through it.`
+      );
+    }
+    if (Math.sign(fmid) === Math.sign(flo)) {
+      lo = mid;
+      flo = fmid;
+    } else {
+      hi = mid;
+    }
+  }
+  return errorValue(
+    "GOAL_SEEK_DID_NOT_CONVERGE",
+    `Goal seek did not bring line ${targetLine} within tolerance of ${target} by varying ${variable} in ${maxIterations} steps.`
+  );
+}
+
+// src/packages/goalseek/parselets/GoalSeekParselet.ts
+var GoalSeekParselet = class {
+  constructor() {
+    this.category = "GoalSeek";
+  }
+  parse(parser, _token, builder) {
+    const lineRef = parser.peek();
+    if (!lineRef || lineRef.type !== "LINE_REF") {
+      throw ErrorFactory.parsing(
+        "GOAL_SEEK_SYNTAX",
+        `Goal seek reads "solve line N for <var> = <target>", for example "solve line 4 for rate = 900".`,
+        { found: lineRef?.type ?? "end of input" }
+      );
+    }
+    parser.consume();
+    const targetLine = parseInt(lineRef.value, 10);
+    const connective = parser.peek();
+    const isFor = !!connective && (connective.type === "FOR_DURATION" || connective.type === "IDENT" && connective.value.toLowerCase() === "for");
+    if (!isFor) {
+      throw ErrorFactory.parsing(
+        "GOAL_SEEK_SYNTAX",
+        `Goal seek reads "solve line N for <var> = <target>". Expected "for" after the line reference.`,
+        { found: connective?.type ?? "end of input" }
+      );
+    }
+    parser.consume();
+    const variable = parser.peek();
+    if (!variable || variable.type !== "IDENT" && variable.type !== "UNIT") {
+      throw ErrorFactory.parsing(
+        "GOAL_SEEK_REQUIRES_VARIABLE_NAME",
+        `Goal seek needs the name of the variable to vary here, as in "solve line 4 for rate = 900".`,
+        { found: variable?.type ?? "end of input" }
+      );
+    }
+    parser.consume();
+    parser.consume("EQUALS");
+    builder.emitOpcode(10 /* PUSH_NUMBER */);
+    builder.emitNumber(targetLine);
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(variable.value);
+    parser.parseExpression(BindingPower.Lowest, builder);
+    builder.emitOpcode(50 /* CALL_PLUGIN */);
+    builder.emitIndex(GOAL_SEEK_FN_IDX);
+    builder.emitIndex(3);
+  }
+};
+
+// src/packages/goalseek/normalizer/GoalSeekNormalizerRule.ts
+var GOAL_SEEK_TYPE_ID = tokenTypeId("GOAL_SEEK");
+function goalSeekNormalizerRule(priority = 75) {
+  return {
+    name: "goalseek:solve-line",
+    priority,
+    match(tokens, pos) {
+      if (pos > 0 && tokens[pos - 1].type === "COLON") return null;
+      const token = tokens[pos];
+      if (!token || token.type !== "IDENT" || token.value.toLowerCase() !== "solve") return null;
+      if (tokens[pos + 1]?.type !== "LINE_REF") return null;
+      return {
+        consumed: 1,
+        replacement: [
+          new LexerToken("GOAL_SEEK", GOAL_SEEK_TYPE_ID, token.value, token.value, token.offset, 0, token.line, token.col)
+        ],
+        ruleName: "goalseek:solve-line"
+      };
+    }
+  };
+}
+
+// src/packages/goalseek/GoalSeekPackage.ts
+var GOALSEEK_PACKAGE = {
+  name: "solve-goalseek",
+  normalizerRules: [goalSeekNormalizerRule()],
+  prefixParselets: [{ tokenType: "GOAL_SEEK", parselet: new GoalSeekParselet() }],
+  pluginFunctions: [{ index: GOAL_SEEK_FN_IDX, handler: goalSeekHandler }]
+  // GOAL_SEEK's highlight category lives in the static TokenCategoryMap
+  // alongside every other token declared in Token.ts's TokenTypes (the same
+  // place the lines package's LINE_REF etc. are categorized), so it is not
+  // repeated here.
+};
+
+// src/packages/colour/ColourPluginFunctions.ts
+var ColourErrorCodes = {
+  /** A string was not a hex colour or a known CSS colour name. */
+  COLOUR_INVALID: "COLOUR_INVALID",
+  /** A function expected a colour argument and got something else. */
+  COLOUR_EXPECTED_COLOUR: "COLOUR_EXPECTED_COLOUR",
+  /** A function was called with the wrong number or type of arguments. */
+  COLOUR_BAD_ARGUMENTS: "COLOUR_BAD_ARGUMENTS"
+};
+function colourOf(v) {
+  return v && v.type === 14 /* Colour */ ? v.value : null;
+}
+function readAmount(v) {
+  if (!v) return 0;
+  const n = v.toNumber();
+  if (v.type === 5 /* Percentage */) return n;
+  return n > 1 ? n / 100 : n;
+}
+function badArgs(fn, expected) {
+  return errorValue(ColourErrorCodes.COLOUR_BAD_ARGUMENTS, `${fn}(...) expects ${expected}`);
+}
+function notAColour(fn) {
+  return errorValue(ColourErrorCodes.COLOUR_EXPECTED_COLOUR, `${fn}(...) expects a colour as its first argument`);
+}
+var COLOUR_PARSE_FN_IDX = allocatePluginFunctionIndex();
+function colourParseHandler(args) {
+  const arg = args[0];
+  if (!arg || arg.type !== 3 /* String */ || typeof arg.value !== "string") {
+    return badArgs("color", 'a string, e.g. color("#ff0000") or color("red")');
+  }
+  const parsed = parseColour(arg.value);
+  if (!parsed) {
+    return errorValue(
+      ColourErrorCodes.COLOUR_INVALID,
+      `"${arg.value}" is not a hex colour (#rgb, #rgba, #rrggbb, #rrggbbaa) or a CSS colour name`
+    );
+  }
+  return colourValue(parsed);
+}
+var COLOUR_RGB_FN_IDX = allocatePluginFunctionIndex();
+function rgbHandler(args) {
+  if (args.length !== 3) return badArgs("rgb", "three numbers: rgb(red, green, blue)");
+  return colourValue({
+    r: clamp255(args[0].toNumber()),
+    g: clamp255(args[1].toNumber()),
+    b: clamp255(args[2].toNumber()),
+    a: 1,
+    format: "rgb"
+  });
+}
+var COLOUR_RGBA_FN_IDX = allocatePluginFunctionIndex();
+function rgbaHandler(args) {
+  if (args.length !== 4) return badArgs("rgba", "four numbers: rgba(red, green, blue, alpha)");
+  return colourValue({
+    r: clamp255(args[0].toNumber()),
+    g: clamp255(args[1].toNumber()),
+    b: clamp255(args[2].toNumber()),
+    a: clamp01(readAmount(args[3])),
+    format: "rgba"
+  });
+}
+var COLOUR_HSL_FN_IDX = allocatePluginFunctionIndex();
+function hslHandler(args) {
+  if (args.length !== 3) return badArgs("hsl", "three values: hsl(hue, saturation%, lightness%)");
+  const { r, g, b } = hslToRgb(args[0].toNumber(), readAmount(args[1]), readAmount(args[2]));
+  return colourValue({ r, g, b, a: 1, format: "hsl" });
+}
+var COLOUR_HSLA_FN_IDX = allocatePluginFunctionIndex();
+function hslaHandler(args) {
+  if (args.length !== 4) return badArgs("hsla", "four values: hsla(hue, saturation%, lightness%, alpha)");
+  const { r, g, b } = hslToRgb(args[0].toNumber(), readAmount(args[1]), readAmount(args[2]));
+  return colourValue({ r, g, b, a: clamp01(readAmount(args[3])), format: "hsla" });
+}
+function adjuster(name, op) {
+  return (args) => {
+    const c = colourOf(args[0]);
+    if (!c) return notAColour(name);
+    if (args.length < 2) return badArgs(name, `a colour and an amount, e.g. ${name}(#3366cc, 20%)`);
+    return colourValue(op(c, readAmount(args[1])));
+  };
+}
+var COLOUR_LIGHTEN_FN_IDX = allocatePluginFunctionIndex();
+var lightenHandler = adjuster("lighten", lighten);
+var COLOUR_DARKEN_FN_IDX = allocatePluginFunctionIndex();
+var darkenHandler = adjuster("darken", darken);
+var COLOUR_SATURATE_FN_IDX = allocatePluginFunctionIndex();
+var saturateHandler = adjuster("saturate", saturate);
+var COLOUR_DESATURATE_FN_IDX = allocatePluginFunctionIndex();
+var desaturateHandler = adjuster("desaturate", desaturate);
+var COLOUR_ROTATE_FN_IDX = allocatePluginFunctionIndex();
+function rotateHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("rotate");
+  if (args.length < 2) return badArgs("rotate", "a colour and a hue angle in degrees, e.g. rotate(#ff0000, 90)");
+  return colourValue(rotateHue(c, args[1].toNumber()));
+}
+var COLOUR_COMPLEMENT_FN_IDX = allocatePluginFunctionIndex();
+function complementHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("complement");
+  return colourValue(complement(c));
+}
+var COLOUR_GRAYSCALE_FN_IDX = allocatePluginFunctionIndex();
+function grayscaleHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("grayscale");
+  return colourValue(grayscale(c));
+}
+var COLOUR_INVERT_FN_IDX = allocatePluginFunctionIndex();
+function invertHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("invert");
+  return colourValue(invert(c, args.length > 1 ? readAmount(args[1]) : 1));
+}
+var COLOUR_MIX_FN_IDX = allocatePluginFunctionIndex();
+function mixHandler(args) {
+  const a = colourOf(args[0]);
+  const b = colourOf(args[1]);
+  if (!a || !b) return errorValue(ColourErrorCodes.COLOUR_EXPECTED_COLOUR, "mix(...) expects two colours to blend");
+  return colourValue(mix(a, b, args.length > 2 ? readAmount(args[2]) : 0.5));
+}
+var COLOUR_ALPHA_FN_IDX = allocatePluginFunctionIndex();
+function alphaHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("alpha");
+  if (args.length < 2) return numberValue(c.a);
+  return colourValue(withAlpha(c, readAmount(args[1])));
+}
+var COLOUR_CONTRAST_FN_IDX = allocatePluginFunctionIndex();
+function contrastHandler(args) {
+  const a = colourOf(args[0]);
+  const b = colourOf(args[1]);
+  if (!a || !b) return errorValue(ColourErrorCodes.COLOUR_EXPECTED_COLOUR, "contrast(...) expects two colours");
+  return numberValue(contrastRatio(a, b));
+}
+var COLOUR_LUMINANCE_FN_IDX = allocatePluginFunctionIndex();
+function luminanceHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("luminance");
+  return numberValue(relativeLuminance(c));
+}
+function extractor(name, get) {
+  return (args) => {
+    const c = colourOf(args[0]);
+    if (!c) return notAColour(name);
+    return numberValue(get(c));
+  };
+}
+var COLOUR_RED_FN_IDX = allocatePluginFunctionIndex();
+var redHandler = extractor("red", (c) => c.r);
+var COLOUR_GREEN_FN_IDX = allocatePluginFunctionIndex();
+var greenHandler = extractor("green", (c) => c.g);
+var COLOUR_BLUE_FN_IDX = allocatePluginFunctionIndex();
+var blueHandler = extractor("blue", (c) => c.b);
+var COLOUR_HUE_FN_IDX = allocatePluginFunctionIndex();
+var hueHandler = extractor("hue", (c) => rgbToHsl(c.r, c.g, c.b).h);
+var COLOUR_SATURATION_FN_IDX = allocatePluginFunctionIndex();
+var saturationHandler = extractor("saturation", (c) => rgbToHsl(c.r, c.g, c.b).s * 100);
+var COLOUR_LIGHTNESS_FN_IDX = allocatePluginFunctionIndex();
+var lightnessHandler = extractor("lightness", (c) => rgbToHsl(c.r, c.g, c.b).l * 100);
+var COLOUR_HSV_FN_IDX = allocatePluginFunctionIndex();
+function hsvHandler(args) {
+  if (args.length !== 3) return badArgs("hsv", "three values: hsv(hue, saturation%, value%)");
+  const { r, g, b } = hsvToRgb(args[0].toNumber(), readAmount(args[1]), readAmount(args[2]));
+  return colourValue({ r, g, b, a: 1, format: "hex" });
+}
+var COLOUR_HSVA_FN_IDX = allocatePluginFunctionIndex();
+function hsvaHandler(args) {
+  if (args.length !== 4) return badArgs("hsva", "four values: hsva(hue, saturation%, value%, alpha)");
+  const { r, g, b } = hsvToRgb(args[0].toNumber(), readAmount(args[1]), readAmount(args[2]));
+  return colourValue({ r, g, b, a: clamp01(readAmount(args[3])), format: "hex" });
+}
+var COLOUR_HWB_FN_IDX = allocatePluginFunctionIndex();
+function hwbHandler(args) {
+  if (args.length !== 3) return badArgs("hwb", "three values: hwb(hue, whiteness%, blackness%)");
+  const { r, g, b } = hwbToRgb(args[0].toNumber(), readAmount(args[1]), readAmount(args[2]));
+  return colourValue({ r, g, b, a: 1, format: "hex" });
+}
+var COLOUR_TINT_FN_IDX = allocatePluginFunctionIndex();
+var tintHandler = adjuster("tint", tint);
+var COLOUR_SHADE_FN_IDX = allocatePluginFunctionIndex();
+var shadeHandler = adjuster("shade", shade);
+var COLOUR_TONE_FN_IDX = allocatePluginFunctionIndex();
+var toneHandler = adjuster("tone", tone);
+var COLOUR_ISDARK_FN_IDX = allocatePluginFunctionIndex();
+function isdarkHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("isdark");
+  return boolValue(isDark(c));
+}
+var COLOUR_ISLIGHT_FN_IDX = allocatePluginFunctionIndex();
+function islightHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("islight");
+  return boolValue(!isDark(c));
+}
+var COLOUR_READABLE_FN_IDX = allocatePluginFunctionIndex();
+function readableHandler(args) {
+  const c = colourOf(args[0]);
+  if (!c) return notAColour("readable");
+  return colourValue(readableColour(c));
+}
+function readWcagThreshold(v) {
+  if (!v) return WCAG_THRESHOLDS.aa;
+  if (v.type === 0 /* Number */) return v.toNumber();
+  if (v.type === 3 /* String */) {
+    const key = v.value.trim().toLowerCase();
+    if (key === "aaa") return WCAG_THRESHOLDS.aaa;
+    if (key === "aa large" || key === "aa-large" || key === "large") return WCAG_THRESHOLDS.aaLarge;
+    if (key === "aaa large" || key === "aaa-large") return WCAG_THRESHOLDS.aaaLarge;
+  }
+  return WCAG_THRESHOLDS.aa;
+}
+var COLOUR_CONTRAST_COMPLIANT_FN_IDX = allocatePluginFunctionIndex();
+function contrastCompliantHandler(args) {
+  const a = colourOf(args[0]);
+  const b = colourOf(args[1]);
+  if (!a || !b) {
+    return errorValue(ColourErrorCodes.COLOUR_EXPECTED_COLOUR, "iscontrastcompliant(...) expects two colours");
+  }
+  return boolValue(contrastRatio(a, b) >= readWcagThreshold(args[2]));
+}
+var COLOUR_WCAG_LEVEL_FN_IDX = allocatePluginFunctionIndex();
+function wcagLevelHandler(args) {
+  const a = colourOf(args[0]);
+  const b = colourOf(args[1]);
+  if (!a || !b) return errorValue(ColourErrorCodes.COLOUR_EXPECTED_COLOUR, "wcaglevel(...) expects two colours");
+  return stringValue(wcagLevel(a, b));
+}
+var COLOUR_FUNCTION_INDEX = {
+  color: COLOUR_PARSE_FN_IDX,
+  colour: COLOUR_PARSE_FN_IDX,
+  rgb: COLOUR_RGB_FN_IDX,
+  rgba: COLOUR_RGBA_FN_IDX,
+  hsl: COLOUR_HSL_FN_IDX,
+  hsla: COLOUR_HSLA_FN_IDX,
+  lighten: COLOUR_LIGHTEN_FN_IDX,
+  darken: COLOUR_DARKEN_FN_IDX,
+  saturate: COLOUR_SATURATE_FN_IDX,
+  desaturate: COLOUR_DESATURATE_FN_IDX,
+  desat: COLOUR_DESATURATE_FN_IDX,
+  rotate: COLOUR_ROTATE_FN_IDX,
+  spin: COLOUR_ROTATE_FN_IDX,
+  adjusthue: COLOUR_ROTATE_FN_IDX,
+  complement: COLOUR_COMPLEMENT_FN_IDX,
+  grayscale: COLOUR_GRAYSCALE_FN_IDX,
+  greyscale: COLOUR_GRAYSCALE_FN_IDX,
+  invert: COLOUR_INVERT_FN_IDX,
+  mix: COLOUR_MIX_FN_IDX,
+  alpha: COLOUR_ALPHA_FN_IDX,
+  opacity: COLOUR_ALPHA_FN_IDX,
+  fade: COLOUR_ALPHA_FN_IDX,
+  contrast: COLOUR_CONTRAST_FN_IDX,
+  luminance: COLOUR_LUMINANCE_FN_IDX,
+  red: COLOUR_RED_FN_IDX,
+  green: COLOUR_GREEN_FN_IDX,
+  blue: COLOUR_BLUE_FN_IDX,
+  hue: COLOUR_HUE_FN_IDX,
+  saturation: COLOUR_SATURATION_FN_IDX,
+  lightness: COLOUR_LIGHTNESS_FN_IDX,
+  hsv: COLOUR_HSV_FN_IDX,
+  hsb: COLOUR_HSV_FN_IDX,
+  hsva: COLOUR_HSVA_FN_IDX,
+  hwb: COLOUR_HWB_FN_IDX,
+  tint: COLOUR_TINT_FN_IDX,
+  shade: COLOUR_SHADE_FN_IDX,
+  tone: COLOUR_TONE_FN_IDX,
+  negate: COLOUR_INVERT_FN_IDX,
+  isdark: COLOUR_ISDARK_FN_IDX,
+  islight: COLOUR_ISLIGHT_FN_IDX,
+  readable: COLOUR_READABLE_FN_IDX,
+  contrastcolor: COLOUR_READABLE_FN_IDX,
+  contrastcolour: COLOUR_READABLE_FN_IDX,
+  iscontrastcompliant: COLOUR_CONTRAST_COMPLIANT_FN_IDX,
+  wcaglevel: COLOUR_WCAG_LEVEL_FN_IDX,
+  wcag: COLOUR_WCAG_LEVEL_FN_IDX
+};
+var COLOUR_PLUGIN_FUNCTIONS = [
+  { index: COLOUR_PARSE_FN_IDX, handler: colourParseHandler },
+  { index: COLOUR_RGB_FN_IDX, handler: rgbHandler },
+  { index: COLOUR_RGBA_FN_IDX, handler: rgbaHandler },
+  { index: COLOUR_HSL_FN_IDX, handler: hslHandler },
+  { index: COLOUR_HSLA_FN_IDX, handler: hslaHandler },
+  { index: COLOUR_LIGHTEN_FN_IDX, handler: lightenHandler },
+  { index: COLOUR_DARKEN_FN_IDX, handler: darkenHandler },
+  { index: COLOUR_SATURATE_FN_IDX, handler: saturateHandler },
+  { index: COLOUR_DESATURATE_FN_IDX, handler: desaturateHandler },
+  { index: COLOUR_ROTATE_FN_IDX, handler: rotateHandler },
+  { index: COLOUR_COMPLEMENT_FN_IDX, handler: complementHandler },
+  { index: COLOUR_GRAYSCALE_FN_IDX, handler: grayscaleHandler },
+  { index: COLOUR_INVERT_FN_IDX, handler: invertHandler },
+  { index: COLOUR_MIX_FN_IDX, handler: mixHandler },
+  { index: COLOUR_ALPHA_FN_IDX, handler: alphaHandler },
+  { index: COLOUR_CONTRAST_FN_IDX, handler: contrastHandler },
+  { index: COLOUR_LUMINANCE_FN_IDX, handler: luminanceHandler },
+  { index: COLOUR_RED_FN_IDX, handler: redHandler },
+  { index: COLOUR_GREEN_FN_IDX, handler: greenHandler },
+  { index: COLOUR_BLUE_FN_IDX, handler: blueHandler },
+  { index: COLOUR_HUE_FN_IDX, handler: hueHandler },
+  { index: COLOUR_SATURATION_FN_IDX, handler: saturationHandler },
+  { index: COLOUR_LIGHTNESS_FN_IDX, handler: lightnessHandler },
+  { index: COLOUR_HSV_FN_IDX, handler: hsvHandler },
+  { index: COLOUR_HSVA_FN_IDX, handler: hsvaHandler },
+  { index: COLOUR_HWB_FN_IDX, handler: hwbHandler },
+  { index: COLOUR_TINT_FN_IDX, handler: tintHandler },
+  { index: COLOUR_SHADE_FN_IDX, handler: shadeHandler },
+  { index: COLOUR_TONE_FN_IDX, handler: toneHandler },
+  { index: COLOUR_ISDARK_FN_IDX, handler: isdarkHandler },
+  { index: COLOUR_ISLIGHT_FN_IDX, handler: islightHandler },
+  { index: COLOUR_READABLE_FN_IDX, handler: readableHandler },
+  { index: COLOUR_CONTRAST_COMPLIANT_FN_IDX, handler: contrastCompliantHandler },
+  { index: COLOUR_WCAG_LEVEL_FN_IDX, handler: wcagLevelHandler }
+];
+
+// src/packages/colour/parselets/HexColourParselet.ts
+var HexColourParselet = class {
+  constructor() {
+    this.category = "Colour";
+  }
+  parse(_parser, token, builder) {
+    builder.emitOpcode(13 /* PUSH_STRING */);
+    builder.emitString(token.value);
+    builder.emitOpcode(50 /* CALL_PLUGIN */);
+    builder.emitIndex(COLOUR_PARSE_FN_IDX);
+    builder.emitIndex(1);
+  }
+};
+
+// src/packages/colour/parselets/ColourCallParselet.ts
+var ColourCallParselet = class {
+  constructor() {
+    this.category = "Colour";
+  }
+  parse(parser, token, builder) {
+    const name = token.value.toLowerCase();
+    const fnIdx = COLOUR_FUNCTION_INDEX[name];
+    if (fnIdx === void 0) {
+      throw ErrorFactory.execution("UNKNOWN_COLOUR_FUNCTION", `Unknown colour function: ${name}`, {
+        functionName: name
+      });
+    }
+    parser.consume("LPAREN");
+    let argCount = 0;
+    if (parser.peek()?.type !== "RPAREN") {
+      parser.parseExpression(BindingPower.Lowest, builder);
+      argCount++;
+      while (parser.match("COMMA")) {
+        parser.parseExpression(BindingPower.Lowest, builder);
+        argCount++;
+      }
+    }
+    parser.consume("RPAREN");
+    builder.emitOpcode(50 /* CALL_PLUGIN */);
+    builder.emitIndex(fnIdx);
+    builder.emitIndex(argCount);
+  }
+};
+
+// src/packages/colour/normalizer/ColourCallNormalizerRule.ts
+function colourCallNormalizerRule(priority = 80) {
+  return {
+    name: "colour:call",
+    priority,
+    match(tokens, pos) {
+      const token = tokens[pos];
+      if (!token || token.type !== "IDENT") return null;
+      const word = token.value.toLowerCase();
+      if (COLOUR_FUNCTION_INDEX[word] === void 0) return null;
+      if (tokens[pos + 1]?.type !== "LPAREN") return null;
+      return {
+        consumed: 1,
+        replacement: [
+          new LexerToken(
+            "COLOUR_CALL",
+            tokenTypeId("COLOUR_CALL"),
+            token.value,
+            token.value,
+            token.offset,
+            0,
+            token.line,
+            token.col
+          )
+        ],
+        ruleName: "colour:call"
+      };
+    }
+  };
+}
+
+// src/packages/colour/ColourPackage.ts
+var retag = (format) => (v) => {
+  if (v.type !== 14 /* Colour */) return v;
+  const c = v.value;
+  return colourValue({ r: c.r, g: c.g, b: c.b, a: c.a, format });
+};
+var completionItems = Object.keys(COLOUR_FUNCTION_INDEX).map((label) => ({
+  label,
+  category: "function",
+  detail: "colour"
+}));
+var COLOUR_PACKAGE = {
+  name: "solve-colour",
+  prefixParselets: [
+    { tokenType: "HEX_COLOUR", parselet: new HexColourParselet() },
+    { tokenType: "COLOUR_CALL", parselet: new ColourCallParselet() }
+  ],
+  normalizerRules: [colourCallNormalizerRule()],
+  pluginFunctions: COLOUR_PLUGIN_FUNCTIONS.map((f) => ({ index: f.index, handler: f.handler })),
+  asConverters: {
+    rgb: retag("rgb"),
+    rgba: retag("rgba"),
+    hsl: retag("hsl"),
+    hsla: retag("hsla")
+  },
+  // HEX_COLOUR/COLOUR_CALL categories live in the core TokenCategoryMap (both
+  // are declared TokenTypes), so no per-package tokenCategories are needed.
+  completionItems
+};
+
 // src/packages/builtins.ts
 var BUILTIN_PACKAGES = [
   ARITHMETIC_PACKAGE,
@@ -6503,10 +7970,16 @@ var BUILTIN_PACKAGES = [
   CONVERTERS_PACKAGE,
   MATHPHRASES_PACKAGE,
   FINANCE_PACKAGE,
+  UNCERTAINTY_PACKAGE,
   WEATHER_PACKAGE,
-  LINES_PACKAGE
+  LINES_PACKAGE,
+  // After LINES_PACKAGE: goal seek's normalizer reads a LINE_REF the lines
+  // rule mints, and its parselet targets a line reference.
+  GOALSEEK_PACKAGE,
+  TABLES_PACKAGE,
+  COLOUR_PACKAGE
 ];
 
-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-HMOISHXR.js.map
-//# sourceMappingURL=chunk-HMOISHXR.js.map
+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, TABLES_PACKAGE, TIME_PACKAGE, UOM_PACKAGE, VARIABLES_PACKAGE, VECTOR_PACKAGE, WEATHER_PACKAGE, containsSymbolicCall, createCurrencyPackage, createKnowledgePackage, createStocksPackage };
+//# sourceMappingURL=chunk-RRLHC37V.js.map
+//# sourceMappingURL=chunk-RRLHC37V.js.map