solve-engine 1.1.0 → 1.2.0

package/dist/{chunk-CKQMXMHR.cjs → chunk-AKNGX4TZ.cjs}

@@ -2,7 +2,8 @@
 
 var chunkN7FNVFXW_cjs = require('./chunk-N7FNVFXW.cjs');
 var chunkALYRJ72W_cjs = require('./chunk-ALYRJ72W.cjs');
-var chunkHIQ5HSZL_cjs = require('./chunk-HIQ5HSZL.cjs');
+var chunkA2DZ5BEJ_cjs = require('./chunk-A2DZ5BEJ.cjs');
+var chunkIT74O4BE_cjs = require('./chunk-IT74O4BE.cjs');
 var chunkOUHT5Z36_cjs = require('./chunk-OUHT5Z36.cjs');
 
 // src/format/FormattingSettings.ts
@@ -101,7 +102,7 @@ function formatMsDuration(ms) {
 function formatUom(value, unit, locale, settings, exact) {
   if (unit === "ms") return `= ${formatMsDuration(value)}`;
   const dp = settings.unitOfMeasurementResult.decimalPlaces;
-  const timeSpanUnits = ["days", "weeks", "hours", "minutes", "seconds", "day", "week", "hour", "minute", "second"];
+  const timeSpanUnits = ["days", "weeks", "months", "years", "hours", "minutes", "seconds", "day", "week", "month", "year", "hour", "minute", "second"];
   const isTimeSpan = unit && timeSpanUnits.includes(unit);
   let formatted;
   if (isTimeSpan && value === Math.floor(value)) {
@@ -109,26 +110,26 @@ function formatUom(value, unit, locale, settings, exact) {
   } else {
     formatted = value.toFixed(dp);
   }
-  const currencyDisplay = unit ? chunkHIQ5HSZL_cjs.CURRENCY_DISPLAY[unit.toUpperCase()] : void 0;
+  const currencyDisplay = unit ? chunkA2DZ5BEJ_cjs.CURRENCY_DISPLAY[unit.toUpperCase()] : void 0;
   if (currencyDisplay) {
-    const moneyText = exact ? chunkHIQ5HSZL_cjs.decimalToFixed(exact, dp) : formatted;
+    const moneyText = exact ? chunkA2DZ5BEJ_cjs.decimalToFixed(exact, dp) : formatted;
     const sep = currencyDisplay.spaced ? " " : "";
     const withSymbol = currencyDisplay.position === "prefix" ? `${currencyDisplay.symbol}${sep}${moneyText}` : `${moneyText}${sep}${currencyDisplay.symbol}`;
     return `= ${withSymbol}`;
   }
-  const genericText = exact ? chunkHIQ5HSZL_cjs.decimalToFixed(exact, dp) : formatted;
+  const genericText = exact ? chunkA2DZ5BEJ_cjs.decimalToFixed(exact, dp) : formatted;
   return `= ${genericText} ${unit || ""}`.trim();
 }
 function formatMatrixEntry(entry, settings) {
   if (typeof entry === "boolean") return entry ? "true" : "false";
-  if (typeof entry === "object" && entry !== null) return chunkHIQ5HSZL_cjs.formatSymbolic(entry);
+  if (typeof entry === "object" && entry !== null) return chunkA2DZ5BEJ_cjs.formatSymbolic(entry);
   const dp = settings.floatResult.decimalPlaces;
   const sep = settings.floatResult.enableSeperator;
   const loc = settings.numberResult.decimalSeparatorLocale;
   return chunkN7FNVFXW_cjs.autoFormatIntegerOrFloat(entry, dp, sep, loc);
 }
 function formatMatrix(m, locale, settings) {
-  const rowMajor = chunkHIQ5HSZL_cjs.columnMajorToRowMajor(m);
+  const rowMajor = chunkA2DZ5BEJ_cjs.columnMajorToRowMajor(m);
   const rows = [];
   for (let r = 0; r < m.rows; r++) {
     const cells = [];
@@ -141,7 +142,7 @@ function formatMatrix(m, locale, settings) {
 }
 function formatMatrixAligned(m, settings) {
   const us = settings || DEFAULT_FORMATTING_SETTINGS;
-  const rowMajor = chunkHIQ5HSZL_cjs.columnMajorToRowMajor(m);
+  const rowMajor = chunkA2DZ5BEJ_cjs.columnMajorToRowMajor(m);
   const cells = [];
   for (let r = 0; r < m.rows; r++) {
     const row = [];
@@ -169,6 +170,20 @@ function formatPercentage(value, locale, settings) {
 function formatUnit(value, unit) {
   return `= ${value} ${unit || ""}`.trim();
 }
+function formatSplit(data, locale, settings) {
+  const prefix = locale.display.resultPrefix;
+  const render = (share) => {
+    const v = data.unit !== void 0 ? new chunkIT74O4BE_cjs.Value(6 /* Uom */, share.value, data.unit) : new chunkIT74O4BE_cjs.Value(0 /* Number */, share.value);
+    v.exact = share.exact;
+    const text = formatValue(v, settings);
+    return text.startsWith(prefix) ? text.slice(prefix.length) : text;
+  };
+  const [base, high] = data.shares;
+  const each = `${render(base)} each`;
+  if (high === void 0) return `${prefix}${each}`;
+  const shareWord = high.count === 1 ? "share" : "shares";
+  return `${prefix}${each}, with ${high.count} ${shareWord} paying ${render(high)}`;
+}
 function formatValue(value, settings) {
   const us = settings || DEFAULT_FORMATTING_SETTINGS;
   const localeCode = us.numberResult.decimalSeparatorLocale || "en";
@@ -199,8 +214,10 @@ function formatValue(value, settings) {
     }
     case 14 /* Colour */:
       return `${locale.display.resultPrefix}${chunkALYRJ72W_cjs.formatColour(value.value)}`;
+    case 15 /* Split */:
+      return formatSplit(value.value, locale, us);
     case 9 /* Symbolic */:
-      return chunkHIQ5HSZL_cjs.formatSymbolic(value.value);
+      return chunkA2DZ5BEJ_cjs.formatSymbolic(value.value);
     case 5 /* Percentage */:
       return formatPercentage(value.value, locale, us);
     case 11 /* Unit */:
@@ -215,5 +232,5 @@ function formatValue(value, settings) {
 exports.DEFAULT_FORMATTING_SETTINGS = DEFAULT_FORMATTING_SETTINGS;
 exports.formatMatrixAligned = formatMatrixAligned;
 exports.formatValue = formatValue;
-//# sourceMappingURL=chunk-CKQMXMHR.cjs.map
-//# sourceMappingURL=chunk-CKQMXMHR.cjs.map
+//# sourceMappingURL=chunk-AKNGX4TZ.cjs.map
+//# sourceMappingURL=chunk-AKNGX4TZ.cjs.map

package/dist/chunk-AKNGX4TZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format/FormattingSettings.ts","../src/format/FormatEngine.ts"],"names":["formatted","autoFormatIntegerOrFloat","CURRENCY_DISPLAY","decimalToFixed","formatSymbolic","columnMajorToRowMajor","Value","getLocale","formatColour"],"mappings":"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","file":"chunk-AKNGX4TZ.cjs","sourcesContent":["/**\n * Minimal formatting settings interface for the engine\n * This allows the engine to format values without depending on app-specific settings\n */\nexport interface FormattingSettings {\n  floatResult: {\n    decimalPlaces: number;\n    enableSeperator: boolean;\n  };\n  numberResult: {\n    decimalSeparatorLocale: string;\n  };\n  hexResult: {\n    enablePadding: boolean;\n    paddingZeros: number;\n  };\n  unitOfMeasurementResult: {\n    decimalPlaces: number;\n  };\n  percentageResult: {\n    decimalPlaces: number;\n  };\n}\n\n/** Formatting used when a host supplies none. */\nexport const DEFAULT_FORMATTING_SETTINGS: FormattingSettings = {\n  floatResult: {\n    decimalPlaces: 2,\n    enableSeperator: true,\n  },\n  numberResult: {\n    decimalSeparatorLocale: \"en-US\",\n  },\n  hexResult: {\n    enablePadding: false,\n    paddingZeros: 0,\n  },\n  unitOfMeasurementResult: {\n    decimalPlaces: 2,\n  },\n  percentageResult: {\n    decimalPlaces: 2,\n  },\n};\n","import { Value, ValueType, type MatrixData, type MatrixEntry, type RangeData, type ColourData, type SplitData, type SplitShare } from \"@solve-js/vm/Value\";\nimport { formatColour } from \"@solve-js/packages/colour/ColourMath\";\nimport { decimalToFixed, type DecimalData } from \"@solve-js/decimal\";\nimport { getLocale, type ILocale } from \"@solve-js/constants/locales\";\nimport { autoFormatIntegerOrFloat } from \"@solve-js/utilities/Number\";\nimport { FormattingSettings, DEFAULT_FORMATTING_SETTINGS } from \"./FormattingSettings\";\nimport { CURRENCY_DISPLAY } from \"@solve-js/uom/CurrencyAliases\";\nimport { columnMajorToRowMajor } from \"@solve-js/vm/MatrixOps\";\nimport { formatSymbolic, type SymbolicNode } from \"@solve-js/symbolic\";\n\nfunction formatNumber(value: number, locale: ILocale, settings: FormattingSettings, decimalPlaces?: number): string {\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  // An explicit precision (`3.14159 to 4 dp`, `round(1.5, 2)`) shows EXACTLY that\n  // many places with trailing zeros kept, where the default trims them and shows\n  // an integer with none. The value was already rounded to this precision when\n  // it was set (see VMBuiltins' roundToPlaces, exact where an exact decimal was\n  // there), so rendering it to the same place count reproduces that rounding.\n  if (decimalPlaces !== undefined && Number.isFinite(value)) {\n    const formatted = value.toLocaleString(loc || \"en-US\", {\n      minimumFractionDigits: decimalPlaces,\n      maximumFractionDigits: decimalPlaces,\n      useGrouping: sep,\n    });\n    return `${locale.display.resultPrefix}${formatted}`;\n  }\n  const dp = settings.floatResult.decimalPlaces;\n  const formatted = autoFormatIntegerOrFloat(value, dp, sep, loc);\n  return `${locale.display.resultPrefix}${formatted}`;\n}\n\n/**\n * Renders a measurement that carries a one-sigma uncertainty as\n * `center ± spread`, e.g. `49.2 ± 2.0`.\n *\n * The center is shown the way any number is, whole numbers as integers and\n * trailing zeros trimmed, so a tolerance-free-looking center still reads\n * cleanly (\"30 ± 2.24\", not \"30.00 ± 2.24\"). The spread is shown to the same\n * decimal-place budget but always keeps at least one fractional digit, which is\n * what distinguishes it as a tolerance and gives \"± 2.0\" rather than \"± 2\".\n * Both use `Intl` with `maximumFractionDigits`, so the trailing-zero trimming is\n * locale-correct (a comma-decimal locale is not string-sliced on \".\").\n *\n * The symbol is always the `±` glyph on output, even when the input was the\n * ASCII `+/-`, since the glyph is the conventional notation and unambiguous to\n * read back.\n */\nfunction formatUncertain(center: number, uncertainty: number, locale: ILocale, settings: FormattingSettings): string {\n  const dp = settings.floatResult.decimalPlaces;\n  const useGrouping = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale || \"en-US\";\n  // The spread needs room for at least one fractional digit, so a zero-decimal\n  // budget cannot leave minimumFractionDigits above maximumFractionDigits.\n  const spreadMax = Math.max(dp, 1);\n  const centerText = center.toLocaleString(loc, { useGrouping, minimumFractionDigits: 0, maximumFractionDigits: dp });\n  const spreadText = Math.abs(uncertainty).toLocaleString(loc, { useGrouping, minimumFractionDigits: 1, maximumFractionDigits: spreadMax });\n  return `${locale.display.resultPrefix}${centerText} ± ${spreadText}`;\n}\n\n/**\n * Renders a number in whichever base it is tagged with.\n *\n * The zero padding is a hexadecimal setting and stays one. Applying it to a\n * binary rendering would pad `0b101` out to the same digit count as a hex\n * value, which is a different quantity of zeros and not what the setting asks\n * for.\n */\nfunction formatHex(value: number | bigint, settings: FormattingSettings, base?: string): string {\n  // An infinity or a NaN has no digits in any base, and asking for them\n  // produced `0xINFINITY`, a literal that reads back as nothing at all. Render\n  // the value itself, which is what every other non-finite result shows.\n  if (typeof value === \"number\" && !Number.isFinite(value)) return `= ${value}`;\n\n  // Truncate and take the sign off before converting. `Number.toString(radix)`\n  // does neither: it renders -255 as \"-ff\", which lands the minus inside the\n  // literal as `0x-FF`, and it renders 255.7 as \"ff.b3333333333\", inventing\n  // fractional hex digits for a notation that has no use for them. Both were\n  // visible on `as hex` until the builtins started sharing this path.\n  //\n  // A bigint needs neither truncation nor a Math call, and must not be routed\n  // through one: passing it to Math.trunc() throws, and converting it to a\n  // double first is exactly the precision loss it is carried as a bigint to\n  // avoid.\n  const negative = typeof value === \"bigint\" ? value < 0n : value < 0;\n  const sign = negative ? \"-\" : \"\";\n  const digits = (radix: number): string =>\n    typeof value === \"bigint\"\n      ? (negative ? -value : value).toString(radix)\n      : Math.abs(Math.trunc(value)).toString(radix);\n\n  if (base === \"bin\") return `= ${sign}0b${digits(2)}`;\n  if (base === \"oct\") return `= ${sign}0o${digits(8)}`;\n  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;\n  const hex = digits(16).toUpperCase().padStart(padding, \"0\");\n  return `= ${sign}0x${hex}`;\n}\n\n/**\n * How many decimal digits of an exact integer this will render in full.\n *\n * A little above the ~19,729 digits of the largest bigint the VM will build\n * (`vm/VM.ts`'s MAX_EXACT_POW_BITS / MAX_EXACT_SHIFT_BITS, 65,536 bits), so\n * every value the engine can produce through `^` or `<<` still prints exactly\n * and this ceiling only ever meets a value that came from somewhere else.\n */\nconst MAX_DISPLAYED_BIGINT_DIGITS = 20000;\n\n/**\n * Renders an exact integer, or describes it when writing it out is itself the\n * expensive operation.\n *\n * This used to be a bare `= ${value}` template, which renders whatever it is\n * handed: `1n << 100000000` took 8.5 seconds here turning a 12.5MB integer\n * into a thirty-million-character string, and a host has no way to opt out,\n * since displaying the answer is what it asked the engine for. The VM's own\n * ceiling on `<<` and `^` now stops that value existing, so this is the\n * backstop for every other way a large bigint can arrive (repeated `x * x`,\n * a Value a host built itself), and it costs one comparison for every value\n * that is not absurd.\n *\n * The digit count is estimated from the bit length rather than measured, since\n * measuring means doing the conversion this exists to avoid. Bit length comes\n * off the hexadecimal form, which is linear in the size of the value where the\n * decimal form is not.\n */\nfunction formatBigInt(value: bigint): string {\n  const magnitude = value < 0n ? -value : value;\n  // Every bigint a person actually reads takes this line and nothing else:\n  // anything a double can hold is at most 309 digits, so it is printable\n  // without measuring it at all.\n  if (Number.isFinite(Number(magnitude))) return `= ${value}`;\n  const bits = magnitude.toString(16).length * 4;\n  if (bits * Math.LN2 / Math.LN10 <= MAX_DISPLAYED_BIGINT_DIGITS) return `= ${value}`;\n  const log10 = bits * Math.LN2 / Math.LN10;\n  const exponent = Math.floor(log10);\n  const mantissa = Math.pow(10, log10 - exponent);\n  const sign = value < 0n ? \"-\" : \"\";\n  return `= ${sign}~${mantissa.toFixed(3)}e+${exponent} (an exact integer of about ${(exponent + 1).toLocaleString(\"en-US\")} digits, too large to print)`;\n}\n\nfunction formatString(value: string): string {\n  return `= ${value}`;\n}\n\nfunction formatBoolean(value: boolean): string {\n  return `= ${value}`;\n}\n\n/**\n * Renders a Datetime value locale-aware, the previous implementation\n * called `d.toLocaleString()` with no arguments, which always uses the JS\n * runtime's own default locale and never actually consulted `locale.code`\n * despite receiving it as a parameter (both branches of its old\n * `dateFormat === \"default\"` check were byte-for-byte identical, dead\n * groundwork for a distinction that was never implemented). Concretely,\n * this meant every configured locale (including the shipped German one)\n * always displayed weekday/month names in English. See GitHub issue #77.\n *\n * Uses `weekday`/`month`: \"long\" for a spelled-out date (\"Monday,\n * November 17, 2025\" / \"lundi 17 novembre 2025\") since that's what a\n * literal weekday name is for; a bare numeric date doesn't need\n * localizing beyond the decimal/thousands separators `formatNumber()`\n * already handles. The time-of-day portion is only appended when it's\n * not exactly local midnight, bare date literals (\"today\", \"17/11/2025\")\n * always anchor to local midnight, and showing \"00:00:00\" on every one of\n * those would be noise, not information.\n */\nfunction formatDatetime(value: number, locale: ILocale): string {\n  const d = new Date(value);\n  const dateStr = d.toLocaleDateString(locale.code, { weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\" });\n  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;\n  if (isMidnight) return `= ${dateStr}`;\n  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;\n}\n\n/**\n * Renders a millisecond duration as clock-style `H:MM` (or `H:MM:SS` when\n * there's a non-zero seconds component). `ms` is never a user-typeable\n * unit (confirmed: it appears nowhere in `lexer/units.ts`), it's only\n * ever produced by subtracting two clock times/datetimes (`9:30 - 8:30`,\n * `VM.ts`'s Datetime SUB case), so this is a safe, narrow special case,\n * not a general change to how durations display.\n */\nfunction formatMsDuration(ms: number): string {\n  const sign = ms < 0 ? \"-\" : \"\";\n  const totalSeconds = Math.round(Math.abs(ms) / 1000);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const seconds = totalSeconds % 60;\n  const mm = String(minutes).padStart(2, \"0\");\n  if (seconds === 0) return `${sign}${hours}:${mm}`;\n  const ss = String(seconds).padStart(2, \"0\");\n  return `${sign}${hours}:${mm}:${ss}`;\n}\n\nfunction formatUom(value: number, unit: string | undefined, locale: ILocale, settings: FormattingSettings, exact?: DecimalData): string {\n  if (unit === \"ms\") return `= ${formatMsDuration(value)}`;\n\n  const dp = settings.unitOfMeasurementResult.decimalPlaces;\n\n  // For TimeSpan values (days, weeks, hours, etc.), format as integer if the value is a whole number\n  const timeSpanUnits = [\"days\", \"weeks\", \"months\", \"years\", \"hours\", \"minutes\", \"seconds\", \"day\", \"week\", \"month\", \"year\", \"hour\", \"minute\", \"second\"];\n  const isTimeSpan = unit && timeSpanUnits.includes(unit);\n\n  let formatted: string;\n  if (isTimeSpan && value === Math.floor(value)) {\n    // For whole number TimeSpan values, format as integer\n    formatted = value.toString();\n  } else {\n    // For other values, use the configured decimal places\n    formatted = value.toFixed(dp);\n  }\n\n  // Currency display: symbol + culturally-conventional placement (e.g.\n  // \"$100.00\" prefix vs \"100.00 kr\" suffix) instead of the generic\n  // \"amount CODE\" fallback below. See uom/CurrencyAliases.ts's\n  // CURRENCY_DISPLAY table for the exact set covered and the reasoning\n  // behind each placement choice. Any currency code NOT in that table\n  // (most of the ~150 `CurrencyExchange.isCurrency()` recognizes) falls\n  // through to the unchanged \"amount CODE\" format below.\n  const currencyDisplay = unit ? CURRENCY_DISPLAY[unit.toUpperCase()] : undefined;\n  if (currencyDisplay) {\n    // An exact money amount rounds from its decimal, not from the double: a\n    // half-cent like \"$1.005\" reads as \"$1.01\" here, where \"(1.005).toFixed(2)\"\n    // answers \"1.00\" because the double it is handed already sits below the\n    // value the user typed. Amounts with no exact decimal (a currency\n    // conversion, whose rate is a double) keep the toFixed rendering above.\n    const moneyText = exact ? decimalToFixed(exact, dp) : formatted;\n    const sep = currencyDisplay.spaced ? \" \" : \"\";\n    const withSymbol = currencyDisplay.position === \"prefix\"\n      ? `${currencyDisplay.symbol}${sep}${moneyText}`\n      : `${moneyText}${sep}${currencyDisplay.symbol}`;\n    return `= ${withSymbol}`;\n  }\n\n  // The unit is written as the symbol the value carries. There used to be a\n  // `unitOfMeasurementResult.unitNames` setting here whose two branches were\n  // the same expression, so it never changed anything, and it was removed\n  // rather than implemented: the engine has no unit-name data to render from.\n  // The generated unit table maps a spelling to [measure, ratio] only, and\n  // names cannot be recovered from it, because units that differ by an OFFSET\n  // share a ratio, so \"20 C\" would come back as \"20 kelvins\". A real\n  // implementation needs a hand-authored name per unit plus pluralization and\n  // per-locale spelling (metre against meter), which is a feature rather than\n  // the repair of a dead ternary.\n  //\n  // An exact currency with no symbol in the display table above (one of the\n  // less common ISO codes) still rounds from its decimal here, so \"1.005 UYW\"\n  // reads the same way \"$1.005\" does. Non-currency Uoms never carry an exact,\n  // so this leaves \"1.50 kg\" exactly as it was.\n  const genericText = exact ? decimalToFixed(exact, dp) : formatted;\n  return `= ${genericText} ${unit || \"\"}`.trim();\n}\n\nfunction formatMatrixEntry(entry: MatrixEntry, settings: FormattingSettings): string {\n  if (typeof entry === \"boolean\") return entry ? \"true\" : \"false\";\n  if (typeof entry === \"object\" && entry !== null) return formatSymbolic(entry);\n  const dp = settings.floatResult.decimalPlaces;\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  return autoFormatIntegerOrFloat(entry, dp, sep, loc);\n}\n\n/**\n * Renders a Matrix matching its own literal syntax: a single row (1xN,\n * including plain vectors) as `[a, b, c]`, a single column (Nx1) as\n * `[a; b; c]`, and a general shape as `[r0c0, r0c1; r1c0, r1c1]`, row-major\n * textual output read back out of the column-major storage\n * (`columnMajorToRowMajor()`), matching how `[1,2;3,4]` is written.\n */\nfunction formatMatrix(m: MatrixData, locale: ILocale, settings: FormattingSettings): string {\n  const rowMajor = columnMajorToRowMajor(m);\n  const rows: string[] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const cells: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));\n    }\n    rows.push(cells.join(\", \"));\n  }\n  return `${locale.display.resultPrefix}[${rows.join(\"; \")}]`;\n}\n\n/**\n * Render a matrix as a multi-line, column-aligned block: one row per line (the\n * newline is where {@link formatValue}'s compact form writes `;`), each column\n * right-padded to its widest cell, and every row wrapped in `[ ... ]`. For\n * display where a grid reads better than a line, e.g. a docs notepad or a REPL:\n *\n * ```text\n * [  1   2 ]\n * [ 30   4 ]\n * ```\n *\n * This is deliberately separate from {@link formatValue}, whose single-line\n * matrix form stays the stable, assertable text the API and the worker DTO use.\n * A 1xN row vector is one line; an Nx1 column vector is N lines.\n */\nexport function formatMatrixAligned(m: MatrixData, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const rowMajor = columnMajorToRowMajor(m);\n  const cells: string[][] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const row: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      row.push(formatMatrixEntry(rowMajor[r * m.cols + c], us));\n    }\n    cells.push(row);\n  }\n  const colWidth: number[] = [];\n  for (let c = 0; c < m.cols; c++) {\n    let width = 0;\n    for (let r = 0; r < m.rows; r++) width = Math.max(width, cells[r][c].length);\n    colWidth.push(width);\n  }\n  return cells\n    .map((row) => `[ ${row.map((cell, c) => cell.padStart(colWidth[c])).join(\"  \")} ]`)\n    .join(\"\\n\");\n}\n\nfunction formatRange(min: number, max: number, locale: ILocale): string {\n  return `${locale.display.resultPrefix}${min}:${max}`;\n}\n\nfunction formatPercentage(value: number, locale: ILocale, settings: FormattingSettings): string {\n  // ValueType.Percentage stores a fraction (0.25 for 25%). See Value.ts's\n  // documented contract and the sole producer, VM.ts's TO_PERCENTAGE opcode\n  // (`right/left - 1`, e.g. 0.25 for \"800 to 1000\"). Multiply by 100 before\n  // formatting; without this every percentage-change result displayed as\n  // e.g. \"0.25%\" instead of \"25.00%\".\n  const dp = settings.percentageResult.decimalPlaces;\n  const formatted = (value * 100).toFixed(dp);\n  return `= ${formatted}${locale.display.percentageSuffix}`;\n}\n\nfunction formatUnit(value: number, unit: string | undefined): string {\n  return `= ${value} ${unit || \"\"}`.trim();\n}\n\n/**\n * Renders a per-person bill split: \"= $45.00 each\", or, when the division is\n * uneven, \"= $33.33 each, with 1 share paying $33.34\". Each share's amount is\n * rendered through the ordinary value formatter (a throwaway {@link Value}), so\n * a currency share honours the same symbol placement, decimal places and locale\n * as any other money and a bare share trims trailing zeros the way a plain\n * number does; the \"= \" prefix is added once, around the whole sentence, not\n * per share.\n */\nfunction formatSplit(data: SplitData, locale: ILocale, settings: FormattingSettings): string {\n  const prefix = locale.display.resultPrefix;\n  const render = (share: SplitShare): string => {\n    const v = data.unit !== undefined\n      ? new Value(ValueType.Uom, share.value, data.unit)\n      : new Value(ValueType.Number, share.value);\n    v.exact = share.exact;\n    const text = formatValue(v, settings);\n    return text.startsWith(prefix) ? text.slice(prefix.length) : text;\n  };\n\n  const [base, high] = data.shares;\n  const each = `${render(base)} each`;\n  if (high === undefined) return `${prefix}${each}`;\n  const shareWord = high.count === 1 ? \"share\" : \"shares\";\n  return `${prefix}${each}, with ${high.count} ${shareWord} paying ${render(high)}`;\n}\n\n/**\n * Render an evaluated {@link Value} as a display string, dispatching on\n * `value.type` to the type-specific formatter (number, hex, datetime, unit\n * of measurement, matrix, range, percentage, ...).\n *\n * Most branches produce a `\"= \"`-prefixed result string (matching the\n * plugin's inline-result convention); `ValueType.Error` is the one\n * exception, it returns the human-readable error message directly\n * (stored in `value.unit`), not an `\"= \"`-prefixed string.\n *\n * @param value - The evaluated value to format.\n * @param settings - Locale/precision/separator options; defaults to\n *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.\n * @example\n * ```typescript\n * const [value] = engine.evaluateExpression(\"10 USD to GBP\");\n * formatValue(value); // \"= £7.85\" (exact output depends on live exchange rates)\n * ```\n */\nexport function formatValue(value: Value, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const localeCode = us.numberResult.decimalSeparatorLocale || \"en\";\n  const locale = getLocale(localeCode);\n\n  switch (value.type) {\n    case ValueType.Number:\n      // A measurement with a tolerance renders as \"center ± spread\"; every\n      // other number is unchanged, so a plain value is byte-for-byte what it was.\n      if (value.uncertainty !== undefined) {\n        return formatUncertain(value.value as number, value.uncertainty, locale, us);\n      }\n      return formatNumber(value.value as number, locale, us, value.decimalPlaces);\n    case ValueType.Hex:\n      return formatHex(value.value as number | bigint, us, value.unit);\n    case ValueType.BigInt:\n      return formatBigInt(value.value as bigint);\n    case ValueType.String:\n      return formatString(value.value as string);\n    case ValueType.Boolean:\n      return formatBoolean(value.value as boolean);\n    case ValueType.Datetime:\n      return formatDatetime(value.value as number, locale);\n    case ValueType.Uom:\n      return formatUom(value.value as number, value.unit, locale, us, value.exact);\n    case ValueType.Matrix:\n      return formatMatrix(value.value as MatrixData, locale, us);\n    case ValueType.Range: {\n      const r = value.value as RangeData;\n      return formatRange(r.min, r.max, locale);\n    }\n    case ValueType.Colour:\n      return `${locale.display.resultPrefix}${formatColour(value.value as ColourData)}`;\n    case ValueType.Split:\n      return formatSplit(value.value as SplitData, locale, us);\n    case ValueType.Symbolic:\n      return formatSymbolic(value.value as SymbolicNode);\n    case ValueType.Percentage:\n      return formatPercentage(value.value as number, locale, us);\n    case ValueType.Unit:\n      return formatUnit(value.value as number, value.unit);\n    case ValueType.Error:\n      // errorValue(code, message) stores the human-readable message in\n      // `.unit` (code goes in `.value`), falling through to the default\n      // case here previously displayed the raw code (e.g.\n      // \"CURRENCY_RATE_UNAVAILABLE\") instead of the actual message.\n      return value.unit ?? String(value.value);\n    default:\n      return `= ${String(value.value)}`;\n  }\n}\n"]}

package/dist/{chunk-I4GAWIPW.js → chunk-AOH6UR2L.js}

@@ -1,8 +1,8 @@
-import { DiagnosticEventType } from './chunk-CCBZZQAE.js';
-import { buildBindingPowerTable, BindingPower, bigIntLiteralDigits, BytecodeBuilder } from './chunk-ENKKJYD3.js';
-import { tokenTypeId, TokenTypes } from './chunk-4D6NIHE2.js';
+import { DiagnosticEventType } from './chunk-UF6JG5SG.js';
+import { buildBindingPowerTable, BindingPower, bigIntLiteralDigits, BytecodeBuilder } from './chunk-IQJGDZOP.js';
+import { tokenTypeId, TokenTypes } from './chunk-NAWZATKT.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
-import { ErrorFactory } from './chunk-ERCOHGXD.js';
+import { ErrorFactory } from './chunk-N7OA4WPJ.js';
 
 // src/parser/registry/ParseletRegistry.ts
 function bindingPowersOf(parselet) {
@@ -821,5 +821,5 @@ _PrecedenceParser.CARET_SUFFIX_RULES = [
 var PrecedenceParser = _PrecedenceParser;
 
 export { ParseletRegistry, PrecedenceParser, sharedParseletRegistry };
-//# sourceMappingURL=chunk-I4GAWIPW.js.map
-//# sourceMappingURL=chunk-I4GAWIPW.js.map
+//# sourceMappingURL=chunk-AOH6UR2L.js.map
+//# sourceMappingURL=chunk-AOH6UR2L.js.map

package/dist/{chunk-I4GAWIPW.js.map → chunk-AOH6UR2L.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/parser/registry/ParseletRegistry.ts","../src/parser/PrecedenceParser.ts"],"names":[],"mappings":";;;;;;;AAyBA,SAAS,gBAAgB,QAAA,EAAiE;AACzF,EAAA,OAAO,QAAA;AACR;AAcO,IAAM,mBAAN,MAAuB;AAAA,EAAvB,WAAA,GAAA;AAEN;AAAA,IAAA,IAAA,CAAQ,eAAA,uBAAmD,GAAA,EAAI;AAC/D,IAAA,IAAA,CAAQ,cAAA,uBAAiD,GAAA,EAAI;AAG7D;AAAA,IAAA,IAAA,CAAQ,UAAA,uBAA8C,GAAA,EAAI;AAC1D,IAAA,IAAA,CAAQ,SAAA,uBAA4C,GAAA,EAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwBxD,cAAA,CAAe,WAAmB,QAAA,EAAgC;AACjE,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,eAAA,CAAgB,GAAA,CAAI,SAAS,CAAA;AACnD,IAAA,IAAI,QAAA,IAAY,aAAa,QAAA,EAAU;AACtC,MAAA,OAAA,CAAQ,IAAA;AAAA,QACP,CAAA,8CAAA,EAAiD,SAAS,CAAA,oCAAA,EAC3C,QAAA,CAAS,YAAY,SAAS,CAAA,gDAAA,EACrB,QAAA,CAAS,QAAA,IAAY,SAAS,CAAA,qGAAA;AAAA,OAEvD;AAAA,IACD;AACA,IAAA,IAAA,CAAK,eAAA,CAAgB,GAAA,CAAI,SAAA,EAAW,QAAQ,CAAA;AAC5C,IAAA,IAAA,CAAK,UAAA,CAAW,GAAA,CAAI,WAAA,CAAY,SAAS,GAAG,QAAQ,CAAA;AAAA,EACrD;AAAA;AAAA,EAGA,aAAA,CAAc,WAAmB,QAAA,EAA+B;AAC/D,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,SAAS,CAAA;AAClD,IAAA,IAAI,QAAA,IAAY,aAAa,QAAA,EAAU;AACtC,MAAA,OAAA,CAAQ,IAAA;AAAA,QACP,CAAA,6CAAA,EAAgD,SAAS,CAAA,oCAAA,EAC1C,QAAA,CAAS,YAAY,SAAS,CAAA,gDAAA,EACrB,QAAA,CAAS,QAAA,IAAY,SAAS,CAAA,qGAAA;AAAA,OAEvD;AAAA,IACD;AACA,IAAA,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,SAAA,EAAW,QAAQ,CAAA;AAC3C,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,WAAA,CAAY,SAAS,GAAG,QAAQ,CAAA;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,YAAA,GAAsF;AACrF,IAAA,MAAM,SAAgF,EAAC;AACvF,IAAA,KAAA,MAAW,CAAC,SAAA,EAAW,QAAQ,CAAA,IAAK,KAAK,eAAA,EAAiB;AACzD,MAAA,MAAA,CAAO,IAAA,CAAK;AAAA,QACX,SAAA;AAAA,QACA,YAAA,EAAc,eAAA,CAAgB,QAAQ,CAAA,CAAE,gBAAgB,YAAA,CAAa,MAAA;AAAA,QACrE,UAAU,QAAA,CAAS;AAAA,OACnB,CAAA;AAAA,IACF;AACA,IAAA,OAAO,MAAA;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,WAAA,GAAoH;AACnH,IAAA,MAAM,SAA+G,EAAC;AACtH,IAAA,KAAA,MAAW,CAAC,SAAA,EAAW,QAAQ,CAAA,IAAK,KAAK,cAAA,EAAgB;AACxD,MAAA,MAAM,IAAA,GAAO,eAAA,CAAgB,QAAQ,CAAA,CAAE,YAAA,IAAgB,CAAA;AACvD,MAAA,MAAA,CAAO,IAAA,CAAK;AAAA,QACX,SAAA;AAAA,QACA,gBAAA,EAAkB,IAAA;AAAA,QAClB,mBAAmB,IAAA,GAAO,CAAA;AAAA,QAC1B,UAAU,QAAA,CAAS;AAAA,OACnB,CAAA;AAAA,IACF;AACA,IAAA,OAAO,MAAA;AAAA,EACR;AAAA;AAAA,EAGA,IAAI,WAAA,GAAsB;AAAE,IAAA,OAAO,KAAK,eAAA,CAAgB,IAAA;AAAA,EAAM;AAAA;AAAA,EAG9D,IAAI,UAAA,GAAqB;AAAE,IAAA,OAAO,KAAK,cAAA,CAAe,IAAA;AAAA,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO5D,UAAU,SAAA,EAAwD;AACjE,IAAA,IAAI,OAAO,SAAA,KAAc,QAAA,SAAiB,IAAA,CAAK,UAAA,CAAW,IAAI,SAAS,CAAA;AACvE,IAAA,OAAO,IAAA,CAAK,eAAA,CAAgB,GAAA,CAAI,SAAS,CAAA;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,SAAA,EAAuD;AAC/D,IAAA,IAAI,OAAO,SAAA,KAAc,QAAA,SAAiB,IAAA,CAAK,SAAA,CAAU,IAAI,SAAS,CAAA;AACtE,IAAA,OAAO,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,SAAS,CAAA;AAAA,EACzC;AAAA,EAEA,UAAU,SAAA,EAA4B;AACrC,IAAA,OAAO,IAAA,CAAK,eAAA,CAAgB,GAAA,CAAI,SAAS,CAAA;AAAA,EAC1C;AAAA,EAEA,SAAS,SAAA,EAA4B;AACpC,IAAA,OAAO,IAAA,CAAK,cAAA,CAAe,GAAA,CAAI,SAAS,CAAA;AAAA,EACzC;AAAA,EAEA,KAAA,GAAc;AACb,IAAA,IAAA,CAAK,gBAAgB,KAAA,EAAM;AAC3B,IAAA,IAAA,CAAK,eAAe,KAAA,EAAM;AAC1B,IAAA,IAAA,CAAK,WAAW,KAAA,EAAM;AACtB,IAAA,IAAA,CAAK,UAAU,KAAA,EAAM;AAAA,EACtB;AACD;AASO,IAAM,sBAAA,GAAyB,IAAI,gBAAA;;;AC7L1C,IAAM,4BAAA,GAA+B,wBAAA;AAUrC,IAAM,aAAA,GAAgB,YAAA;AAqBf,IAAM,iBAAA,GAAN,MAAM,iBAAA,CAAiB;AAAA,EA+E5B,WAAA,CAAY,gBAAA,EAAoC,QAAA,GAAW,EAAA,EAAI,aAAa,IAAA,EAAM;AA9ElF,IAAA,IAAA,CAAQ,SAAkB,EAAC;AAC3B,IAAA,IAAA,CAAQ,OAAA,GAAU,CAAA;AAClB,IAAA,IAAA,CAAQ,KAAA,GAAQ,CAAA;AAWhB,IAAA,IAAA,CAAQ,iBAAA,GAA4B,EAAA;AAWpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,IAAA,CAAA,oBAAA,GAAuB,CAAA;AAuDrB,IAAA,IAAA,CAAK,QAAA,GAAW,gBAAA;AAChB,IAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAChB,IAAA,IAAA,CAAK,UAAA,GAAa,UAAA;AAAA,EACpB;AAAA;AAAA,EAGA,aAAA,GAAwB;AACtB,IAAA,OAAO,IAAA,CAAK,UAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,qBAAA,CAAsB,UAA0C,UAAA,EAA0B;AACxF,IAAA,IAAA,CAAK,kBAAA,GAAqB,QAAA;AAC1B,IAAA,IAAA,CAAK,oBAAoB,UAAA,IAAc,EAAA;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAA,CAAK,QAAiB,SAAA,EAA2B;AAC/C,IAAA,IAAI,cAAc,KAAA,EAAO;AACvB,MAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AACd,MAAA,IAAA,CAAK,OAAA,GAAU,CAAA;AACf,MAAA,IAAA,CAAK,KAAA,GAAQ,CAAA;AACb,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,SAAA,GAAY,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAC/C,IAAA,MAAM,SAAA,GAAY,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAC/C,IAAA,IAAI,SAAA,GAAY,CAAA;AAChB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AACtC,MAAA,IAAI,MAAA,CAAO,CAAC,CAAA,CAAE,MAAA,KAAW,SAAA,EAAW,SAAA,EAAA;AAAA,WAAA,IAC3B,MAAA,CAAO,CAAC,CAAA,CAAE,MAAA,KAAW,SAAA,EAAW,SAAA,EAAA;AAAA,IAC3C;AACA,IAAA,IAAA,CAAK,SAAS,SAAA,KAAc,CAAA,GAAI,SAAS,IAAA,CAAK,aAAA,CAAc,QAAQ,SAAS,CAAA;AAC7E,IAAA,IAAA,CAAK,OAAA,GAAU,CAAA;AACf,IAAA,IAAA,CAAK,KAAA,GAAQ,CAAA;AAAA,EACf;AAAA;AAAA;AAAA;AAAA,EAKQ,aAAA,CAAc,QAAiB,SAAA,EAA4B;AACjE,IAAA,MAAM,MAAA,GAAS,OAAO,KAAA,EAAM;AAC5B,IAAA,IAAI,YAAY,CAAA,EAAG;AACjB,MAAA,MAAM,SAAA,GAAY,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAC/C,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,SAAA,EAAW,CAAA,EAAA,EAAK;AAClC,QAAA,MAAM,SAAA,GAAY,MAAA,CAAO,MAAA,CAAO,MAAA,GAAS,CAAC,CAAA;AAC1C,QAAA,MAAA,CAAO,IAAA,CAAK;AAAA,UACV,MAAM,UAAA,CAAW,MAAA;AAAA,UACjB,MAAA,EAAQ,SAAA;AAAA,UACR,KAAA,EAAO,GAAA;AAAA,UACP,IAAA,EAAM,GAAA;AAAA,UACN,QAAQ,SAAA,GAAY,SAAA,CAAU,MAAA,GAAS,SAAA,CAAU,KAAK,MAAA,GAAS,CAAA;AAAA,UAC/D,UAAA,EAAY,CAAA;AAAA,UACZ,IAAA,EAAM,SAAA,GAAY,SAAA,CAAU,IAAA,GAAO,CAAA;AAAA,UACnC,KAAK,SAAA,GAAY,SAAA,CAAU,GAAA,GAAM,SAAA,CAAU,KAAK,MAAA,GAAS;AAAA,SACjD,CAAA;AAAA,MACZ;AAAA,IACF,CAAA,MAAA,IAAW,YAAY,CAAA,EAAG;AACxB,MAAA,MAAM,SAAA,GAAY,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAC/C,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAC,WAAW,CAAA,EAAA,EAAK;AACnC,QAAA,MAAA,CAAO,OAAA,CAAQ;AAAA,UACb,MAAM,UAAA,CAAW,MAAA;AAAA,UACjB,MAAA,EAAQ,SAAA;AAAA,UACR,KAAA,EAAO,GAAA;AAAA,UACP,IAAA,EAAM,GAAA;AAAA,UACN,MAAA,EAAQ,CAAA;AAAA,UACR,UAAA,EAAY,CAAA;AAAA,UACZ,IAAA,EAAM,CAAA;AAAA,UACN,GAAA,EAAK;AAAA,SACG,CAAA;AAAA,MACZ;AAAA,IACF;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,eAAA,CAAgB,KAAA,GAAgB,CAAA,EAAG,QAAA,EAAkC;AAInE,IAAA,IAAI,QAAA,EAAU;AACZ,MAAA,IAAA,CAAK,OAAA,GAAU,QAAA;AAAA,IACjB;AACA,IAAA,IAAA,CAAK,KAAA,EAAA;AACL,IAAA,IAAI,IAAA,CAAK,KAAA,GAAQ,IAAA,CAAK,QAAA,EAAU;AAC9B,MAAA,IAAA,CAAK,KAAA,EAAA;AACL,MAAA,MAAM,YAAA,CAAa,OAAA;AAAA,QACjB,wBAAA;AAAA,QACA,CAAA,oBAAA,EAAuB,IAAA,CAAK,KAAK,CAAA,oBAAA,EAAuB,KAAK,QAAQ,CAAA,CAAA;AAAA,QACrE,EAAE,QAAA,EAAU,IAAA,CAAK,QAAA,EAAU,YAAA,EAAc,KAAK,KAAA;AAAM,OACtD;AAAA,IACF;AAEA,IAAA,MAAM,KAAA,GAAQ,KAAK,OAAA,EAAQ;AAC3B,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,IAAA,CAAK,KAAA,EAAA;AACL,MAAA,MAAM,YAAA,CAAa,OAAA,CAAQ,gBAAA,EAAkB,8BAA8B,CAAA;AAAA,IAC7E;AAGA,IAAA,IAAA,CAAK,YAAY,KAAK,CAAA;AAGtB,IAAA,MAAM,SAAS,IAAA,CAAK,MAAA;AACpB,IAAA,MAAM,MAAM,MAAA,CAAO,MAAA;AACnB,IAAA,MAAM,UAAU,iBAAA,CAAiB,QAAA;AACjC,IAAA,MAAM,WAAW,IAAA,CAAK,QAAA;AACtB,IAAA,MAAM,UAAU,IAAA,CAAK,OAAA;AACrB,IAAA,IAAI,MAAM,IAAA,CAAK,OAAA;AAEf,IAAA,OAAO,MAAM,GAAA,EAAK;AAChB,MAAA,MAAM,SAAA,GAAY,OAAO,GAAG,CAAA;AAC5B,MAAA,IAAI,CAAC,SAAA,EAAW;AAEhB,MAAA,MAAM,EAAA,GAAK,OAAA,CAAQ,SAAA,CAAU,MAAM,CAAA;AACnC,MAAA,IAAI,KAAK,CAAA,EAAG;AAEV,QAAA,IAAI,MAAM,KAAA,EAAO;AAEjB,QAAA,IAAI,KAAK,kBAAA,EAAoB;AAK3B,UAAA,MAAM,aAAA,GAAgB,QAAA,CAAS,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA;AACxD,UAAA,IAAI,aAAA,EAAe;AACjB,YAAA,IAAA,CAAK,mBAAA,CAAoB,aAAA,EAAe,SAAA,EAAW,KAAA,EAAO,EAAE,CAAA;AAAA,UAC9D;AAAA,QACF;AAEA,QAAA,IAAA,CAAK,UAAU,EAAE,GAAA;AACjB,QAAA,MAAM,SAAS,SAAA,CAAU,MAAA;AAEzB,QAAA,IAAI,MAAA,KAAW,kBAAiB,UAAA,EAAY;AAS1C,UAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,mBAA6B;AACrC,UAAA,OAAA,CAAQ,WAAW,GAAG,CAAA;AACtB,UAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,WAAqB;AAC7B,UAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,qBAA+B;AAAA,QACzC,WAAW,MAAA,KAAW,iBAAA,CAAiB,YAAY,IAAA,CAAK,oBAAA,CAAqB,OAAO,CAAA,EAAG,CAGvF,MAAO;AAgBL,UAAA,MAAM,UAAW,MAAA,KAAW,iBAAA,CAAiB,QAAA,GAAY,EAAA,GAAK,IAAI,EAAA,GAAK,CAAA;AACvE,UAAA,IAAA,CAAK,eAAA,CAAgB,SAAS,OAAO,CAAA;AACrC,UAAA,OAAA,CAAQ,UAAA,CAAW,iBAAA,CAAiB,YAAA,CAAa,MAAM,CAAC,CAAA;AAAA,QAC1D;AAAA,MACF,CAAA,MAAO;AAEL,QAAA,MAAM,aAAA,GAAgB,QAAA,CAAS,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA;AACxD,QAAA,IAAI,CAAC,aAAA,EAAe;AACpB,QAAA,IAAI,aAAA,CAAc,gBAAgB,KAAA,EAAO;AAEzC,QAAA,IAAA,CAAK,UAAU,EAAE,GAAA;AAEjB,QAAA,IAAI,KAAK,kBAAA,EAAoB;AAC3B,UAAA,IAAA,CAAK,mBAAA,CAAoB,aAAA,EAAe,SAAA,EAAW,KAAA,EAAO,cAAc,YAAY,CAAA;AAAA,QACtF;AAKA,QAAA,IAAA,CAAK,oBAAA,GAAuB,KAAA;AAE5B,QAAA,aAAA,CAAc,KAAA,CAAM,IAAA,EAAM,KAAA,EAAO,SAAA,EAAW,OAAO,CAAA;AAAA,MACrD;AAEA,MAAA,GAAA,GAAM,IAAA,CAAK,OAAA;AAAA,IACb;AAEA,IAAA,IAAA,CAAK,OAAA,GAAU,GAAA;AACf,IAAA,IAAA,CAAK,KAAA,EAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWQ,YAAY,KAAA,EAAoB;AACtC,IAAA,MAAM,UAAU,IAAA,CAAK,OAAA;AACrB,IAAA,MAAM,SAAS,KAAA,CAAM,MAAA;AAErB,IAAA,IAAI,KAAK,kBAAA,EAAoB;AAK3B,MAAA,MAAM,QAAA,GAAW,IAAA,CAAK,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA;AAC/C,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,IAAA,CAAK,mBAAA,CAAoB,QAAA,EAAU,KAAA,EAAO,IAAI,CAAA;AAAA,MAChD;AAAA,IACF;AAEA,IAAA,QAAQ,MAAA;AAAQ;AAAA,MAEd,KAAK,kBAAiB,SAAA,EAAW;AAE/B,QAAA,IAAI,CAAA;AAMJ,QAAA,IAAI,WAAA,GAA6B,IAAA;AACjC,QAAA,MAAM,MAAM,KAAA,CAAM,KAAA;AAClB,QAAA,IAAI,IAAI,UAAA,CAAW,IAAI,KAAK,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AAChD,UAAA,CAAA,GAAI,QAAA,CAAS,KAAK,EAAE,CAAA;AAIpB,UAAA,IAAI,MAAA,CAAO,KAAA,CAAM,CAAC,CAAA,EAAG;AACnB,YAAA,MAAM,YAAA,CAAa,QAAQ,wBAAA,EAA0B,CAAA,sBAAA,EAAyB,GAAG,CAAA,CAAA,CAAA,EAAK,EAAE,KAAK,CAAA;AAAA,UAC/F;AAAA,QACF,CAAA,MAAA,IAAW,IAAI,UAAA,CAAW,IAAI,KAAK,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AACvD,UAAA,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,KAAA,CAAM,CAAC,GAAG,CAAC,CAAA;AAC5B,UAAA,IAAI,MAAA,CAAO,KAAA,CAAM,CAAC,CAAA,EAAG;AACnB,YAAA,MAAM,YAAA,CAAa,QAAQ,wBAAA,EAA0B,CAAA,yBAAA,EAA4B,GAAG,CAAA,CAAA,CAAA,EAAK,EAAE,KAAK,CAAA;AAAA,UAClG;AAAA,QACF,CAAA,MAAA,IAAW,IAAI,UAAA,CAAW,IAAI,KAAK,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AACvD,UAAA,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,KAAA,CAAM,CAAC,GAAG,CAAC,CAAA;AAC5B,UAAA,IAAI,MAAA,CAAO,KAAA,CAAM,CAAC,CAAA,EAAG;AACnB,YAAA,MAAM,YAAA,CAAa,QAAQ,wBAAA,EAA0B,CAAA,wBAAA,EAA2B,GAAG,CAAA,CAAA,CAAA,EAAK,EAAE,KAAK,CAAA;AAAA,UACjG;AAAA,QACF,CAAA,MAAA,IAAW,4BAAA,CAA6B,IAAA,CAAK,GAAG,CAAA,EAAG;AAejD,UAAA,CAAA,GAAI,WAAW,GAAA,CAAI,KAAA,CAAM,GAAG,CAAA,CAAE,IAAA,CAAK,EAAE,CAAC,CAAA;AAAA,QACxC,CAAA,MAAO;AACL,UAAA,MAAM,MAAA,GAAS,SAAA,CAAU,IAAA,CAAK,UAAU,CAAA;AACxC,UAAA,MAAM,UAAA,GAAa,OAAO,OAAA,CAAQ,gBAAA;AAClC,UAAA,MAAM,YAAA,GAAe,OAAO,OAAA,CAAQ,kBAAA;AACpC,UAAA,IAAI,UAAA,GAAa,GAAA;AAEjB,UAAA,IAAI,YAAA,EAAc;AAChB,YAAA,UAAA,GAAa,UAAA,CAAW,KAAA,CAAM,YAAY,CAAA,CAAE,KAAK,EAAE,CAAA;AAAA,UACrD;AAEA,UAAA,IAAI,UAAA,IAAc,eAAe,GAAA,EAAK;AACpC,YAAA,UAAA,GAAa,UAAA,CAAW,OAAA,CAAQ,UAAA,EAAY,GAAG,CAAA;AAAA,UACjD;AACA,UAAA,CAAA,GAAI,WAAW,UAAU,CAAA;AAKzB,UAAA,IAAI,aAAA,CAAc,IAAA,CAAK,UAAU,CAAA,EAAG,WAAA,GAAc,UAAA;AAAA,QACpD;AACA,QAAA,IAAI,gBAAgB,IAAA,EAAM;AACxB,UAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,oBAA8B;AACtC,UAAA,OAAA,CAAQ,WAAW,WAAW,CAAA;AAC9B,UAAA;AAAA,QACF;AACA,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,mBAA6B;AACrC,QAAA,OAAA,CAAQ,WAAW,CAAC,CAAA;AACpB,QAAA;AAAA,MACF;AAAA,MAEA,KAAK,kBAAiB,SAAA,EAAW;AAK/B,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,mBAA6B;AACrC,QAAA,OAAA,CAAQ,WAAW,mBAAA,CAAoB,KAAA,CAAM,KAAA,EAAO,IAAA,CAAK,UAAU,CAAC,CAAA;AACpE,QAAA;AAAA,MACF;AAAA,MAEA,KAAK,kBAAiB,SAAA,EAAW;AAC/B,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,mBAA6B;AACrC,QAAA,OAAA,CAAQ,UAAA,CAAW,MAAM,KAAK,CAAA;AAC9B,QAAA;AAAA,MACF;AAAA;AAAA,MAGA,KAAK,kBAAiB,QAAA,EAAU;AAO9B,QAAA,IAAI,IAAA,CAAK,IAAA,EAAK,EAAG,MAAA,KAAW,kBAAiB,SAAA,EAAW;AACtD,UAAA,IAAA,CAAK,0BAAA,CAA2B,OAAO,OAAO,CAAA;AAC9C,UAAA;AAAA,QACF;AAQA,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,gBAA0B;AAClC,QAAA,OAAA,CAAQ,UAAA,CAAW,MAAM,KAAK,CAAA;AAC9B,QAAA;AAAA,MACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAWA,KAAK,kBAAiB,SAAA,EAAW;AAC/B,QAAA,IAAA,CAAK,eAAA,CAAgB,GAAG,OAAO,CAAA;AAC/B,QAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,QAAA,OAAO,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,KAAK,CAAA,EAAG;AACnC,UAAA,IAAA,CAAK,eAAA,CAAgB,GAAG,OAAO,CAAA;AAC/B,UAAA,KAAA,EAAA;AAAA,QACF;AACA,QAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAC9B,QAAA,IAAI,QAAQ,CAAA,EAAG;AAGb,UAAA,OAAA,CAAQ,UAAA,CAAA,GAAA,eAAyB;AACjC,UAAA,OAAA,CAAQ,UAAU,CAAC,CAAA;AACnB,UAAA,OAAA,CAAQ,UAAU,KAAK,CAAA;AAAA,QACzB;AACA,QAAA;AAAA,MACF;AAAA;AAAA,MAGA,KAAK,kBAAiB,QAAA,EAAU;AAC9B,QAAA,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,MAAA,EAAQ,OAAO,CAAA;AACjD,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,WAAqB;AAC7B,QAAA;AAAA,MACF;AAAA,MAEA,KAAK,kBAAiB,OAAA,EAAS;AAC7B,QAAA,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,MAAA,EAAQ,OAAO,CAAA;AACjD,QAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,WAAqB;AAC7B,QAAA;AAAA,MACF;AAAA;AAAA,MAGA,KAAK,kBAAiB,UAAA,CAGtB;AAIF,IAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,QAAA,CAAS,SAAA,CAAU,MAAM,CAAA;AACrD,IAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,MAAA,MAAM,YAAA,CAAa,OAAA;AAAA,QACjB,oBAAA;AAAA,QACA,CAAA,oCAAA,EAAuC,KAAA,CAAM,IAAI,CAAA,GAAA,EAAM,MAAM,KAAK,CAAA,EAAA,CAAA;AAAA,QAClE,EAAE,SAAA,EAAW,KAAA,CAAM,IAAA,EAAM,UAAA,EAAY,MAAM,KAAA;AAAM,OACnD;AAAA,IACF;AAEA,IAAA,cAAA,CAAe,KAAA,CAAM,IAAA,EAAM,KAAA,EAAO,OAAO,CAAA;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAyGQ,qBAAqB,OAAA,EAAmC;AAC9D,IAAA,KAAA,MAAW,IAAA,IAAQ,kBAAiB,kBAAA,EAAoB;AACtD,MAAA,IAAI,IAAA,CAAK,OAAA,CAAQ,IAAI,CAAA,EAAG;AACtB,QAAA,IAAA,CAAK,IAAA,CAAK,MAAM,OAAO,CAAA;AACvB,QAAA,OAAO,IAAA;AAAA,MACT;AAAA,IACF;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcQ,mBAAmB,OAAA,EAAgC;AACzD,IAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,IAAA,KAAA,IAAS,IAAI,OAAA,EAAS,CAAA,GAAI,IAAA,CAAK,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AACjD,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,MAAA,CAAO,CAAC,CAAA;AACvB,MAAA,IAAI,CAAA,CAAE,MAAA,KAAW,iBAAA,CAAiB,SAAA,EAAW,KAAA,EAAA;AAAA,WAAA,IACpC,CAAA,CAAE,MAAA,KAAW,iBAAA,CAAiB,SAAA,EAAW;AAChD,QAAA,KAAA,EAAA;AACA,QAAA,IAAI,KAAA,KAAU,GAAG,OAAO,CAAA;AAAA,MAC1B;AAAA,IACF;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBQ,0BAAA,CAA2B,WAAkB,OAAA,EAAgC;AACnF,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,kBAAA,CAAmB,IAAA,CAAK,OAAO,CAAA;AACrD,IAAA,IAAI,aAAa,IAAA,EAAM;AACrB,MAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,gBAA0B;AAClC,MAAA,OAAA,CAAQ,UAAA,CAAW,UAAU,KAAK,CAAA;AAClC,MAAA;AAAA,IACF;AACA,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,MAAA,CAAO,QAAA,GAAW,CAAC,CAAA;AAC3C,IAAA,IAAI,UAAA,EAAY,IAAA,KAAS,UAAA,CAAW,MAAA,EAAQ;AAC1C,MAAA,IAAA,CAAK,2BAAA,CAA4B,WAAW,OAAO,CAAA;AAAA,IACrD,CAAA,MAAO;AACL,MAAA,IAAA,CAAK,qBAAA,CAAsB,WAAW,OAAO,CAAA;AAAA,IAC/C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWQ,gBAAA,GAA2B;AACjC,IAAA,MAAM,KAAA,GAAQ,KAAK,IAAA,EAAK;AACxB,IAAA,IAAI,OAAO,IAAA,KAAS,UAAA,CAAW,SAAS,KAAA,EAAO,IAAA,KAAS,WAAW,IAAA,EAAM;AACvE,MAAA,IAAA,CAAK,OAAA,EAAQ;AACb,MAAA,OAAO,KAAA,CAAM,KAAA;AAAA,IACf;AACA,IAAA,MAAM,YAAA,CAAa,OAAA;AAAA,MACjB,kCAAA;AAAA,MACA,CAAA,mCAAA,EAAsC,KAAA,EAAO,IAAA,IAAQ,cAAc,CAAA,CAAA,EAAI,QAAQ,CAAA,GAAA,EAAM,KAAA,CAAM,KAAK,CAAA,EAAA,CAAA,GAAO,EAAE,CAAA,CAAA;AAAA,MACzG,EAAE,UAAA,EAAY,KAAA,EAAO,IAAA;AAAK,KAC5B;AAAA,EACF;AAAA,EAEQ,2BAAA,CAA4B,WAAkB,OAAA,EAAgC;AACpF,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAC9B,IAAA,MAAM,SAAmB,EAAC;AAC1B,IAAA,IAAI,IAAA,CAAK,IAAA,EAAK,EAAG,IAAA,KAAS,WAAW,MAAA,EAAQ;AAC3C,MAAA,MAAA,CAAO,IAAA,CAAK,IAAA,CAAK,gBAAA,EAAkB,CAAA;AACnC,MAAA,OAAO,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,KAAK,CAAA,EAAG;AACnC,QAAA,MAAA,CAAO,IAAA,CAAK,IAAA,CAAK,gBAAA,EAAkB,CAAA;AAAA,MACrC;AAAA,IACF;AACA,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAC9B,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAE9B,IAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACvB,MAAA,MAAM,YAAA,CAAa,OAAA;AAAA,QACjB,yBAAA;AAAA,QACA,CAAA,CAAA,EAAI,UAAU,KAAK,CAAA,yMAAA,CAAA;AAAA,QACnB,EAAE,IAAA,EAAM,SAAA,CAAU,KAAA;AAAM,OAC1B;AAAA,IACF;AAYA,IAAA,MAAM,WAAA,GAAc,IAAI,eAAA,EAAgB;AACxC,IAAA,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,MAAA,EAAQ,WAAW,CAAA;AACrD,IAAA,IAAA,CAAK,WAAW,OAAO,CAAA;AAEvB,IAAA,MAAM,WAAA,GAAc,YAAY,KAAA,EAAM;AACtC,IAAA,IAAI,YAAY,QAAA,EAAU;AAUxB,MAAA,MAAM,YAAA,CAAa,OAAA;AAAA,QACjB,mCAAA;AAAA,QACA,CAAA,CAAA,EAAI,UAAU,KAAK,CAAA,+HAAA,CAAA;AAAA,QACnB,EAAE,IAAA,EAAM,SAAA,CAAU,KAAA;AAAM,OAC1B;AAAA,IACF;AAEA,IAAA,MAAM,UAAU,OAAA,CAAQ,oBAAA,CAAqB,SAAA,CAAU,KAAA,EAAO,QAAQ,WAAW,CAAA;AACjF,IAAA,OAAA,CAAQ,UAAA,CAAA,GAAA,4BAAsC;AAC9C,IAAA,OAAA,CAAQ,UAAU,OAAO,CAAA;AAKzB,IAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,mBAA6B;AACrC,IAAA,OAAA,CAAQ,UAAA,CAAW,GAAG,SAAA,CAAU,KAAK,IAAI,MAAA,CAAO,IAAA,CAAK,IAAI,CAAC,CAAA,SAAA,CAAW,CAAA;AAAA,EACvE;AAAA,EAEQ,qBAAA,CAAsB,WAAkB,OAAA,EAAgC;AAC9E,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAC9B,IAAA,IAAI,QAAA,GAAW,CAAA;AACf,IAAA,IAAI,IAAA,CAAK,IAAA,EAAK,EAAG,IAAA,KAAS,WAAW,MAAA,EAAQ;AAC3C,MAAA,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,MAAA,EAAQ,OAAO,CAAA;AACjD,MAAA,QAAA,EAAA;AACA,MAAA,OAAO,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,KAAK,CAAA,EAAG;AACnC,QAAA,IAAA,CAAK,eAAA,CAAgB,YAAA,CAAa,MAAA,EAAQ,OAAO,CAAA;AACjD,QAAA,QAAA,EAAA;AAAA,MACF;AAAA,IACF;AACA,IAAA,IAAA,CAAK,OAAA,CAAQ,WAAW,MAAM,CAAA;AAE9B,IAAA,OAAA,CAAQ,UAAA,CAAA,GAAA,0BAAoC;AAC5C,IAAA,OAAA,CAAQ,UAAA,CAAW,UAAU,KAAK,CAAA;AAClC,IAAA,OAAA,CAAQ,SAAS,QAAQ,CAAA;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,YAAA,EAA8B;AACpC,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,OAAO,CAAA;AACtC,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,MAAM,YAAA,CAAa,OAAA;AAAA,QACjB,yBAAA;AAAA,QACA;AAAA,OACF;AAAA,IACF;AACA,IAAA,IAAI,iBAAiB,MAAA,EAAW;AAC9B,MAAA,MAAM,UAAA,GAAa,YAAY,YAAY,CAAA;AAC3C,MAAA,IAAI,KAAA,CAAM,WAAW,UAAA,EAAY;AAC/B,QAAA,MAAM,YAAA,CAAa,OAAA;AAAA,UACjB,uBAAA;AAAA,UACA,wBAAwB,YAAY,CAAA,WAAA,EAAc,MAAM,IAAI,CAAA,IAAA,EAAO,MAAM,KAAK,CAAA,EAAA,CAAA;AAAA,UAC9E,EAAE,YAAA,EAAc,UAAA,EAAY,MAAM,IAAA,EAAM,WAAA,EAAa,MAAM,KAAA;AAAM,SACnE;AAAA,MACF;AAAA,IACF;AACA,IAAA,IAAA,CAAK,OAAA,EAAA;AACL,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,MAAM,YAAA,EAA+B;AACnC,IAAA,MAAM,KAAA,GAAQ,KAAK,IAAA,EAAK;AACxB,IAAA,IAAI,KAAA,IAAS,KAAA,CAAM,MAAA,KAAW,WAAA,CAAY,YAAY,CAAA,EAAG;AACvD,MAAA,IAAA,CAAK,OAAA,EAAQ;AACb,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,IAAA,GAA0B;AACxB,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,OAAO,CAAA;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,MAAA,EAAmC;AACxC,IAAA,OAAO,IAAA,CAAK,MAAA,CAAO,IAAA,CAAK,OAAA,GAAU,MAAM,CAAA;AAAA,EAC1C;AAAA,EAEA,QAAA,GAA8B;AAC5B,IAAA,OAAO,IAAA,CAAK,UAAU,CAAA,GAAI,IAAA,CAAK,OAAO,IAAA,CAAK,OAAA,GAAU,CAAC,CAAA,GAAI,MAAA;AAAA,EAC5D;AAAA,EAEQ,OAAA,GAAgB;AACtB,IAAA,IAAA,CAAK,OAAA,EAAA;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAW,OAAA,EAAgC;AACzC,IAAA,IAAA,CAAK,OAAA,GAAU,OAAA;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAMQ,mBAAA,CACN,QAAA,EACA,KAAA,EACA,QAAA,EACA,YAAA,EACM;AACN,IAAA,MAAM,WAAW,IAAA,CAAK,kBAAA;AACtB,IAAA,MAAM,KAAA,GAAwD;AAAA,MAC5D,MAAM,mBAAA,CAAoB,eAAA;AAAA,MAC1B,SAAA,EAAW,CAAA;AAAA,MACX,YAAY,IAAA,CAAK,iBAAA;AAAA,MACjB,WAAW,KAAA,CAAM,IAAA;AAAA,MACjB,YAAY,KAAA,CAAM,KAAA;AAAA,MAClB,kBAAkB,QAAA,CAAS,QAAA;AAAA,MAC3B,YAAA,EAAc,QAAA,CAAS,WAAA,EAAa,IAAA,IAAQ,SAAA;AAAA,MAC5C,QAAA;AAAA,MACA,YAAA;AAAA,MACA,WAAA,EAAa,MAAM,MAAA,IAAU;AAAA,KAC/B;AACA,IAAA,QAAA,CAAS,oBAAoB,KAAK,CAAA;AAAA,EACpC;AACF,CAAA;AAAA;AAAA;AAAA;AAAA;AA91Ba,iBAAA,CA+BK,WAAuB,sBAAA,EAAuB;AAAA;AAAA;AA/BnD,iBAAA,CAmCa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAnCxD,iBAAA,CAoCa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AApCxD,iBAAA,CAqCa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AArCxD,iBAAA,CAsCa,QAAA,GAAc,WAAA,CAAY,UAAA,CAAW,KAAK,CAAA;AAtCvD,iBAAA,CAuCa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAvCxD,iBAAA,CAwCa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAxCxD,iBAAA,CAyCa,QAAA,GAAc,WAAA,CAAY,UAAA,CAAW,KAAK,CAAA;AAzCvD,iBAAA,CA0Ca,OAAA,GAAc,WAAA,CAAY,UAAA,CAAW,IAAI,CAAA;AA1CtD,iBAAA,CA2Ca,UAAA,GAAc,WAAA,CAAY,UAAA,CAAW,OAAO,CAAA;AAAA;AA3CzD,iBAAA,CA8Ca,OAAA,GAAc,WAAA,CAAY,UAAA,CAAW,IAAI,CAAA;AA9CtD,iBAAA,CA+Ca,QAAA,GAAc,WAAA,CAAY,UAAA,CAAW,KAAK,CAAA;AA/CvD,iBAAA,CAgDa,MAAA,GAAc,WAAA,CAAY,UAAA,CAAW,GAAG,CAAA;AAhDrD,iBAAA,CAiDa,QAAA,GAAc,WAAA,CAAY,UAAA,CAAW,KAAK,CAAA;AAjDvD,iBAAA,CAkDa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAlDxD,iBAAA,CAmDa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAnDxD,iBAAA,CAoDa,UAAA,GAAc,WAAA,CAAY,UAAA,CAAW,OAAO,CAAA;AApDzD,iBAAA,CAqDa,UAAA,GAAc,WAAA,CAAY,UAAA,CAAW,OAAO,CAAA;AArDzD,iBAAA,CAsDa,SAAA,GAAc,WAAA,CAAY,UAAA,CAAW,MAAM,CAAA;AAtDxD,iBAAA,CAuDa,UAAA,GAAc,WAAA,CAAY,UAAA,CAAW,OAAO,CAAA;AAvDzD,iBAAA,CAwDa,UAAA,GAAc,WAAA,CAAY,UAAA,CAAW,OAAO,CAAA;AAxDzD,iBAAA,CAyDa,KAAA,GAAc,WAAA,CAAY,UAAA,CAAW,EAAE,CAAA;AAAA;AAAA;AAAA;AAAA;AAzDpD,iBAAA,CA+Da,YAAA,GAAuC;AAAA,EAC7D,CAAC,WAAA,CAAY,UAAA,CAAW,IAAI,CAAC,GAAA,EAAA;AAAA,EAC7B,CAAC,WAAA,CAAY,UAAA,CAAW,KAAK,CAAC,GAAA,EAAA;AAAA,EAC9B,CAAC,WAAA,CAAY,UAAA,CAAW,IAAI,CAAC,GAAA,EAAA;AAAA,EAC7B,CAAC,WAAA,CAAY,UAAA,CAAW,KAAK,CAAC,GAAA,EAAA;AAAA,EAC9B,CAAC,WAAA,CAAY,UAAA,CAAW,GAAG,CAAC,GAAA,EAAA;AAAA,EAC5B,CAAC,WAAA,CAAY,UAAA,CAAW,KAAK,CAAC,GAAA,EAAA;AAAA,EAC9B,CAAC,WAAA,CAAY,UAAA,CAAW,MAAM,CAAC,GAAA,EAAA;AAAA,EAC/B,CAAC,WAAA,CAAY,UAAA,CAAW,MAAM,CAAC,GAAA,EAAA;AAAA,EAC/B,CAAC,WAAA,CAAY,UAAA,CAAW,OAAO,CAAC,GAAA,EAAA;AAAA,EAChC,CAAC,WAAA,CAAY,UAAA,CAAW,OAAO,CAAC,GAAA,EAAA;AAAA,EAChC,CAAC,WAAA,CAAY,UAAA,CAAW,MAAM,CAAC,GAAA,EAAA;AAAA,EAC/B,CAAC,WAAA,CAAY,UAAA,CAAW,OAAO,CAAC,GAAA,EAAA;AAAA,EAChC,CAAC,WAAA,CAAY,UAAA,CAAW,EAAE,CAAC,GAAA,EAAA;AAC7B,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA7EW,iBAAA,CA4hBa,kBAAA,GAInB;AAAA,EACH;AAAA,IACE,IAAA,EAAM,gBAAA;AAAA,IACN,OAAA,EAAS,CAAC,CAAA,KAAM;AACd,MAAA,MAAM,IAAA,GAAO,EAAE,IAAA,EAAK;AACpB,MAAA,OAAO,IAAA,EAAM,IAAA,KAAS,UAAA,CAAW,KAAA,IAAS,KAAK,KAAA,KAAU,GAAA;AAAA,IAC3D,CAAA;AAAA,IACA,IAAA,EAAM,CAAC,CAAA,EAAG,OAAA,KAAY;AACpB,MAAA,CAAA,CAAE,OAAA,EAAQ;AACV,MAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,oBAA8B;AACtC,MAAA,OAAA,CAAQ,UAAU,EAAE,CAAA;AACpB,MAAA,OAAA,CAAQ,UAAU,CAAC,CAAA;AAAA,IACrB;AAAA,GACF;AAAA,EACA;AAAA,IACE,IAAA,EAAM,eAAA;AAAA,IACN,OAAA,EAAS,CAAC,CAAA,KAAM;AACd,MAAA,MAAM,IAAA,GAAO,EAAE,IAAA,EAAK;AACpB,MAAA,IAAI,IAAA,EAAM,MAAA,KAAW,iBAAA,CAAiB,QAAA,EAAU,OAAO,KAAA;AACvD,MAAA,MAAM,UAAA,GAAa,CAAA,CAAE,MAAA,CAAO,CAAC,CAAA;AAC7B,MAAA,OAAO,UAAA,EAAY,IAAA,KAAS,UAAA,CAAW,MAAA,IAAU,WAAW,KAAA,KAAU,GAAA;AAAA,IACxE,CAAA;AAAA,IACA,IAAA,EAAM,CAAC,CAAA,EAAG,OAAA,KAAY;AACpB,MAAA,CAAA,CAAE,OAAA,EAAQ;AACV,MAAA,CAAA,CAAE,OAAA,EAAQ;AACV,MAAA,OAAA,CAAQ,UAAA,CAAA,EAAA,oBAA8B;AACtC,MAAA,OAAA,CAAQ,UAAU,EAAE,CAAA;AACpB,MAAA,OAAA,CAAQ,UAAU,CAAC,CAAA;AAAA,IACrB;AAAA;AAEJ,CAAA;AA9jBK,IAAM,gBAAA,GAAN","file":"chunk-I4GAWIPW.js","sourcesContent":["import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\n\n/**\n * The one binding-power field a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `InfixParselet` requires `bindingPower`; `PrefixParselet` declares none, and\n * some prefix parselets carry one anyway. That single field is the whole\n * optional surface deliberately. A `leftBindingPower`/`rightBindingPower` pair\n * used to be read here as well, and reading a name off an object this way finds\n * PRIVATE fields too, since TypeScript's `private` exists only at compile time:\n * `BinaryOpParselet` holds a private `rightBindingPower` meaning \"the minimum\n * power to parse my right operand at\", which is a different quantity from \"the\n * power at which I bind to my right\" and differs from it by one. Reading it\n * silently reported that other number. So neither is read.\n *\n * `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n}\n\n/** Reads the optional binding-power field off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/**\n\t * Iterate all registered prefix parselets for diagnostic display.\n\t *\n\t * `PrefixParselet` declares no binding power, and this used to read a field\n\t * of that name and report 0 for every one of them. 0 is not a neutral\n\t * wrong answer: it is the value that means \"not an operator, stop the\n\t * expression\", so a host drawing a table from this was told none of them\n\t * bind at all. A prefix parselet in this parser has no per-parselet power\n\t * to report, they all bind at the prefix level and each chooses for itself\n\t * at what power to parse its own operand, so that level is what is\n\t * reported. A parselet that does carry its own `bindingPower` still wins.\n\t */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? BindingPower.Prefix,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Iterate all registered infix parselets for diagnostic display.\n\t *\n\t * The field an `InfixParselet` actually declares is `bindingPower`. This\n\t * used to read `leftBindingPower` and `rightBindingPower`, which no\n\t * parselet in this codebase declares, so both reads were `undefined`, both\n\t * fell to the `?? 0` default, and the public `getParseletRegistry()`\n\t * reported a binding power of 0 for every one of the ~60 infix operators.\n\t * A host building a precedence table from it was told `*` and `+` bind\n\t * equally, and that neither binds at all.\n\t *\n\t * The left/right split: `bindingPower` is the LEFT power, and the right is\n\t * one higher. That is the standard encoding for a left-associative\n\t * operator, and it is what the parser itself does, see\n\t * `PrecedenceParser.parseExpression()`'s `bp + 1` for the right operand.\n\t * Every operator is reported that way, `^` included. Associativity is not\n\t * something a parselet declares, it is a property of how each one calls\n\t * `parseExpression`, so this API cannot report it without a new field on\n\t * the interface. See {@link ParseletBindingPowers} for why scraping a\n\t * plausible-looking one off the parselet is worse than not reporting it.\n\t */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tconst left = bindingPowersOf(parselet).bindingPower ?? 0;\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: left,\n\t\t\t\trightBindingPower: left + 1,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. It survives for the\n * deprecated {@link PackageRegistry} path only.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n","import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { bigIntLiteralDigits } from \"@solve-js/parser/BigIntLiteral\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * A plain fractional literal: digits, exactly one dot, digits, nothing else.\n *\n * The gate for compiling to PUSH_DECIMAL. It admits \"0.10\", \"1.005\", \".5\" and\n * \"5.\" and refuses anything with an exponent (\"2.5e-3\"), which parses as an\n * ordinary double instead, since scientific notation has no exact base-ten\n * value this representation would keep.\n */\nconst PLAIN_DECIMAL = /^\\d*\\.\\d*$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /**\n   * The binding power the current infix parselet is being invoked at, i.e. the\n   * `minBp` of the expression it sits inside. Set immediately before each Tier-2\n   * parselet runs. A parselet that decides whether to swallow a following\n   * loose operator (UomLiteralParselet with a trailing `in`/`to`) reads this to\n   * respect precedence it cannot otherwise see: `120 km / 2 hours in kph` must\n   * group as `(120 km / 2 hours) in kph`, not `120 km / (2 hours in kph)`.\n   */\n  infixMinBindingPower = 0;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly URSHIFT_ID  = tokenTypeId(TokenTypes.URSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.URSHIFT)]: OpCode.URSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  constructor(parseletRegistry: ParseletRegistry, maxDepth = 50, localeCode = \"en\") {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp - 1`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter.\n    if (_builder) {\n      this.builder = _builder;\n    }\n    this.depth++;\n    if (this.depth > this.maxDepth) {\n      this.depth--;\n      throw ErrorFactory.parsing(\n        \"NESTING_DEPTH_EXCEEDED\",\n        `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n        { maxDepth: this.maxDepth, currentDepth: this.depth }\n      );\n    }\n\n    const token = this.consume();\n    if (!token) {\n      this.depth--;\n      throw ErrorFactory.parsing(\"UNEXPECTED_END\", \"Unexpected end of expression\");\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → Percentage holding 0.5.\n          //\n          // Must stay byte-for-byte equivalent to PercentParselet, which is\n          // the Tier-2 registration of the same operator. This path is the one\n          // that actually runs for ordinary expressions, so a change made only\n          // in the parselet does nothing at all: that is exactly how the\n          // divide-by-100 here outlived its replacement and kept `200 + 10%`\n          // answering 200.10.\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n          builder.emitOpcode(OpCode.TO_PERCENTAGE);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          //\n          // The threshold has to be bp - 1, not bp. The loop above breaks on\n          // `bp <= minBp`, so a right operand parsed at `bp` stops at the next\n          // `^` exactly as one parsed at `bp + 1` does: the old special case\n          // was dead code and \"2 ^ 3 ^ 2\" grouped left, answering 64. One\n          // below lets the recursive call keep consuming `^`, which is what\n          // makes it 2^(3^2) = 512, as in mathematics, Python, Ruby and\n          // JavaScript's `**`.\n          //\n          // Nothing else sits between Exponent (50) and Product (40), so\n          // 49 cannot collide with another operator's level. Unary minus is\n          // unaffected: it parses its operand at Prefix (60), above `^`\n          // either way, so \"-2 ^ 2\" is still (-2)^2 = 4.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp - 1 : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Expose the level this parselet is bound at, so one that peeks past its\n        // own token (a unit literal weighing whether a trailing `in`/`to` is\n        // its own or an outer operator's) can respect precedence. See\n        // infixMinBindingPower's doc comment.\n        this.infixMinBindingPower = minBp;\n        // Parselet handles its own recursion for right operand internally\n        infixParselet.parse(this, token, lookahead, builder);\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n    this.depth--;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        // The exact dot-decimal text for a literal written with a fractional\n        // point, so it can be pushed as PUSH_DECIMAL and keep its precision\n        // where it later meets money. Stays null for every integer shape\n        // (hex/bin/oct, chained-dot grouping, plain integers), which push the\n        // ordinary PUSH_NUMBER and are unchanged.\n        let decimalText: string | null = null;\n        const raw = token.value;\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid hex literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid binary literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid octal literal: \"${raw}\"`, { raw });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const locale = getLocale(this.localeCode);\n          const decimalSep = locale.display.decimalSeparator;\n          const thousandsSep = locale.display.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation)\n          if (thousandsSep) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n          // A plain fractional literal (digits, one dot, digits) is what carries\n          // an exact decimal. Scientific notation like \"2.5e-3\" has a dot too\n          // but no exact base-ten form worth the trouble, so it stays a\n          // PUSH_NUMBER double, and so does any integer (grouping stripped).\n          if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;\n        }\n        if (decimalText !== null) {\n          builder.emitOpcode(OpCode.PUSH_DECIMAL);\n          builder.emitString(decimalText);\n          return;\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strips the `n` and any thousands grouping the lexer coalesced in.\n        // This used to be `raw.slice(0, -1)` and nothing else, so `1.000n`\n        // reached BigInt(\"1.000\") and threw a raw SyntaxError. See\n        // parser/BigIntLiteral.ts, which the parselet tier shares.\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(bigIntLiteralDigits(token.value, this.localeCode));\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing(\n        \"NO_PREFIX_PARSELET\",\n        `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        { tokenType: token.type, tokenValue: token.value }\n      );\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing(\n      \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      { actualType: token?.type },\n    );\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing(\n        \"USER_FUNCTION_NO_PARAMS\",\n        `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        { name: nameToken.value },\n      );\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder();\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing(\n        \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        { name: nameToken.value },\n      );\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing(\n        \"UNEXPECTED_END_OF_INPUT\",\n        \"Unexpected end of input\"\n      );\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing(\n          \"UNEXPECTED_TOKEN_TYPE\",\n          `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          { expectedType, actualType: token.type, actualValue: token.value }\n        );\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n"]}
+{"version":3,"sources":["../src/parser/registry/ParseletRegistry.ts","../src/parser/PrecedenceParser.ts"],"names":[],"mappings":"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","file":"chunk-AOH6UR2L.js","sourcesContent":["import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\n\n/**\n * The one binding-power field a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `InfixParselet` requires `bindingPower`; `PrefixParselet` declares none, and\n * some prefix parselets carry one anyway. That single field is the whole\n * optional surface deliberately. A `leftBindingPower`/`rightBindingPower` pair\n * used to be read here as well, and reading a name off an object this way finds\n * PRIVATE fields too, since TypeScript's `private` exists only at compile time:\n * `BinaryOpParselet` holds a private `rightBindingPower` meaning \"the minimum\n * power to parse my right operand at\", which is a different quantity from \"the\n * power at which I bind to my right\" and differs from it by one. Reading it\n * silently reported that other number. So neither is read.\n *\n * `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n}\n\n/** Reads the optional binding-power field off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/**\n\t * Iterate all registered prefix parselets for diagnostic display.\n\t *\n\t * `PrefixParselet` declares no binding power, and this used to read a field\n\t * of that name and report 0 for every one of them. 0 is not a neutral\n\t * wrong answer: it is the value that means \"not an operator, stop the\n\t * expression\", so a host drawing a table from this was told none of them\n\t * bind at all. A prefix parselet in this parser has no per-parselet power\n\t * to report, they all bind at the prefix level and each chooses for itself\n\t * at what power to parse its own operand, so that level is what is\n\t * reported. A parselet that does carry its own `bindingPower` still wins.\n\t */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? BindingPower.Prefix,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Iterate all registered infix parselets for diagnostic display.\n\t *\n\t * The field an `InfixParselet` actually declares is `bindingPower`. This\n\t * used to read `leftBindingPower` and `rightBindingPower`, which no\n\t * parselet in this codebase declares, so both reads were `undefined`, both\n\t * fell to the `?? 0` default, and the public `getParseletRegistry()`\n\t * reported a binding power of 0 for every one of the ~60 infix operators.\n\t * A host building a precedence table from it was told `*` and `+` bind\n\t * equally, and that neither binds at all.\n\t *\n\t * The left/right split: `bindingPower` is the LEFT power, and the right is\n\t * one higher. That is the standard encoding for a left-associative\n\t * operator, and it is what the parser itself does, see\n\t * `PrecedenceParser.parseExpression()`'s `bp + 1` for the right operand.\n\t * Every operator is reported that way, `^` included. Associativity is not\n\t * something a parselet declares, it is a property of how each one calls\n\t * `parseExpression`, so this API cannot report it without a new field on\n\t * the interface. See {@link ParseletBindingPowers} for why scraping a\n\t * plausible-looking one off the parselet is worse than not reporting it.\n\t */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tconst left = bindingPowersOf(parselet).bindingPower ?? 0;\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: left,\n\t\t\t\trightBindingPower: left + 1,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. It survives for the\n * deprecated {@link PackageRegistry} path only.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n","import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { bigIntLiteralDigits } from \"@solve-js/parser/BigIntLiteral\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * A plain fractional literal: digits, exactly one dot, digits, nothing else.\n *\n * The gate for compiling to PUSH_DECIMAL. It admits \"0.10\", \"1.005\", \".5\" and\n * \"5.\" and refuses anything with an exponent (\"2.5e-3\"), which parses as an\n * ordinary double instead, since scientific notation has no exact base-ten\n * value this representation would keep.\n */\nconst PLAIN_DECIMAL = /^\\d*\\.\\d*$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /**\n   * The binding power the current infix parselet is being invoked at, i.e. the\n   * `minBp` of the expression it sits inside. Set immediately before each Tier-2\n   * parselet runs. A parselet that decides whether to swallow a following\n   * loose operator (UomLiteralParselet with a trailing `in`/`to`) reads this to\n   * respect precedence it cannot otherwise see: `120 km / 2 hours in kph` must\n   * group as `(120 km / 2 hours) in kph`, not `120 km / (2 hours in kph)`.\n   */\n  infixMinBindingPower = 0;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly URSHIFT_ID  = tokenTypeId(TokenTypes.URSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.URSHIFT)]: OpCode.URSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  constructor(parseletRegistry: ParseletRegistry, maxDepth = 50, localeCode = \"en\") {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp - 1`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter.\n    if (_builder) {\n      this.builder = _builder;\n    }\n    this.depth++;\n    if (this.depth > this.maxDepth) {\n      this.depth--;\n      throw ErrorFactory.parsing(\n        \"NESTING_DEPTH_EXCEEDED\",\n        `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n        { maxDepth: this.maxDepth, currentDepth: this.depth }\n      );\n    }\n\n    const token = this.consume();\n    if (!token) {\n      this.depth--;\n      throw ErrorFactory.parsing(\"UNEXPECTED_END\", \"Unexpected end of expression\");\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → Percentage holding 0.5.\n          //\n          // Must stay byte-for-byte equivalent to PercentParselet, which is\n          // the Tier-2 registration of the same operator. This path is the one\n          // that actually runs for ordinary expressions, so a change made only\n          // in the parselet does nothing at all: that is exactly how the\n          // divide-by-100 here outlived its replacement and kept `200 + 10%`\n          // answering 200.10.\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n          builder.emitOpcode(OpCode.TO_PERCENTAGE);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          //\n          // The threshold has to be bp - 1, not bp. The loop above breaks on\n          // `bp <= minBp`, so a right operand parsed at `bp` stops at the next\n          // `^` exactly as one parsed at `bp + 1` does: the old special case\n          // was dead code and \"2 ^ 3 ^ 2\" grouped left, answering 64. One\n          // below lets the recursive call keep consuming `^`, which is what\n          // makes it 2^(3^2) = 512, as in mathematics, Python, Ruby and\n          // JavaScript's `**`.\n          //\n          // Nothing else sits between Exponent (50) and Product (40), so\n          // 49 cannot collide with another operator's level. Unary minus is\n          // unaffected: it parses its operand at Prefix (60), above `^`\n          // either way, so \"-2 ^ 2\" is still (-2)^2 = 4.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp - 1 : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Expose the level this parselet is bound at, so one that peeks past its\n        // own token (a unit literal weighing whether a trailing `in`/`to` is\n        // its own or an outer operator's) can respect precedence. See\n        // infixMinBindingPower's doc comment.\n        this.infixMinBindingPower = minBp;\n        // Parselet handles its own recursion for right operand internally\n        infixParselet.parse(this, token, lookahead, builder);\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n    this.depth--;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        // The exact dot-decimal text for a literal written with a fractional\n        // point, so it can be pushed as PUSH_DECIMAL and keep its precision\n        // where it later meets money. Stays null for every integer shape\n        // (hex/bin/oct, chained-dot grouping, plain integers), which push the\n        // ordinary PUSH_NUMBER and are unchanged.\n        let decimalText: string | null = null;\n        const raw = token.value;\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid hex literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid binary literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid octal literal: \"${raw}\"`, { raw });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const locale = getLocale(this.localeCode);\n          const decimalSep = locale.display.decimalSeparator;\n          const thousandsSep = locale.display.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation)\n          if (thousandsSep) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n          // A plain fractional literal (digits, one dot, digits) is what carries\n          // an exact decimal. Scientific notation like \"2.5e-3\" has a dot too\n          // but no exact base-ten form worth the trouble, so it stays a\n          // PUSH_NUMBER double, and so does any integer (grouping stripped).\n          if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;\n        }\n        if (decimalText !== null) {\n          builder.emitOpcode(OpCode.PUSH_DECIMAL);\n          builder.emitString(decimalText);\n          return;\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strips the `n` and any thousands grouping the lexer coalesced in.\n        // This used to be `raw.slice(0, -1)` and nothing else, so `1.000n`\n        // reached BigInt(\"1.000\") and threw a raw SyntaxError. See\n        // parser/BigIntLiteral.ts, which the parselet tier shares.\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(bigIntLiteralDigits(token.value, this.localeCode));\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing(\n        \"NO_PREFIX_PARSELET\",\n        `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        { tokenType: token.type, tokenValue: token.value }\n      );\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing(\n      \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      { actualType: token?.type },\n    );\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing(\n        \"USER_FUNCTION_NO_PARAMS\",\n        `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        { name: nameToken.value },\n      );\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder();\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing(\n        \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        { name: nameToken.value },\n      );\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing(\n        \"UNEXPECTED_END_OF_INPUT\",\n        \"Unexpected end of input\"\n      );\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing(\n          \"UNEXPECTED_TOKEN_TYPE\",\n          `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          { expectedType, actualType: token.type, actualValue: token.value }\n        );\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n"]}