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

package/dist/chunk-KVILKGMS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/language/TokenCategoryMap.ts"],"names":[],"mappings":"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","file":"chunk-KVILKGMS.js","sourcesContent":["import type { TokenCategory } from \"@solve-js/language/TokenCategory\";\n\n/**\n * Static, built-in token-type → semantic-category table.\n *\n * Covers the full `TokenTypes` surface (see Token.ts) so nothing recognized\n * by the lexer's grammar goes uncategorized by omission. Structural/internal\n * token types (WS, NEWLINE, EOF, BACKTICK_OPEN, INLINE_SOLVE_START, COMMENT)\n * are intentionally absent, they're either filtered out before reaching\n * this lookup (see Lexer.getHighlightTokens) or simply have nothing\n * meaningful to highlight. COMMENT specifically: it reaches\n * Lexer.getHighlightTokens() (unlike WS/NEWLINE, filtered earlier), so a\n * future \"give comments their own color\" pass would add a real category\n * here. This is a rendering-scope decision, not a correctness\n * requirement, since COMMENT tokens are already filtered out of the\n * parser's input regardless of how they're highlighted.\n */\nconst TOKEN_CATEGORY_MAP: Record<string, TokenCategory> = {\n\t// Literals\n\tNUMBER: \"number\",\n\tBIGINT: \"number\",\n\tFLOAT: \"number\",\n\tSTRING: \"string\",\n\n\t// Keywords (constants, date words, dice, misc grammar keywords)\n\tPI: \"keyword\",\n\tE: \"keyword\",\n\tNOW: \"keyword\",\n\tTODAY: \"keyword\",\n\tTOMORROW: \"keyword\",\n\tYESTERDAY: \"keyword\",\n\tROLL: \"keyword\",\n\tGLOBAL: \"keyword\",\n\tOF: \"keyword\",\n\tDURATION_DAY: \"keyword\",\n\tDURATION_WEEK: \"keyword\",\n\tDURATION_MONTH: \"keyword\",\n\tDURATION_YEAR: \"keyword\",\n\tDURATION_HOUR: \"keyword\",\n\tDURATION_MINUTE: \"keyword\",\n\tDURATION_SECOND: \"keyword\",\n\tNEXT: \"keyword\",\n\tLAST: \"keyword\",\n\tUNTIL: \"keyword\",\n\tSINCE: \"keyword\",\n\tBETWEEN: \"keyword\",\n\tFROM: \"keyword\",\n\tBEST: \"keyword\",\n\tKEYWORD: \"keyword\",\n\tTRUE: \"keyword\",\n\tFALSE: \"keyword\",\n\tIF: \"keyword\",\n\tTHEN: \"keyword\",\n\tELSE: \"keyword\",\n\tAS: \"keyword\",\n\tCONVERTER_NAME: \"keyword\",\n\tAVERAGE_OF: \"keyword\",\n\tMEDIAN_OF: \"keyword\",\n\tTOTAL_OF: \"keyword\",\n\tCOUNT_OF: \"keyword\",\n\tLARGER_OF: \"keyword\",\n\tSMALLER_OF: \"keyword\",\n\tHALF_OF: \"keyword\",\n\tMIDPOINT_BETWEEN: \"keyword\",\n\tCLAMP: \"keyword\",\n\tMAP: \"keyword\",\n\tREDUCE: \"keyword\",\n\tSUM_FN: \"keyword\",\n\tPROD_FN: \"keyword\",\n\t// Symbolic algebra verbs (packages/symbolic/). Declared here alongside\n\t// map/reduce rather than only on the package descriptor, so highlighting is\n\t// correct without depending on registration order.\n\tEXPAND_FN: \"keyword\",\n\tFACTOR_FN: \"keyword\",\n\tSOLVE_FN: \"keyword\",\n\tDER_FN: \"keyword\",\n\tINTEGRAL_FN: \"keyword\",\n\tTAYLOR_FN: \"keyword\",\n\tJACOBIAN_FN: \"keyword\",\n\tIMAGINARY: \"number\",\n\tCONJ_FN: \"keyword\",\n\tRE_FN: \"keyword\",\n\tIM_FN: \"keyword\",\n\tCANCEL_FN: \"keyword\",\n\tAPART_FN: \"keyword\",\n\tTIME_IN: \"keyword\",\n\tDATE_IN: \"keyword\",\n\tTIME_DIFFERENCE_BETWEEN: \"keyword\",\n\tCITY_NAME: \"keyword\",\n\tOVER: \"keyword\",\n\tRATE_AT: \"keyword\",\n\tCOMPOUND_INTEREST_ON: \"keyword\",\n\tINTEREST_ON: \"keyword\",\n\tDAILY_REPAYMENT_ON: \"keyword\",\n\tMONTHLY_REPAYMENT_ON: \"keyword\",\n\tANNUAL_REPAYMENT_ON: \"keyword\",\n\tTOTAL_REPAYMENT_ON: \"keyword\",\n\tDAILY_LOAN_INTEREST_ON: \"keyword\",\n\tMONTHLY_LOAN_INTEREST_ON: \"keyword\",\n\tANNUAL_LOAN_INTEREST_ON: \"keyword\",\n\tTOTAL_LOAN_INTEREST_ON: \"keyword\",\n\tTAX_ON: \"keyword\",\n\tTAX_OFF: \"keyword\",\n\tIS_TO: \"keyword\",\n\tRANDOM_NUMBER: \"keyword\",\n\tWHAT_IS: \"keyword\",\n\tWHAT_WAS: \"keyword\",\n\tVALUE_OF: \"keyword\",\n\tWORTH_IN: \"keyword\",\n\tIN_YEAR_DOLLARS: \"keyword\",\n\tINGREDIENT_NAME: \"keyword\",\n\tASSUMING: \"keyword\",\n\t// Datetime, workdays/weekdays/timestamps (packages/datetime/); Time\n\t// video timecode (packages/time/). See Token.ts's TokenTypes doc\n\t// comments for why each is a fused phrase/sequence token rather than a\n\t// bare keyword.\n\tWORKDAYS_IN: \"keyword\",\n\tWEEKDAY_ON: \"keyword\",\n\tWEEKDAY_IN: \"keyword\",\n\tMONTH_ON: \"keyword\",\n\tMONTH_IN: \"keyword\",\n\tWEEK_ON: \"keyword\",\n\tWEEK_IN: \"keyword\",\n\tBETWEEN_UNIT: \"keyword\",\n\tIS_WEEKEND: \"keyword\",\n\tIS_WORKDAY: \"keyword\",\n\tCURRENT_TIMESTAMP: \"keyword\",\n\tTO_DATE: \"keyword\",\n\tTO_TIMESTAMP: \"keyword\",\n\tVIDEO_TIMECODE: \"datetime\",\n\tFRAME_COUNT: \"datetime\",\n\tAT: \"keyword\",\n\n\t// Arithmetic / assignment-style operators\n\tPLUS: \"operator\",\n\tMINUS: \"operator\",\n\tSTAR: \"operator\",\n\tSLASH: \"operator\",\n\tCARET: \"operator\",\n\tPERCENT: \"operator\",\n\tLSHIFT: \"operator\",\n\tRSHIFT: \"operator\",\n\tEQUALS: \"operator\",\n\tTHEREFORE: \"operator\",\n\tINCREASE_BY: \"operator\",\n\tDECREASE_BY: \"operator\",\n\tOF_WHAT_IS: \"keyword\",\n\tON_WHAT_IS: \"keyword\",\n\tOFF_WHAT_IS: \"keyword\",\n\tTIMES_BY: \"operator\",\n\tMULTIPLY_BY: \"operator\",\n\tDIVIDE_BY: \"operator\",\n\tMOD: \"operator\",\n\tINCREASE: \"operator\",\n\tDECREASE: \"operator\",\n\tUNICODE_MATH: \"operator\",\n\tQUESTION: \"operator\",\n\tBANG: \"operator\",\n\n\t// Comparison operators\n\tNEQ: \"comparison\",\n\tIN: \"comparison\",\n\tGTE: \"comparison\",\n\tLTE: \"comparison\",\n\tEQUALITY: \"comparison\",\n\tLT: \"comparison\",\n\tGT: \"comparison\",\n\tLOGICAL_AND: \"comparison\",\n\tLOGICAL_OR: \"comparison\",\n\tOR: \"comparison\",\n\n\t// Bitwise operators\n\tURSHIFT: \"bitwise\",\n\tBIT_AND: \"bitwise\",\n\tBIT_OR: \"bitwise\",\n\tBIT_NOT: \"bitwise\",\n\tBIT_XOR: \"bitwise\",\n\n\t// Functions\n\tFUNC: \"function\",\n\n\t// Variable references/definitions, DOLLAR/COLON are the sigils, IDENT is\n\t// a bare identifier reference. All three are recognized-by-the-grammar\n\t// variable syntax at LEX time, independent of whether the variable turns\n\t// out to be defined at eval time (that's a separate, later concern).\n\tDOLLAR: \"variable\",\n\tCOLON: \"variable\",\n\tIDENT: \"variable\",\n\n\t// Units / conversions / currency symbols\n\tUNIT: \"unit\",\n\tCONVERT: \"unit\",\n\tTO: \"unit\",\n\tPOUND: \"unit\",\n\tEURO: \"unit\",\n\tYEN: \"unit\",\n\tRUBLE: \"unit\",\n\tWON: \"unit\",\n\tCURRENCY_SYMBOL: \"unit\",\n\n\t// Cross-line data access (packages/lines/)\n\tPREV: \"keyword\",\n\tLINE_REF: \"keyword\",\n\tSUM_RANGE_CALL: \"keyword\",\n\tAVERAGE_RANGE_CALL: \"keyword\",\n\tTOTAL_ABOVE: \"keyword\",\n\tSUM_ABOVE: \"keyword\",\n\tAVERAGE_ABOVE: \"keyword\",\n\n\t// Datetime literals/durations\n\tDATETIME_LITERAL: \"datetime\",\n\tDURATION: \"datetime\",\n\n\t// Vectors\n\tVEC2: \"vector\",\n\tVEC3: \"vector\",\n\tVEC4: \"vector\",\n\n\t// Punctuation, grouping/separators, deliberately neutral/muted rather\n\t// than left uncategorized: they're still recognized grammar, just not\n\t// semantically interesting enough to earn a \"loud\" color.\n\tLPAREN: \"punctuation\",\n\tRPAREN: \"punctuation\",\n\tLBRACKET: \"punctuation\",\n\tRBRACKET: \"punctuation\",\n\tLBRACE: \"punctuation\",\n\tRBRACE: \"punctuation\",\n\tDOT: \"punctuation\",\n\tCOMMA: \"punctuation\",\n\tSEMICOLON: \"punctuation\",\n\n\t// Errors\n\tERROR: \"error\",\n};\n\n/**\n * Token types intentionally left uncategorized, either purely structural\n * (never meant to be visibly styled) or already filtered out upstream\n * before reaching a category lookup. Used only by the completeness test to\n * distinguish \"deliberately unstyled\" from \"forgotten.\"\n */\nexport const UNCATEGORIZED_TOKEN_TYPES: ReadonlySet<string> = new Set([\n\t\"WS\",\n\t\"NEWLINE\",\n\t\"EOF\",\n\t\"BACKTICK_OPEN\",\n\t\"INLINE_SOLVE_START\",\n\t\"COMMENT\",\n]);\n\n/**\n * Runtime registry for package-contributed categories (e.g. a plugin's\n * custom token types). Overrides/extends the static table above, never\n * replaces it, so a package can't accidentally break core highlighting.\n * Register/unregister symmetry mirrors this codebase's other pluggable\n * registries (e.g. sharedOpRegistry). See ExpressionEngine.registerPackage\n * / unregisterPackage, which call these on behalf of IEnginePackage.tokenCategories.\n */\nconst pluginCategories = new Map<string, TokenCategory>();\n\n/**\n * Map a token type to a highlighting category.\n *\n * @param tokenType - Token type a package registered.\n * @param category - Category deciding how an editor colours it.\n */\nexport function registerTokenCategory(tokenType: string, category: TokenCategory): void {\n\tpluginCategories.set(tokenType, category);\n}\n\n/**\n * Remove a token type's highlighting category.\n *\n * @param tokenType - Token type to forget. Unknown types are ignored.\n */\nexport function unregisterTokenCategory(tokenType: string): void {\n\tpluginCategories.delete(tokenType);\n}\n\n/**\n * Resolve a token type to its semantic category, checking plugin-contributed\n * categories first (so a plugin could theoretically re-categorize a builtin\n * token type, though in practice plugins only ever add categories for their\n * own new types).\n *\n * @returns The category, or `undefined` if the token type has no category\n *   the signal to a UI adapter that this token should render unstyled.\n */\nexport function getTokenCategory(tokenType: string): TokenCategory | undefined {\n\treturn pluginCategories.get(tokenType) ?? TOKEN_CATEGORY_MAP[tokenType];\n}\n"]}

package/dist/chunk-NH2O2AUR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/uom/UnitConversion.ts","../src/uom/UomConverter.ts"],"names":[],"mappings":"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","file":"chunk-NH2O2AUR.js","sourcesContent":["/**\n * The unit conversion algorithm, ported from the `convert` npm package v7.0.2\n * alongside its tables (see `generated/UnitTable.generated.ts` and\n * THIRD-PARTY-NOTICES.md).\n *\n * Transliterated expression for expression rather than rewritten. Floating\n * point is not associative, so `(q + d) * (a / b) - d2` and any algebraically\n * equal rearrangement disagree in the last bits. Those bits are observable:\n * `0.5 l` best-converts to `500.00000000000006 mL` today, and the test suite\n * pins several conversions to ten decimal places.\n *\n * This module is deliberately unaware of the engine's own additions. Workdays,\n * extended units, currency and the caches all live in `UomConverter.ts`, which\n * layers them on top of these three functions.\n */\n\nimport {\n  UNIT_TABLE,\n  UNIT_DIFFERENCES,\n  BEST_UNITS_METRIC,\n  type UnitEntry,\n} from \"./generated/UnitTable.generated\";\n\n/**\n * The generated tables re-keyed into Maps once at module load.\n *\n * Not a micro-optimization. A 1456-key object literal lands in V8's dictionary\n * mode, and guarding a read on it against inherited names (`constructor`,\n * `toString`) costs about 123ns per call with either `hasOwnProperty.call` or\n * `Object.hasOwn`, measured. `Map.get` is about 6ns and needs no guard at all,\n * because a Map has no prototype chain to fall through to. That is a 20x\n * difference on the single hottest operation in the unit system: `convertRaw`\n * performs two of these per call, and `LanguageService` sweeps all 1456 keys\n * to build completions.\n */\nconst UNIT_LOOKUP: ReadonlyMap<string, UnitEntry> = new Map(Object.entries(UNIT_TABLE));\n\n/**\n * Temperature offsets, as a Map for the same reason.\n *\n * Also removes a latent hazard: the upstream code tests membership with `in`,\n * and `\"toString\" in UNIT_DIFFERENCES` is true, so an inherited name reaching\n * that branch would add a function to a number.\n */\nconst DIFFERENCE_LOOKUP: ReadonlyMap<string, number> = new Map(Object.entries(UNIT_DIFFERENCES));\n\n/**\n * Looks up a unit spelling.\n *\n * @returns its `[kind, ratio]` entry, or `undefined` if the spelling is not a\n * unit. Case-sensitive: no normalization or aliasing happens anywhere in this\n * module.\n *\n * The one deliberate deviation from upstream. `convert` tests membership with\n * `in` and reads the property directly, so inherited names like \"constructor\"\n * and \"toString\" reach its measure comparison and fail there with \"Cannot\n * convert between different measures\" instead of \"is not a valid unit\". Both\n * throw a RangeError and both report no measure, so nothing downstream can\n * tell the difference, and naming the real problem is the better message.\n */\nexport function lookupUnit(unit: string): UnitEntry | undefined {\n  return UNIT_LOOKUP.get(unit);\n}\n\n/**\n * Converts `quantity` from one unit to another.\n *\n * THROWS a `RangeError` for an unknown unit or a pair in different measures.\n * Callers depend on that: `VM.ts`'s `extractDurationMs()` calls this with an\n * arbitrary unit inside a bare try/catch and treats the throw as \"not a\n * duration, contribute zero\". Returning NaN or the input unchanged instead\n * would turn `<date> + 5 kg` into an Invalid Date rather than a no-op.\n */\nexport function convertRaw(quantity: number, from: string, to: string): number {\n  const parsedFrom = UNIT_LOOKUP.get(from);\n  if (parsedFrom === undefined) {\n    throw new RangeError(`${from} is not a valid unit`);\n  }\n\n  const parsedTo = UNIT_LOOKUP.get(to);\n  if (parsedTo === undefined) {\n    throw new RangeError(`${to} is not a valid unit`);\n  }\n\n  return convertResolved(quantity, from, to, parsedFrom, parsedTo);\n}\n\n/**\n * The conversion arithmetic, for callers that have already looked both units\n * up and want to skip doing it twice.\n *\n * Split out for `UomConverter.convertUnit()`, which has to check whether\n * either side is a workday or an extended unit before it can dispatch, and\n * would otherwise resolve each unit once to decide and again to convert. The\n * entries MUST be the ones this module returned for these exact spellings.\n */\nexport function convertResolved(\n  quantity: number,\n  from: string,\n  to: string,\n  fromEntry: UnitEntry,\n  toEntry: UnitEntry\n): number {\n  const parsedFrom = fromEntry;\n  const parsedTo = toEntry;\n\n  if (parsedFrom[0] !== parsedTo[0]) {\n    // DELIBERATE DEVIATION from the ported original, which silently reinterpreted\n    // \"m\" as minutes whenever the other side was a time unit. That is a guess,\n    // and this project's stated position is that refusing to guess is the safer\n    // default for a tool doing arithmetic on someone's real numbers (see\n    // docs/architecture/design-decisions.md). The guess was not harmless: it\n    // reached `<date> + <duration>` through VM.ts's extractDurationMs(), where\n    // `today + 5 m` silently added five MINUTES for someone who wrote metres.\n    //\n    // Minutes are spelled \"min\", \"minute\" or \"minutes\", all of which the table\n    // has always accepted.\n    throw new RangeError(`Cannot convert between different measures: ${from} and ${to}`);\n  }\n\n  const fromRatio = parsedFrom[1];\n  const toRatio = parsedTo[1];\n\n  // Only six units in the whole table carry an offset, so the common path is\n  // both misses. Reading the Map once per side and reusing the value beats\n  // testing membership and then reading it again.\n  const fromDifference = DIFFERENCE_LOOKUP.get(from);\n  const toDifference = DIFFERENCE_LOOKUP.get(to);\n\n  // Scales that do not share an origin (temperature) need the offset applied\n  // around the ratio. Do not refactor the four branches into one expression:\n  // the grouping is what makes the result bit-identical to the original.\n  if (fromDifference !== undefined) {\n    if (toDifference !== undefined) {\n      return (quantity + fromDifference) * (fromRatio / toRatio) - toDifference;\n    }\n    return (quantity + fromDifference) * (fromRatio / toRatio);\n  }\n\n  if (toDifference !== undefined) {\n    return quantity * (fromRatio / toRatio) - toDifference;\n  }\n\n  return quantity * (fromRatio / toRatio);\n}\n\n/**\n * Picks the most readable metric unit for a magnitude and converts to it.\n *\n * Only the metric lists are ported; nothing has ever requested the imperial\n * ones. Note the final conversion goes from the ORIGINAL unit to the chosen\n * one directly rather than via the smallest unit, which is what keeps the\n * result exact.\n */\nexport function convertToBestMetric(\n  quantity: number,\n  from: string\n): { quantity: number; unit: string } {\n  const parsedFrom = UNIT_LOOKUP.get(from);\n  if (parsedFrom === undefined) {\n    throw new RangeError(`${from} is not a valid unit`);\n  }\n\n  const best = BEST_UNITS_METRIC[parsedFrom[0]];\n  const smallestUnit = best[0][0];\n  let bestUnit = smallestUnit;\n\n  const baseQuantity = convertRaw(quantity, from, smallestUnit);\n  const absQuantity = baseQuantity < 0 ? -baseQuantity : baseQuantity;\n\n  // Thresholds are expressed in the smallest unit and ascend, so the last one\n  // the magnitude reaches wins. Breaking early rather than scanning the whole\n  // list matters for zero and for negatives, which stay on the smallest unit.\n  for (let i = 0; i < best.length; i++) {\n    const bestEntry = best[i];\n    if (absQuantity >= bestEntry[1]) {\n      bestUnit = bestEntry[0];\n    } else {\n      break;\n    }\n  }\n\n  return { quantity: convertRaw(quantity, from, bestUnit), unit: bestUnit };\n}\n","/**\n * UoM Converter, built on the in-house unit tables in `UnitConversion.ts` and\n * `generated/UnitTable.generated.ts` (ported from the `convert` npm package\n * v7.0.2 so the engine ships with no runtime dependencies).\n *\n * Units are strictly case-sensitive and are looked up without aliasing. No unit\n * remapping, what you type is what you get.\n * e.g. 'C' = Celsius, 'c' = cup; 'MB' = megabytes, 'mb' = millibits.\n *\n * This file owns everything the base tables do not: the workday shim, the\n * extended (custom-measure) units, and the two caches.\n */\n\nimport { lookupUnit, convertRaw, convertResolved, convertToBestMetric } from \"@solve-js/uom/UnitConversion\";\nimport { MEASURE_KIND_NAMES, MEASURE_SYMBOLS } from \"@solve-js/uom/generated/UnitTable.generated\";\nimport { EXTENDED_UNITS } from \"@solve-js/uom/ExtendedUnits\";\n\n// ── \"workday\", a synthetic unit with no entry in the base table ───────────\n//\n// A business day (Mon-Fri) backing the datetime package's `<date> + N\n// workdays` arithmetic and `$X/workday` Rate literals\n// (packages/datetime/). NOT a real physical unit, a business day has no\n// fixed duration, since it depends on which calendar dates are weekends\n// so the ported base table has no concept of it and can't be\n// taught one without monkey-patching its internal unit table.\n//\n// For RATE-MATH purposes only (e.g. \"$500/workday x 4 weeks\" needs a\n// workday count to multiply by), a workday is treated as a FIXED 7/5 of a\n// calendar day: 5 workdays span exactly 7 calendar days in a whole week,\n// so this ratio is exact for whole-week spans and a reasonable linear\n// approximation otherwise. This is deliberately NOT the same\n// calendar-aware, weekend-skipping logic real \"<date> + N workdays\" date\n// arithmetic needs (see vm/VM.ts's addBusinessDays()), that can't be\n// reduced to a fixed ratio, since the exact skip pattern depends on which\n// day of the week the calculation actually starts from.\n//\n// Handled here as a thin pre/post layer in front of the normal\n// base-table path (rather than inside the tables themselves) so every\n// caller of getMeasure()/convertUnit()/canConvert() automatically gets\n// workday support for free.\nconst WORKDAY_UNIT_NAMES = new Set([\"workday\", \"workdays\"]);\nconst WORKDAY_TO_DAY_FACTOR = 7 / 5; // 1 workday == 1.4 calendar days\n\n/** Whether `unit` is the synthetic \"workday\" unit (see module note above). */\nexport function isWorkdayUnit(unit: string | undefined): unit is string {\n  return typeof unit === \"string\" && WORKDAY_UNIT_NAMES.has(unit);\n}\n\n/**\n * Validate `unit` against the known unit table.\n *\n * @returns `unit` unchanged in all cases. This does NOT normalize casing\n *   or aliasing (units are strictly case-sensitive, see the module note\n *   above). A unit the table doesn't recognize is still\n *   returned as-is (not thrown), so callers must not assume a returned\n *   string is actually convertible, check with {@link isConvertibleUnit}\n *   or {@link canConvert} first if that matters.\n *\n * Kept as an identity function purely for API compatibility. It used to guard\n * a validity cache, which existed because validating a unit meant a\n * throw/catch round trip through the old dependency. Validation is now a Map\n * lookup, so the cache cost more than it saved: worse, it was capped at 1000\n * entries against a 1456-unit table, so any sweep over the full vocabulary\n * (which is exactly what LanguageService does to build completions) evicted\n * on almost every call. That one change took the full-table sweep from 7.7ms\n * to under 20us.\n */\nexport function resolveUnit(unit: string): string {\n  return unit;\n}\n\n// MEASURE_KIND_NAMES now comes from the generated table (it is derived data,\n// so the generator emits it rather than it being retyped here). The reason it\n// is a module-level constant has not changed: getMeasure() runs at least twice\n// per conversion, and this used to be reallocated on every call.\n\n/**\n * Get the measure/dimension kind for `unit` (e.g. `\"length\"`, `\"mass\"`,\n * `\"temperature\"`), used to check whether two units are even in the same\n * dimension before attempting a conversion.\n *\n * @returns `undefined` if `unit` isn't recognized, rather than throwing.\n */\nexport function getMeasure(unit: string): string | undefined {\n  // Workday is a Time-measure unit by convention (see isWorkdayUnit's doc\n  // comment) and is not in the base table, so resolve its measure via \"day\"\n  // instead of attempting the real lookup below.\n  if (isWorkdayUnit(unit)) return getMeasure(\"day\");\n\n  // Extended (custom) categories the base table has no measure kind for,\n  // see ExtendedUnits.ts.\n  const extended = EXTENDED_UNITS[unit];\n  if (extended) return extended.measure;\n\n  const entry = lookupUnit(unit);\n  if (entry === undefined) return undefined;\n\n  return MEASURE_KIND_NAMES[entry[0]];\n}\n\n/**\n * Check whether `from` can be converted to `to`. Same unit, or same\n * measure kind (length, mass, ...) and the underlying tables accept the pair.\n * Never throws; returns `false` on any failure.\n */\nexport function canConvert(from: string, to: string): boolean {\n  if (from === to) return true;\n  if (isWorkdayUnit(from) || isWorkdayUnit(to)) {\n    const fromMeasure = getMeasure(from);\n    const toMeasure = getMeasure(to);\n    return !!fromMeasure && fromMeasure === toMeasure;\n  }\n  // One table read per side, comparing numeric kind ids. The old shape called\n  // getMeasure() on each side (two more reads) purely to compare the resulting\n  // STRINGS, then did a throwaway conversion to confirm what the kind check had\n  // already established.\n  const fromEntry = lookupUnit(from);\n  const toEntry = lookupUnit(to);\n  if (fromEntry !== undefined && toEntry !== undefined) {\n    return fromEntry[0] === toEntry[0];\n  }\n\n  // Extended (custom) categories aren't in the base table at all, so they are\n  // compared on their own measure names instead.\n  const fromExtended = EXTENDED_UNITS[from];\n  const toExtended = EXTENDED_UNITS[to];\n  if (fromExtended !== undefined && toExtended !== undefined) {\n    return fromExtended.measure === toExtended.measure;\n  }\n\n  // Mixed: one side is a base unit and the other is extended or unknown. The\n  // measure spaces are disjoint by construction, so this can never convert.\n  return false;\n}\n\n/**\n * Convert `value` from unit `from` to unit `to`.\n *\n * Does not validate that the conversion is possible, callers should check\n * with {@link canConvert} first if `from`/`to` aren't already known-good.\n *\n * THROWS a RangeError for an unknown unit or a cross-measure pair. `VM.ts`'s\n * `extractDurationMs()` depends on that, see {@link convertRaw}.\n *\n * This used to memoize a per-pair conversion factor in an LFU cache. The cache\n * is gone: computing the factor is now two Map reads, while the cache cost a\n * template-string key allocation on every call plus the LFU's own frequency\n * bookkeeping, so it was slower than the work it avoided. Removing it is\n * bit-exact, not merely close: the cache stored `convertRaw(1, f, t)`, which is\n * exactly `fromRatio / toRatio`, and then multiplied, which is the identical\n * expression `convertRaw(value, f, t)` evaluates. It also deleted the special\n * case that existed only to keep offset-based temperature pairs out of a\n * factor cache.\n */\nexport function convertUnit(value: number, from: string, to: string): number {\n  if (from === to) return value;\n\n  // Fast path first: two ordinary units, which is nearly every call. Resolving\n  // both here and handing the entries to convertResolved() avoids looking them\n  // up again inside convertRaw(). Neither workdays nor extended units appear in\n  // the base table, so they always fall through to the branches below and this\n  // ordering cannot steal a case from them. UnitVocabulary.spec.ts pins that\n  // the two vocabularies stay disjoint.\n  const fromEntry = lookupUnit(from);\n  const toEntry = lookupUnit(to);\n  if (fromEntry !== undefined && toEntry !== undefined) {\n    return convertResolved(value, from, to, fromEntry, toEntry);\n  }\n\n  // Workday <-> any other Time-measure unit: pivot through \"day\" using the\n  // fixed 7/5 ratio (see isWorkdayUnit's doc comment above).\n  if (isWorkdayUnit(from) && isWorkdayUnit(to)) return value; // \"workday\" <-> \"workdays\" alias\n  if (isWorkdayUnit(from)) {\n    const days = value * WORKDAY_TO_DAY_FACTOR;\n    return to === \"day\" ? days : convertUnit(days, \"day\", to);\n  }\n  if (isWorkdayUnit(to)) {\n    const days = from === \"day\" ? value : convertUnit(value, from, \"day\");\n    return days / WORKDAY_TO_DAY_FACTOR;\n  }\n\n  // Extended (custom) categories the base table has no measure kind for\n  // (see ExtendedUnits.ts), compute the ratio directly from each unit's\n  // factor-to-base value instead of calling convertRaw(), which would throw\n  // on an unrecognized unit string. Every extended category is a pure linear\n  // ratio scale (no Temperature-style offset), so this is always safe.\n  const fExt = EXTENDED_UNITS[from];\n  const tExt = EXTENDED_UNITS[to];\n  if (fExt !== undefined && tExt !== undefined) {\n    return value * (fExt.toBase / tExt.toBase);\n  }\n\n  // Offsets, cross-measure rejection and the unknown-unit throw all live in\n  // convertRaw. Nothing is layered on top here any more.\n  return convertRaw(value, from, to);\n}\n\n/**\n * List every unit symbol in the same measure/dimension as `unit` (wiki:\n * Units-Of-Measurement, \"Conversion Possibilities\", `sourceUnit to ?`\n * e.g. `cm to ?\"` → every Length unit). Excludes `unit` itself.\n *\n * Reads MEASURE_SYMBOLS, which is a curated symbols-only vocabulary and\n * deliberately NOT the keys of the unit table filtered by kind. The two\n * differ: Volume's symbols include `c` and `pt` but not `cup`/`cups`, and\n * Time's include `wk` and `mo` but not `week`/`month`. Deriving this list\n * from the unit table instead would roughly quadruple every answer.\n *\n * @returns `[]` if `unit` isn't recognized, rather than throwing.\n */\nexport function getConvertiblePossibilities(unit: string): string[] {\n  const resolved = resolveUnit(unit);\n  const entry = lookupUnit(resolved);\n  if (entry === undefined) return [];\n  const symbols = MEASURE_SYMBOLS[entry[0]];\n  if (!symbols) return [];\n  return symbols.filter((s) => s !== resolved);\n}\n\n/** Check whether `unit` is a unit the conversion tables recognize. Never throws. */\nexport function isConvertibleUnit(unit: string): boolean {\n  if (isWorkdayUnit(unit)) return true;\n  if (EXTENDED_UNITS[unit]) return true;\n  return lookupUnit(resolveUnit(unit)) !== undefined;\n}\n\n/**\n * Convert `value` (in `unit`) to whichever unit of the same measure gives\n * the most human-readable magnitude, e.g. 1500 metres becomes 1.5 km. Falls\n * back to returning `value`/`unit` unchanged if `unit` isn't recognized,\n * which is what every extended unit and workday does.\n *\n * Note the chosen unit is drawn from the best-unit lists, which are not\n * restricted to spellings the lexer accepts: 0.5 l reports \"mL\".\n */\nexport function getBestUnit(value: number, unit: string): { value: number; unit: string } {\n  const u = resolveUnit(unit);\n  try {\n    const result = convertToBestMetric(value, u);\n    return { value: result.quantity, unit: result.unit };\n  } catch {\n    return { value, unit: u };\n  }\n}\n"]}

package/dist/chunk-OJ6LW7VQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/normalizer/TokenNormalizer.ts","../src/normalizer/PhraseTrie.ts","../src/normalizer/BuiltinNormalizerRules.ts"],"names":[],"mappings":"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","file":"chunk-OJ6LW7VQ.js","sourcesContent":["//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * TokenNormalizer, post-lexer token normalization pass.\n *\n * ## Purpose\n * Applies domain-specific {@link NormalizerRule | NormalizerRules} to the raw\n * token stream produced by the {@link ExpressionLexer}. This keeps the lexer\n * slim and focused on single-token production, while multi-token pattern\n * matching (phrases, implicit operators, domain merges) lives here.\n *\n * ## What rules can do\n * - **Phrase fusion**: Merge consecutive words into compound tokens\n *   (e.g., `IDENT + ... + IDENT` → `CARET`)\n * - **Implicit operator insertion**: Insert missing operators between tokens\n *   (e.g., `NUMBER IDENT` → `NUMBER STAR IDENT`)\n * - **Domain-specific transformations**: Coalesce item names, currency pairs,\n *   percentage syntax, etc.\n *\n * ## Architecture\n * Providers register NormalizerRules alongside Parselets and OpCode handlers\n * via {@link IEnginePackage.normalizerRules}. The normalizer applies them\n * greedily left-to-right in multiple passes with safety limits.\n *\n * @module TokenNormalizer\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, TokenFusion } from \"./NormalizerRule\";\nimport { PhraseTrie } from \"./PhraseTrie\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n//#endregion\n//#region ─── NormalizerOptions, Configuration ────────────────────────────────\n\n/**\n * Configuration options for the normalization pass.\n *\n * These control safety limits and diagnostic callbacks. The defaults\n * are chosen to be generous enough for any realistic expression while\n * preventing runaway token expansion from recursive rules.\n */\nexport interface NormalizerOptions {\n  /**\n   * Maximum number of full passes over the token stream before bailing out.\n   * Prevents infinite loops from recursive rule chains.\n   * @default 100\n   */\n  maxPasses?: number;\n\n  /**\n   * Maximum number of tokens allowed after normalization.\n   * If exceeded, an Error is thrown rather than passing a bloated stream\n   * to the parser.\n   * @default 10000\n   */\n  maxTokens?: number;\n\n  /**\n   * Callback invoked for each fusion event during normalization.\n   * Used by diagnostic mode to populate {@link NormalizerOutput.fusions}.\n   * When `undefined`, fusions are still tracked internally but no callbacks fire.\n   */\n  onFusion?: (fusion: TokenFusion) => void;\n}\n\n//#endregion\n//#region ─── Default Options ──────────────────────────────────────────────────\n\n/** Sensible defaults that catch infinite loops without limiting real expressions. */\nconst DEFAULT_OPTIONS: Required<NormalizerOptions> = {\n  maxPasses: 100,\n  maxTokens: 10000,\n  onFusion: () => {},\n};\n\n//#endregion\n//#region ─── createFusedToken, Token Factory ──────────────────────────────────\n\n/**\n * Creates a new normalized token from fused source tokens.\n *\n * The fused token inherits position information (offset, line, column)\n * from the first source token, which preserves source-map accuracy\n * for error messages and diagnostic highlighting.\n *\n * It also records where the source text ENDS, on `sourceEnd`. The start alone\n * is not enough to describe the span a fusion covers, because `text` is the\n * replacement rather than the original: `10 frames` fuses into a FRAME_COUNT\n * whose text is `10`, and a timecode fuses into a token whose text is a\n * comma-separated tuple that appears nowhere in the line. Anything painting the\n * line needs both ends, and only this function is in a position to know them.\n *\n * @param type         - The new token type (e.g., \"CARET\", \"TIMES_BY\")\n * @param text         - The combined text representation (e.g., \"to the power of\")\n * @param sourceTokens - The original tokens being fused (at least 2)\n * @returns A new {@link LexerToken} with the fused type and combined text\n */\nexport function createFusedToken(\n  type: string,\n  text: string,\n  sourceTokens: Token[]\n): Token {\n  const first = sourceTokens[0];\n  const last = sourceTokens[sourceTokens.length - 1];\n  const token = new LexerToken(\n    type,\n    tokenTypeId(type),\n    text,\n    text,\n    first.offset,\n    first.lineBreaks ?? 0,\n    first.line,\n    first.col,\n  );\n  token.sourceEnd = last.offset + last.value.length;\n  return token;\n}\n\n/**\n * Record, on a token that replaced several, where its source text ended.\n *\n * Called centrally rather than left to each rule. A rule that builds its\n * replacement by hand rather than through {@link createFusedToken} is doing\n * nothing wrong, and several do: the date-literal rule needs a token whose\n * value is an epoch and whose text is the source, which that factory cannot\n * express. Stamping here means every fusion carries its span, including ones\n * written after this was.\n *\n * Reads `sourceEnd` off the last source token when it has one, so a fusion of\n * a fusion still describes the original text rather than the intermediate.\n *\n * @param fused - The single token the rule produced.\n * @param sourceTokens - The tokens it consumed.\n */\nfunction recordSourceSpan(fused: Token, sourceTokens: Token[]): void {\n  const last = sourceTokens[sourceTokens.length - 1];\n  if (!last) return;\n  fused.sourceEnd = last.sourceEnd ?? last.offset + last.value.length;\n}\n\n//#endregion\n//#region ─── NON_WORD_TOKEN_TYPES, Type-guard skip set ────────────────────────\n\n/**\n * Token types that can NEVER start a multi-word phrase.\n *\n * Used by {@link normalize} to skip the PhraseTrie walk entirely at\n * positions where the token type makes phrase matching impossible.\n * This avoids even the O(1) {@link PhraseTrie.canStart} check.\n *\n * Types NOT in this set (IDENT, KEYWORD, FUNC, UNIT, and any custom\n * types registered by packages) still pass through to the trie for\n * a full match attempt.\n */\n// ── Non-word type ID lookup table (flat Uint8Array, true O(1) array index) ──\n//\n// Index = token typeId, value = 1 if non-word (skip trie), 0 otherwise.\n// Array indexing avoids ALL hashing: no Set.has(), no Map.get(), no string ops.\n//\n// Custom types from packages get IDs beyond the table length, so the bounds\n// check `tid < TABLE.length` safely passes them through to the trie.\n//\n// Arithmetic operators (PLUS, MINUS, STAR, SLASH, CARET, MOD, PERCENT) are\n// intentionally excluded: in keyword locales the lexer maps \"times\"→STAR,\n// \"divide\"→SLASH etc., and those tokens CAN start phrases like \"times by\".\n/**\n * Token type names that can NEVER start a multi-word phrase.\n *\n * Exported for testing only, consumers should use the type-guard behavior\n * of {@link TokenNormalizer.normalize} rather than this list directly.\n */\nexport const NON_WORD_NAMES = [\n\t\"NUMBER\", \"HEX\", \"BIGINT\", \"FLOAT\",\n\t\"LSHIFT\", \"RSHIFT\", \"BIT_AND\", \"BIT_OR\", \"BIT_XOR\",\n\t\"LPAREN\", \"RPAREN\", \"LBRACKET\", \"RBRACKET\",\n\t\"COMMA\", \"COLON\", \"EQUALS\", \"THEREFORE\", \"PIPE\", \"AMPERSAND\", \"AT\",\n\t\"SEMICOLON\", \"QUESTION\", \"EXCLAMATION\",\n\t\"EOF\", \"WS\", \"NEWLINE\",\n] as const;\n\n/**\n * Flat Uint8Array lookup table: index = token typeId, value = 1 if non-word.\n *\n * Exported for testing only, consumers should not depend on the internal\n * table layout, as the set of non-word types may change.\n */\nexport const NON_WORD_TABLE: Uint8Array = (() => {\n\t// Resolve all non-word type names to their numeric IDs\n\tconst ids = NON_WORD_NAMES.map(n => tokenTypeId(n));\n\t// Size the table to cover the largest ID + 1\n\tconst len = Math.max(...ids) + 1;\n\tconst table = new Uint8Array(len);\n\t// Mark non-word type positions\n\tfor (const id of ids) table[id] = 1;\n\treturn table;\n})();\n\n//#endregion\n//#region ─── TokenNormalizer Class ─────────────────────────────────────────────\n\n/**\n * Token normalizer: applies {@link NormalizerRule | NormalizerRules} to a token stream.\n *\n * ## Lifecycle\n * 1. **Registration**: Rules are added via {@link register} and sorted by priority\n * 2. **Normalization**: {@link normalize} applies rules greedily left-to-right\n * 3. **Cleanup**: {@link clear} or {@link unregister} removes rules\n *\n * ## Normalization algorithm\n * The normalizer uses a greedy left-to-right multi-pass algorithm:\n * - At each token position, rules are tried in priority order (highest first)\n * - When a rule matches, matched tokens are consumed and replaced\n * - Processing continues from the replacement position\n * - Multiple passes handle cascading matches (one rule's output triggers another)\n * - Safety limits ({@link NormalizerOptions.maxPasses}) prevent infinite loops\n *\n * @example\n * ```ts\n * const normalizer = new TokenNormalizer();\n * normalizer.register(phraseRule);       // \"to the power of\" → CARET\n * normalizer.register(implicitMultRule); // \"2 x\" → \"2 * x\"\n * const normalized = normalizer.normalize(rawTokens);\n * ```\n */\nexport class TokenNormalizer {\n  /** Registered rules, unsorted, the source of truth. */\n  private rules: NormalizerRule[] = [];\n\n  /**\n   * Priority-sorted copy of {@link rules}, rebuilt lazily on the next\n   * {@link normalize} call after a mutation. Rules are registered once at\n   * engine/package-registration time and essentially never change during a\n   * session, but normalize() runs on every keystroke-driven evaluation, an\n   * earlier version re-sorted a fresh copy of `rules` on every single call,\n   * which meant every keystroke paid for an allocation + sort of a list that\n   * had usually not changed since the last one. `null` means \"stale, rebuild\n   * on next use\"; {@link register}/{@link unregister}/{@link clear} all\n   * invalidate it.\n   */\n  private sortedRulesCache: NormalizerRule[] | null = null;\n\n  /**\n   * Phrase trie for single-pass multi-word phrase fusion.\n   * Tried at each token position BEFORE other rules, the trie walk\n   * is O(depth) vs O(R × W) for separate rule matching.\n   */\n  private phraseTrie = new PhraseTrie();\n\n  /** Merged options with defaults applied. */\n  private options: Required<NormalizerOptions>;\n\n  // ── Constructor ──────────────────────────────────────────────────────────\n\n  /**\n   * @param options - Configuration overrides for safety limits and diagnostic callbacks\n   */\n  constructor(options: NormalizerOptions = {}) {\n    this.options = { ...DEFAULT_OPTIONS, ...options };\n  }\n\n  // ── Rule Management ──────────────────────────────────────────────────────\n\n  /**\n   * Register a normalization rule.\n   *\n   * Rules are sorted by priority (descending) on each {@link normalize} call.\n   * Multiple rules can share the same priority, they are tried in registration\n   * order when priorities are equal.\n   *\n   * @param rule - The rule to register\n   */\n  register(rule: NormalizerRule): void {\n    this.rules.push(rule);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Unregister a normalization rule by its {@link NormalizerRule.name | name}.\n   *\n   * If multiple rules share the same name, all are removed. This is safe to\n   * call with a name that doesn't match any rule, it simply has no effect.\n   *\n   * @param ruleName - The name of the rule to remove\n   */\n  unregister(ruleName: string): void {\n    this.rules = this.rules.filter(r => r.name !== ruleName);\n    this.sortedRulesCache = null;\n  }\n\n  /**\n   * Remove all registered rules, resetting the normalizer to its initial state.\n   * Also clears the phrase trie.\n   */\n  clear(): void {\n    this.rules = [];\n    this.sortedRulesCache = null;\n    this.phraseTrie = new PhraseTrie();\n  }\n\n  /**\n   * Priority-sorted view of {@link rules} (descending priority; registration\n   * order preserved for ties, since {@link Array.prototype.sort} is stable).\n   * Cached until the next mutation. See {@link sortedRulesCache}.\n   */\n  private getSortedRules(): NormalizerRule[] {\n    if (this.sortedRulesCache === null) {\n      this.sortedRulesCache = [...this.rules].sort((a, b) => b.priority - a.priority);\n    }\n    return this.sortedRulesCache;\n  }\n\n  /**\n   * Get the number of currently registered rules (excludes phrase trie entries).\n   */\n  get ruleCount(): number {\n    return this.rules.length;\n  }\n\n  // ── Phrase Registration ────────────────────────────────────────────────\n\n  /**\n   * Register a multi-word phrase for fusion into a single compound token.\n   *\n   * This is the preferred way to add phrase patterns. It inserts into the\n   * internal {@link PhraseTrie}, which collapses all phrase rules into a\n   * single O(depth) trie walk per position, no separate rule scanning.\n   *\n   * @param phrase    - Multi-word phrase (e.g., \"to the power of\", \"abyssal whip\")\n   * @param tokenType - Target token type after fusion (e.g., \"CARET\", \"ITEM\")\n   */\n  addPhrase(phrase: string, tokenType: string): void {\n    this.phraseTrie.addPhrase(phrase, tokenType);\n  }\n\n  /**\n   * Check whether a word can start any registered phrase.\n   *\n   * Used by {@link implicitMultiplyRule} to suppress `*` insertion\n   * before phrase-starting identifiers (e.g., \"2 power of 3\" → `2 ^ 3`,\n   * not `2 * power of 3`). Delegates to {@link PhraseTrie.canStart}.\n   */\n  /**\n   * Get all registered phrases and their target token types.\n   *\n   * Exposes the full phrase trie structure for diagnostic rendering\n   * in the playground's NormalizerTab. Returns ALL registered phrases,\n   * not just the ones that matched in the last evaluation.\n   */\n  getPhrases(): Record<string, string> {\n    return this.phraseTrie.getAllPhrases();\n  }\n\n  canStartPhrase(word: string): boolean {\n    return this.phraseTrie.canStart(word);\n  }\n\n  // ── Normalization ────────────────────────────────────────────────────────\n\n  /**\n   * Normalize a token stream by applying all registered rules.\n   *\n   * ## Algorithm\n   * Applies rules greedily left-to-right in multiple passes:\n   * 1. Sort rules by priority (descending)\n   * 2. Walk the token stream left to right\n   * 3. At each position, try rules in priority order\n   * 4. On match: consume matched tokens, insert replacements, restart from insert point\n   * 5. On no match: pass token through unchanged\n   * 6. Repeat until a full pass produces no changes, or maxPasses is reached\n   *\n   * ## Fusion tracking\n   * When a rule consumes more tokens than it produces, the normalizer calls\n   * `onFusion` with a {@link TokenFusion} record for diagnostic collection.\n   * This populates {@link NormalizerOutput.fusions} in the playground pipeline view.\n   *\n   * ## Safety\n   * If the normalized token count exceeds {@link NormalizerOptions.maxTokens},\n   * an Error is thrown to prevent memory exhaustion from runaway rule expansion.\n   *\n   * @param tokens   - Raw tokens from the lexer\n   * @param onFusion - Optional fusion callback (overrides {@link NormalizerOptions.onFusion})\n   * @returns Normalized tokens ready for parsing\n   * @throws {Error} If the normalized token count exceeds maxTokens\n   */\n  normalize(tokens: Token[], onFusion?: (fusion: TokenFusion) => void): Token[] {\n    // ── Early exit: nothing to normalize ──\n    if (tokens.length === 0) return tokens;\n\n    // ── Priority-sorted rules, cached across calls, see getSortedRules() ──\n    const sorted = this.getSortedRules();\n    const fusionHandler = onFusion ?? this.options.onFusion;\n    const maxPasses = this.options.maxPasses;\n    const maxTokens = this.options.maxTokens;\n\n    let current = tokens;\n    let changed = true;\n    let passCount = 0;\n\n    // Multi-pass loop: rules may trigger cascading matches across passes\n    while (changed && passCount < maxPasses) {\n      changed = false;\n      passCount++;\n\n      const result: Token[] = [];\n      let pos = 0;\n\n      // Single-pass left-to-right greedy walk\n      while (pos < current.length) {\n        let matched = false;\n\n        // ── Fast path: phrase trie (O(depth) single walk vs O(R × W) per rule) ──\n        // O(1) type-guard: skip trie entirely for tokens that can't start phrases.\n        // Flat Uint8Array indexed by typeId, no hashing, no Set lookup, true O(1).\n        const tid = current[pos].typeId;\n        if (tid >= NON_WORD_TABLE.length || NON_WORD_TABLE[tid] === 0) {\n          const trieMatch = this.phraseTrie.matchAt(current, pos);\n          if (trieMatch) {\n            const sourceTokens = current.slice(pos, pos + trieMatch.consumed);\n            for (const rt of trieMatch.replacement) {\n              result.push(rt);\n            }\n            if (trieMatch.consumed > 1 && trieMatch.replacement.length === 1) {\n              recordSourceSpan(trieMatch.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: trieMatch.ruleName ?? \"phrase-trie\",\n                sourceTokens,\n                fusedToken: trieMatch.replacement[0],\n              });\n            }\n            pos += trieMatch.consumed;\n            changed = true;\n            continue; // trie matched — skip other rules at this position (no need to set matched)\n          }\n        }\n\n        // Try every rule in priority order at this position\n        for (const rule of sorted) {\n          const match = rule.match(current, pos);\n          if (match) {\n            // Collect source tokens for fusion tracking\n            const sourceTokens = current.slice(pos, pos + match.consumed);\n\n            // Insert replacement tokens into result\n            for (const rt of match.replacement) {\n              result.push(rt);\n            }\n\n            // Track fusion events for diagnostics:\n            // - Multiple tokens → single token: classic fusion\n            // - Multiple tokens → fewer tokens: partial fusion\n            if (match.consumed > 1 && match.replacement.length === 1) {\n              recordSourceSpan(match.replacement[0], sourceTokens);\n              fusionHandler({\n                rule: rule.name,\n                sourceTokens,\n                fusedToken: match.replacement[0],\n              });\n            } else if (match.consumed > 1 && match.replacement.length < match.consumed) {\n              for (const rt of match.replacement) {\n                fusionHandler({\n                  rule: rule.name,\n                  sourceTokens,\n                  fusedToken: rt,\n                });\n              }\n            }\n\n            // Advance position past consumed tokens\n            pos += match.consumed;\n            changed = true;\n            matched = true;\n            break; // Rule matched — restart at new position with highest-priority rules\n          }\n        }\n\n        if (!matched) {\n          // No rule matched at this position, pass token through unchanged\n          result.push(current[pos]);\n          pos++;\n        }\n      }\n\n      // Safety: bail if token count explodes (runaway rule expansion)\n      if (result.length > maxTokens) {\n        // A raw Error here would bypass ThreeTierEvaluator's DAG-preservation\n        // enrichment on compile failure (it specifically checks for\n        // EngineError). Same reasoning as ExpressionEngineSafety.ts's\n        // complexity/length checks, which this mirrors.\n        throw ErrorFactory.validation(\n          \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n          `Normalized token count (${result.length}) exceeds safety limit (${maxTokens})`,\n          { tokenCount: result.length, maxTokens }\n        );\n      }\n\n      current = result;\n    }\n\n    return current;\n  }\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * PhraseTrie, optimized word-level trie for multi-word phrase fusion.\n *\n * ## Problem\n * The normalizer previously applied N separate `phraseFusionRule` instances,\n * each scanning forward from the current token position. For R phrase rules\n * and W average phrase length, this cost O(N × R × W) per pass.\n *\n * ## Solution\n * A single trie walk per position collapses all phrase rules into O(D)\n * where D ≤ longest phrase depth (typically ≤ 5 words). The trie tracks\n * the deepest terminal node reached, implementing longest-match-wins\n * without priority sorting.\n *\n * ## Optimizations\n * 1. **Set<string> quick-reject**, the `startWords` set contains the first\n *    word of every registered phrase. At each position, if the token's\n *    lowercase value isn't in the set, we bail in O(1) without touching\n *    the trie. ~80% of tokens (numbers, operators) hit this fast path.\n * 2. **Longest-match-wins**, the `matchAt()` walk continues past terminal\n *    nodes, tracking the deepest one. Shorter overlapping phrases (e.g.,\n *    \"power of\") don't need lower priority, the trie naturally prefers\n *    the longer match.\n * 3. **Map-based children**, `Map<string, TrieNode>` gives O(1) amortized\n *    child lookup per word, faster than array scanning for sparse branches.\n *\n * ## Package integration\n * Packages add phrases via {@link TokenNormalizer.addPhrase} (public API)\n * or the {@link IEnginePackage.phrases} declarative field. Each call to\n * `addPhrase()` inserts the phrase into this trie and updates `startWords`.\n *\n * @module PhraseTrie\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport type { NormalizerMatch } from \"./NormalizerRule\";\nimport { createFusedToken } from \"./TokenNormalizer\";\n\n//#endregion\n//#region ─── TrieNode ─────────────────────────────────────────────────────────\n\n/**\n * Internal trie node.\n *\n * Each node represents a matched word in a phrase. The path from root\n * to a node spells out a partial or complete phrase.\n */\ninterface TrieNode {\n\t/** Child nodes keyed by next word (all lowercase). */\n\tchildren: Map<string, TrieNode>;\n\t/**\n\t * If this node completes a phrase, the terminal metadata.\n\t * A node can be both terminal AND have children. This handles\n\t * overlapping phrases like \"power of\" and \"to the power of\".\n\t */\n\tterminal: TrieTerminal | null;\n}\n\n/** Metadata stored at terminal nodes for deferred token creation. */\ninterface TrieTerminal {\n\t/** The target token type after fusion (e.g., \"CARET\", \"TIMES_BY\"). */\n\ttokenType: string;\n\t/** The original phrase string (e.g., \"to the power of\"). */\n\tphrase: string;\n\t/** Number of tokens consumed by this phrase. */\n\tconsumed: number;\n}\n\n//#endregion\n//#region ─── PhraseTrie ─────────────────────────────────────────────────────\n\n/**\n * Word-level trie for single-pass multi-word phrase matching.\n *\n * @example\n * ```ts\n * const trie = new PhraseTrie();\n * trie.addPhrase(\"to the power of\", \"CARET\");\n * trie.addPhrase(\"power of\", \"CARET\");\n * trie.addPhrase(\"abyssal whip\", \"ITEM\");\n *\n * // At position 0 with tokens [\"to\",\"the\",\"power\",\"of\",\"3\"]\n * const match = trie.matchAt(tokens, 0);\n * // → { consumed: 4, replacement: [CARET(\"to the power of\")] }\n * ```\n */\nexport class PhraseTrie {\n\t/**\n\t * First words that can start any registered phrase (all lowercase).\n\t * O(1) quick-reject: if `tokens[pos].value.toLowerCase()` isn't here,\n\t * no phrase can match at this position.\n\t */\n\tprivate startWords = new Set<string>();\n\n\t/**\n\t * Root maps first word → child node.\n\t * Two-level root avoids an unnecessary intermediate TrieNode.\n\t */\n\tprivate root = new Map<string, TrieNode>();\n\n\t// ── Registration ──────────────────────────────────────────────────────\n\n\t/**\n\t * Register a phrase for fusion into a single compound token.\n\t *\n\t * @param phrase    - Multi-word phrase (e.g., \"to the power of\")\n\t * @param tokenType - Target token type after fusion (e.g., \"CARET\")\n\t */\n\taddPhrase(phrase: string, tokenType: string): void {\n\t\tconst words = phrase.toLowerCase().trim().split(/\\s+/);\n\t\tif (words.length === 0 || words[0] === \"\") return;\n\n\t\tthis.startWords.add(words[0]);\n\n\t\tconst firstWord = words[0];\n\t\tlet node: TrieNode;\n\n\t\tif (this.root.has(firstWord)) {\n\t\t\tnode = this.root.get(firstWord)!;\n\t\t} else {\n\t\t\tnode = { children: new Map(), terminal: null };\n\t\t\tthis.root.set(firstWord, node);\n\t\t}\n\n\t\t// Single-word phrase: terminal at root's child\n\t\tif (words.length === 1) {\n\t\t\tnode.terminal = { tokenType, phrase, consumed: 1 };\n\t\t\treturn;\n\t\t}\n\n\t\t// Walk/insert remaining words\n\t\tfor (let i = 1; i < words.length; i++) {\n\t\t\tconst word = words[i];\n\t\t\tif (!node.children.has(word)) {\n\t\t\t\tnode.children.set(word, { children: new Map(), terminal: null });\n\t\t\t}\n\t\t\tnode = node.children.get(word)!;\n\t\t}\n\n\t\tnode.terminal = { tokenType, phrase, consumed: words.length };\n\t}\n\n\t// ── Matching ──────────────────────────────────────────────────────────\n\n\t/**\n\t * Attempt to match a phrase starting at `pos` in the token stream.\n\t *\n\t * Walks the trie one token at a time, tracking the deepest terminal\n\t * node reached. Returns the longest match found, or `null` if no\n\t * phrase starts at this position.\n\t *\n\t * @param tokens - The current token stream\n\t * @param pos    - Position to attempt matching from\n\t * @returns The longest {@link NormalizerMatch}, or `null` on no match\n\t */\n\tmatchAt(tokens: Token[], pos: number): NormalizerMatch | null {\n\t\t// ── Bounds guard ──\n\t\tif (pos >= tokens.length) return null;\n\n\t\t// ── O(1) quick-reject: first word not a phrase starter ──\n\t\tconst firstWord = tokens[pos].value.toLowerCase();\n\t\tif (!this.startWords.has(firstWord)) return null;\n\n\t\t// ── Walk trie, tracking deepest terminal ──\n\t\tlet node: TrieNode | undefined = this.root.get(firstWord);\n\t\tif (!node) return null;\n\n\t\tlet best: NormalizerMatch | null = null;\n\t\tlet depth = 1;\n\n\t\t// Check single-word phrase at first node\n\t\tif (node.terminal) {\n\t\t\tconst sourceTokens = tokens.slice(pos, pos + 1);\n\t\t\tbest = {\n\t\t\t\tconsumed: 1,\n\t\t\t\treplacement: [createFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens)],\n\t\t\t\truleName: node.terminal.phrase,\n\t\t\t};\n\t\t}\n\n\t\t// Walk deeper for multi-word phrases\n\t\tfor (let i = pos + 1; i < tokens.length && node?.children; i++) {\n\t\t\tconst word = tokens[i].value.toLowerCase();\n\t\t\tnode = node.children.get(word);\n\t\t\tif (!node) break; // dead end\n\t\t\tdepth++;\n\n\t\t\tif (node.terminal) {\n\t\t\t\t// Deferred fused-token creation, only on deepest match found\n\t\t\t\tconst sourceTokens = tokens.slice(pos, pos + depth);\n\t\t\t\tbest = {\n\t\t\t\t\tconsumed: depth,\n\t\t\t\t\treplacement: [\n\t\t\t\t\t\tcreateFusedToken(node.terminal.tokenType, node.terminal.phrase, sourceTokens),\n\t\t\t\t\t],\n\t\t\t\t\truleName: node.terminal.phrase,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn best;\n\t}\n\n\t// ── Introspection ─────────────────────────────────────────────────────\n\n\t/** Number of unique first words (not total phrases). */\n\tget size(): number {\n\t\treturn this.root.size;\n\t}\n\n\t/**\n\t * Return all registered phrases and their target token types.\n\t *\n\t * Used by diagnostic mode to expose the complete trie structure to the\n\t * playground's NormalizerTab for rendering ALL registered phrases\n\t * (not just the ones that matched in this evaluation).\n\t */\n\tgetAllPhrases(): Record<string, string> {\n\t\tconst result: Record<string, string> = {};\n\n\t\tconst collect = (node: TrieNode, path: string[]): void => {\n\t\t\tif (node.terminal) {\n\t\t\t\tresult[path.join(' ')] = node.terminal.tokenType;\n\t\t\t}\n\t\t\tfor (const [word, child] of node.children) {\n\t\t\t\tcollect(child, [...path, word]);\n\t\t\t}\n\t\t};\n\n\t\tfor (const [firstWord, node] of this.root) {\n\t\t\tcollect(node, [firstWord]);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/** Check if any phrase starts with this word (case-insensitive). */\n\tcanStart(word: string): boolean {\n\t\treturn this.startWords.has(word.toLowerCase());\n\t}\n}\n\n//#endregion\n","//#region ─── Module Overview ───────────────────────────────────────────────────\n\n/**\n * Built-in normalization rules for the {@link TokenNormalizer}.\n *\n * These rules handle common expression patterns that span multiple tokens.\n * Phrase fusion (e.g., \"to the power of\" → CARET) is handled by the\n * internal {@link PhraseTrie}. See {@link TokenNormalizer.addPhrase}.\n * This module only exports non-phrase rules like {@link implicitMultiplyRule}.\n *\n * @module BuiltinNormalizerRules\n */\n\n//#endregion\n//#region ─── Imports ──────────────────────────────────────────────────────────\n\nimport type { Token } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { LexerToken } from \"@solve-js/lexer/ExpressionLexer\";\nimport type { NormalizerRule, NormalizerMatch } from \"./NormalizerRule\";\n\n//#endregion\n//#region ─── PHRASE_START_WORDS, Implicit Multiply Guard ─────────────────────\n\n/**\n * Words that can start multi-word phrases, hardcoded fallback.\n *\n * This is ONLY used as the default fallback in {@link implicitMultiplyRule}\n * when no `canStart` predicate is provided. In the recommended pattern,\n * the {@link PhraseTrie}'s live `canStart()` set is passed instead, keeping\n * the guard in sync with package-registered phrases.\n *\n * @see {@link TokenNormalizer.canStartPhrase}\n */\nconst PHRASE_START_WORDS = new Set([\n  \"to\", \"power\", \"increase\", \"decrease\", \"times\", \"multiply\", \"divide\", \"by\",\n]);\n\n//#endregion\n//#region ─── implicitMultiplyRule, Implicit Operator Insertion ────────────────\n\n/**\n * Creates a normalization rule that inserts an implicit multiplication operator\n * between adjacent tokens where multiplication is implied.\n *\n * ## When it fires\n * Inserts a STAR token between:\n * - `NUMBER IDENT` (e.g., \"2 x\" → \"2 * x\")\n * - `RPAREN IDENT` (e.g., \"(x+1)y\" → \"(x+1) * y\")\n * - `NUMBER LPAREN` (e.g., \"2(x+1)\" → \"2 * (x+1)\")\n * - `NUMBER PI` / `NUMBER E` (e.g., \"2π\" → \"2 * π\")\n *\n * ## When it doesn't fire\n * - When the following identifier starts a multi-word phrase\n *   (checked against {@link PHRASE_START_WORDS})\n * - When the following token is not an identifier or parenthesized expression\n *\n * ## Priority\n * Default priority is 50, below phrase fusion so phrases match first.\n *\n * @param priority - Rule priority (default 50)\n * @returns A {@link NormalizerRule} that inserts implicit multiply operators\n */\nexport function implicitMultiplyRule(\n\tpriority: number = 50,\n\tcanStart?: (word: string) => boolean\n): NormalizerRule {\n\tconst phraseGuard = canStart ?? ((word: string) => PHRASE_START_WORDS.has(word.toLowerCase()));\n\n\treturn {\n    name: \"implicit:multiply\",\n    priority,\n    match(tokens: Token[], pos: number): NormalizerMatch | null {\n      // ── Need at least one token after the current position ──\n      if (pos + 1 >= tokens.length) return null;\n\n      const t = tokens[pos];\n      const next = tokens[pos + 1];\n\n      // ── Guard: suppress if the next identifier starts a phrase ──\n      // Uses the trie's canStart when available, falls back to hardcoded set.\n      // This prevents \"2 power of 3\" from becoming \"2 * power of 3\".\n      const nextValue = next.value.toLowerCase();\n      if (phraseGuard(nextValue)) return null;\n\n      // ── Check trigger conditions ──\n      const triggers =\n        (t.type === \"NUMBER\" || t.type === \"RPAREN\") &&\n        (next.type === \"IDENT\" || next.type === \"LPAREN\" || next.type === \"PI\" || next.type === \"E\");\n\n      if (!triggers) return null;\n\n      // ── Insert a STAR token at the next token's position ──\n      const starToken = new LexerToken(\n        \"STAR\", tokenTypeId(\"STAR\"), \"*\", \"*\",\n        next.offset, 0, next.line, next.col,\n      );\n\n      // consumed = 1: only the current token is replaced with [current, STAR]\n      // The next token is NOT consumed, it stays for the next iteration\n      return { consumed: 1, replacement: [t, starToken] };\n    },\n  };\n}\n\n//#endregion\n//#region ─── isInsideRangeContext, Bracket/Call-Paren Context Guard ───────────\n\n/**\n * Whether token `pos` sits inside a context where a bare `NUMBER:NUMBER`\n * sequence means a Range, not a clock-time/laptime/video-timecode literal:\n * a matrix literal/index/slice (`[1,2,3]`, `a[0:3]`), OR a `map`/`reduce`/\n * `sum`/`prod` call's own argument-list parens (`map(f, 0:3)`, these\n * accept a bare Range argument directly, per the Calca spec's own\n * example). Scans backward from `pos` over the CURRENT pass's token array,\n * tracking `[`/`(` nesting depth, the same \"positional guard via\n * backward scan\" idiom already used elsewhere in this normalizer layer\n * (e.g. `LineRefNormalizerRule`'s previous-token check), generalized to\n * depth-tracking. An `LBRACKET` is unconditionally a range-safe opener; an\n * `LPAREN` is range-safe ONLY when immediately preceded by MAP/REDUCE/\n * SUM_FN/PROD_FN, an ordinary grouping/function-call paren is NOT, so\n * `(9:00) + 5` still means a clock time, not a range.\n *\n * Needed because the clock-time/laptime/video-timecode rules each match a\n * bare `NUMBER COLON NUMBER...` shape with ZERO context-awareness, a real\n * collision discovered when adding Range support, since e.g. \"0:3\" is\n * valid input to BOTH features. These contexts have no legitimate use for\n * a clock-time/laptime/timecode literal, so the carve-out costs the time\n * features nothing.\n *\n * IMPORTANT cross-pass-timing gotcha (a real bug found and fixed here,\n * not a hypothetical): the `LPAREN`-opener check deliberately tests the\n * RAW word text (`prev.value.toLowerCase()`), not `prev.type ===\n * \"MAP\"/\"REDUCE\"/...`. The normalizer's multi-pass loop hands every rule\n * the SAME frozen `tokens` snapshot for an entire pass, a rule scanning\n * a LATER position in that pass cannot see a fusion `mapReduceCallNormalizerRule`\n * performs at an EARLIER position in that SAME pass (fusion results only\n * become visible to other rules starting the NEXT pass). Checking the\n * fused token type here would miss exactly the case that matters most\n * `map(f, 0:3)` on its very first normalization pass, silently letting\n * `0:3` fuse into a clock time before `map(`'s own fusion ever lands.\n * Testing the raw word is immune to this: it's true from the very first\n * pass, regardless of whether `mapReduceCallNormalizerRule` has run yet.\n * (`LBRACKET` above has no equivalent issue, it's a genuine lexer token\n * from the start, never itself the product of a fusion.)\n */\nexport function isInsideRangeContext(tokens: Token[], pos: number): boolean {\n  const safeStack: boolean[] = [];\n  for (let i = 0; i < pos; i++) {\n    const t = tokens[i];\n    if (t.type === \"LBRACKET\") {\n      safeStack.push(true);\n    } else if (t.type === \"LPAREN\") {\n      const prev = tokens[i - 1];\n      const opensMapReduceCall = !!prev && (\n        prev.type === \"MAP\" || prev.type === \"REDUCE\" || prev.type === \"SUM_FN\" || prev.type === \"PROD_FN\" ||\n        (prev.type === \"IDENT\" && (prev.value.toLowerCase() === \"map\" || prev.value.toLowerCase() === \"reduce\" || prev.value.toLowerCase() === \"sum\" || prev.value.toLowerCase() === \"prod\"))\n      );\n      safeStack.push(opensMapReduceCall);\n    } else if (t.type === \"RBRACKET\" || t.type === \"RPAREN\") {\n      safeStack.pop();\n    }\n  }\n  return safeStack.length > 0 && safeStack[safeStack.length - 1];\n}\n\n//#endregion\n//#region ─── createBuiltinNormalizerRules, All Built-in Rules ─────────────────\n\n/**\n * Creates built-in non-phrase normalization rules.\n *\n * Returns implicit multiply insertion (priority 50).\n *\n * **Prefer** calling {@link implicitMultiplyRule} directly with a\n * `canStart` predicate wired to the normalizer's phrase trie:\n * ```ts\n * normalizer.register(implicitMultiplyRule(50, (w) => normalizer.canStartPhrase(w)));\n * ```\n * Without the predicate, this function falls back to a hardcoded\n * {@link PHRASE_START_WORDS} set that won't reflect package-registered phrases.\n *\n * @returns An array of {@link NormalizerRule} instances ready for registration\n */\nexport function createBuiltinNormalizerRules(): NormalizerRule[] {\n  return [\n    // ── Implicit operator insertion (priority 50) ──\n    implicitMultiplyRule(),\n  ];\n}\n\n/**\n * Built-in phrase → tokenType mappings.\n *\n * These are registered into the engine's {@link PhraseTrie} during\n * construction. Tests that create a standalone {@link TokenNormalizer}\n * should register these via {@link TokenNormalizer.addPhrase}.\n */\nexport const BUILTIN_PHRASES: Record<string, string> = {\n\t\"to the power of\": \"CARET\",\n\t\"power of\": \"CARET\",\n\t\"increase by\": \"INCREASE_BY\",\n\t\"decrease by\": \"DECREASE_BY\",\n\t\"times by\": \"TIMES_BY\",\n\t\"multiply by\": \"MULTIPLY_BY\",\n\t\"divide by\": \"DIVIDE_BY\",\n};\n\n//#endregion\n"]}

package/dist/chunk-OT6OJY7C.cjs

@@ -1,114 +0,0 @@
-'use strict';
-
-// src/uom/CurrencyAliases.ts
-var CURRENCY_SYMBOL_ALIASES = {
-  "$": "USD",
-  "\xA3": "GBP",
-  "\u20AC": "EUR",
-  // ¥ is genuinely ambiguous between JPY and CNY in real-world usage, JPY
-  // is the conventional default (matches Numi/most calculator apps' own
-  // choice); a user wanting CNY specifically can still type "CNY" directly.
-  "\xA5": "JPY",
-  "\u20BD": "RUB",
-  "\u20A9": "KRW",
-  "\u20B9": "INR",
-  "\u20BA": "TRY",
-  "\u20B4": "UAH",
-  "\u20AA": "ILS",
-  "\u20AB": "VND",
-  "\u20A6": "NGN",
-  "\u20B1": "PHP"
-};
-var CURRENCY_WORD_ALIASES = {
-  dollar: "USD",
-  dollars: "USD",
-  euro: "EUR",
-  euros: "EUR",
-  yen: "JPY",
-  ruble: "RUB",
-  rubles: "RUB",
-  rouble: "RUB",
-  roubles: "RUB",
-  won: "KRW",
-  rupee: "INR",
-  rupees: "INR",
-  yuan: "CNY",
-  renminbi: "CNY",
-  franc: "CHF",
-  francs: "CHF",
-  rand: "ZAR",
-  krona: "SEK",
-  kronor: "SEK",
-  krone: "NOK",
-  kroner: "NOK",
-  real: "BRL",
-  reais: "BRL",
-  peso: "MXN",
-  pesos: "MXN",
-  shekel: "ILS",
-  shekels: "ILS",
-  lira: "TRY",
-  hryvnia: "UAH",
-  hryvnias: "UAH",
-  zloty: "PLN",
-  zlotys: "PLN",
-  forint: "HUF",
-  koruna: "CZK",
-  dirham: "AED",
-  dirhams: "AED",
-  riyal: "SAR",
-  riyals: "SAR",
-  rial: "SAR",
-  rials: "SAR",
-  ringgit: "MYR",
-  rupiah: "IDR",
-  baht: "THB",
-  dong: "VND",
-  naira: "NGN"
-};
-function resolveCurrencyAlias(text) {
-  return CURRENCY_SYMBOL_ALIASES[text] ?? CURRENCY_WORD_ALIASES[text.toLowerCase()];
-}
-var CURRENCY_DISPLAY = {
-  USD: { symbol: "$", position: "prefix", spaced: false },
-  AUD: { symbol: "$", position: "prefix", spaced: false },
-  CAD: { symbol: "$", position: "prefix", spaced: false },
-  NZD: { symbol: "$", position: "prefix", spaced: false },
-  HKD: { symbol: "$", position: "prefix", spaced: false },
-  SGD: { symbol: "$", position: "prefix", spaced: false },
-  MXN: { symbol: "$", position: "prefix", spaced: false },
-  GBP: { symbol: "\xA3", position: "prefix", spaced: false },
-  // English-language convention (€100.00), many EU locales instead suffix
-  // with a space ("100,00 €"); this engine's default locale is "en", so
-  // the English convention was chosen. A locale-aware override would be a
-  // reasonable future extension, not attempted here.
-  EUR: { symbol: "\u20AC", position: "prefix", spaced: false },
-  JPY: { symbol: "\xA5", position: "prefix", spaced: false },
-  CNY: { symbol: "\xA5", position: "prefix", spaced: false },
-  KRW: { symbol: "\u20A9", position: "prefix", spaced: false },
-  INR: { symbol: "\u20B9", position: "prefix", spaced: false },
-  // Russian convention places the ruble sign AFTER the amount, with a space.
-  RUB: { symbol: "\u20BD", position: "suffix", spaced: true },
-  TRY: { symbol: "\u20BA", position: "prefix", spaced: false },
-  UAH: { symbol: "\u20B4", position: "suffix", spaced: true },
-  ILS: { symbol: "\u20AA", position: "prefix", spaced: false },
-  // Vietnamese convention: no space, symbol after the amount.
-  VND: { symbol: "\u20AB", position: "suffix", spaced: false },
-  NGN: { symbol: "\u20A6", position: "prefix", spaced: false },
-  PHP: { symbol: "\u20B1", position: "prefix", spaced: false },
-  BRL: { symbol: "R$", position: "prefix", spaced: false },
-  ZAR: { symbol: "R", position: "prefix", spaced: false },
-  // Scandinavian convention: amount then "kr", space-separated.
-  SEK: { symbol: "kr", position: "suffix", spaced: true },
-  NOK: { symbol: "kr", position: "suffix", spaced: true },
-  DKK: { symbol: "kr", position: "suffix", spaced: true },
-  PLN: { symbol: "z\u0142", position: "suffix", spaced: true },
-  CHF: { symbol: "Fr", position: "suffix", spaced: true },
-  HUF: { symbol: "Ft", position: "suffix", spaced: true },
-  CZK: { symbol: "K\u010D", position: "suffix", spaced: true }
-};
-
-exports.CURRENCY_DISPLAY = CURRENCY_DISPLAY;
-exports.resolveCurrencyAlias = resolveCurrencyAlias;
-//# sourceMappingURL=chunk-OT6OJY7C.cjs.map
-//# sourceMappingURL=chunk-OT6OJY7C.cjs.map

package/dist/chunk-OT6OJY7C.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/uom/CurrencyAliases.ts"],"names":[],"mappings":";;;AAwBO,IAAM,uBAAA,GAAkD;AAAA,EAC7D,GAAA,EAAK,KAAA;AAAA,EACL,MAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA;AAAA;AAAA;AAAA,EAIL,MAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK,KAAA;AAAA,EACL,QAAA,EAAK;AACP,CAAA;AAuCO,IAAM,qBAAA,GAAgD;AAAA,EAC3D,MAAA,EAAQ,KAAA;AAAA,EAAO,OAAA,EAAS,KAAA;AAAA,EACxB,IAAA,EAAM,KAAA;AAAA,EAAO,KAAA,EAAO,KAAA;AAAA,EACpB,GAAA,EAAK,KAAA;AAAA,EACL,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EAAO,OAAA,EAAS,KAAA;AAAA,EACrD,GAAA,EAAK,KAAA;AAAA,EACL,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EACtB,IAAA,EAAM,KAAA;AAAA,EAAO,QAAA,EAAU,KAAA;AAAA,EACvB,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EACtB,IAAA,EAAM,KAAA;AAAA,EACN,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EACtB,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EACtB,IAAA,EAAM,KAAA;AAAA,EAAO,KAAA,EAAO,KAAA;AAAA,EACpB,IAAA,EAAM,KAAA;AAAA,EAAO,KAAA,EAAO,KAAA;AAAA,EACpB,MAAA,EAAQ,KAAA;AAAA,EAAO,OAAA,EAAS,KAAA;AAAA,EACxB,IAAA,EAAM,KAAA;AAAA,EACN,OAAA,EAAS,KAAA;AAAA,EAAO,QAAA,EAAU,KAAA;AAAA,EAC1B,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EACtB,MAAA,EAAQ,KAAA;AAAA,EACR,MAAA,EAAQ,KAAA;AAAA,EACR,MAAA,EAAQ,KAAA;AAAA,EAAO,OAAA,EAAS,KAAA;AAAA,EACxB,KAAA,EAAO,KAAA;AAAA,EAAO,MAAA,EAAQ,KAAA;AAAA,EAAO,IAAA,EAAM,KAAA;AAAA,EAAO,KAAA,EAAO,KAAA;AAAA,EACjD,OAAA,EAAS,KAAA;AAAA,EACT,MAAA,EAAQ,KAAA;AAAA,EACR,IAAA,EAAM,KAAA;AAAA,EACN,IAAA,EAAM,KAAA;AAAA,EACN,KAAA,EAAO;AACT,CAAA;AASO,SAAS,qBAAqB,IAAA,EAAkC;AACrE,EAAA,OAAO,wBAAwB,IAAI,CAAA,IAAK,qBAAA,CAAsB,IAAA,CAAK,aAAa,CAAA;AAClF;AA4BO,IAAM,gBAAA,GAAwD;AAAA,EACnE,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,QAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA,EAKtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,QAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,QAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA;AAAA,EAEtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACrD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACrD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA;AAAA,EAEtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,UAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA,EACvD,KAAK,EAAE,MAAA,EAAQ,KAAK,QAAA,EAAU,QAAA,EAAU,QAAQ,KAAA,EAAM;AAAA;AAAA,EAEtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,WAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA,EAAK;AAAA,EACtD,KAAK,EAAE,MAAA,EAAQ,WAAM,QAAA,EAAU,QAAA,EAAU,QAAQ,IAAA;AACnD","file":"chunk-OT6OJY7C.cjs","sourcesContent":["/**\n * Currency symbol/word → ISO 4217 code aliases, and the reverse table used\n * for display formatting (see `format/FormatEngine.ts`'s `formatUom()`).\n *\n * Single source of truth for BOTH directions so the same ambiguity\n * decisions (documented inline below) aren't made twice, inconsistently,\n * in two different files.\n */\n\n/**\n * Currency SYMBOLS (non-alphanumeric characters), safe to recognize as\n * bare lexer tokens with zero risk of colliding with a variable name,\n * since `:name = expr` variable names can never be symbol characters.\n * `CurrencySymbolParselet.ts` consumes these directly.\n *\n * `¥`/`₱`/`peso` ambiguity note: the PESO SIGN (₱) is, per Unicode, the\n * Philippine peso specifically, but the WORD \"peso\" (see\n * `CURRENCY_WORD_ALIASES` below) defaults to the Mexican peso, the most\n * globally recognized \"peso\" in English financial writing. This is a\n * deliberate inconsistency between the symbol and the word for the same\n * general concept, same reasoning as `¥` (JPY) vs \"yuan\" (CNY) below\n * document rather than silently guess, and a user wanting the other one\n * can always type the ISO code directly (\"PHP\"/\"CNY\").\n */\nexport const CURRENCY_SYMBOL_ALIASES: Record<string, string> = {\n  \"$\": \"USD\",\n  \"£\": \"GBP\",\n  \"€\": \"EUR\",\n  // ¥ is genuinely ambiguous between JPY and CNY in real-world usage, JPY\n  // is the conventional default (matches Numi/most calculator apps' own\n  // choice); a user wanting CNY specifically can still type \"CNY\" directly.\n  \"¥\": \"JPY\",\n  \"₽\": \"RUB\",\n  \"₩\": \"KRW\",\n  \"₹\": \"INR\",\n  \"₺\": \"TRY\",\n  \"₴\": \"UAH\",\n  \"₪\": \"ILS\",\n  \"₫\": \"VND\",\n  \"₦\": \"NGN\",\n  \"₱\": \"PHP\",\n};\n\n/**\n * Currency WORD forms (singular/plural, all lowercase. This codebase's\n * unit table is strictly case-sensitive with no aliasing, so \"Euro\"/\"EURO\"\n * are deliberately NOT recognized, matching every other word-unit here).\n * Registered as `UNIT` tokens (see `lexer/units.ts`) rather than bare\n * keywords: a bare keyword can never be a `:variableName` (this codebase's\n * tested, intentional policy. See `VariableParselet.ts`'s doc comment)\n * but `:dollar = 5` etc. must keep working, and UNIT-typed tokens ARE\n * accepted as variable names (e.g. \":b = 5\" already works for the \"b\" bits\n * unit), so these ride the same safe mechanism `workday`/`workdays` used.\n *\n * Deliberately NOT included: \"pound\"/\"pounds\", already a MASS unit in\n * `lexer/units.ts` (450g, matching \"lb\"). Remapping it to GBP would be a\n * real, silent regression for anyone using \"5 pounds\" to mean weight; GBP\n * stays reachable via the £ symbol or the \"GBP\" code, same as before.\n *\n * Deliberately NOT included: \"dinar\", used by ~10 countries (Kuwaiti\n * Bahraini, Jordanian, Iraqi, Algerian, ... dinars) with wildly different\n * values (a Kuwaiti dinar is worth roughly 1000x an Algerian one), no\n * single default is defensible the way ¥→JPY or peso→MXN are. Type the\n * ISO code directly (KWD/BHD/JOD/...).\n *\n * Ambiguous-but-resolved cases, and why:\n * - \"peso\"/\"pesos\" → MXN (Mexican peso is the most globally recognized\n *   \"peso\" in English financial writing). See the ₱ symbol note above\n *   for why this deliberately differs from the ₱ SYMBOL's PHP mapping.\n * - \"franc\"/\"francs\" → CHF (Swiss franc; also used by several African\n *   currencies, CHF is the overwhelmingly dominant \"franc\" in English use).\n * - \"krona\"/\"kronor\" → SEK (Swedish); \"krone\"/\"kroner\" → NOK (Norwegian)\n *   Danish also uses \"krone\" (DKK) with the identical spelling as\n *   Norwegian; NOK was picked arbitrarily as the more commonly-referenced\n *   of the two in English text. Type \"DKK\" directly for Danish krone.\n * - \"riyal\"/\"riyals\"/\"rial\"/\"rials\" → SAR (Saudi riyal), both spellings\n *   also refer to Qatari/Omani riyals and the Iranian rial; SAR is the\n *   most commonly referenced in English. Type \"QAR\"/\"OMR\"/\"IRR\" directly\n *   for the others.\n */\nexport const CURRENCY_WORD_ALIASES: Record<string, string> = {\n  dollar: \"USD\", dollars: \"USD\",\n  euro: \"EUR\", euros: \"EUR\",\n  yen: \"JPY\",\n  ruble: \"RUB\", rubles: \"RUB\", rouble: \"RUB\", roubles: \"RUB\",\n  won: \"KRW\",\n  rupee: \"INR\", rupees: \"INR\",\n  yuan: \"CNY\", renminbi: \"CNY\",\n  franc: \"CHF\", francs: \"CHF\",\n  rand: \"ZAR\",\n  krona: \"SEK\", kronor: \"SEK\",\n  krone: \"NOK\", kroner: \"NOK\",\n  real: \"BRL\", reais: \"BRL\",\n  peso: \"MXN\", pesos: \"MXN\",\n  shekel: \"ILS\", shekels: \"ILS\",\n  lira: \"TRY\",\n  hryvnia: \"UAH\", hryvnias: \"UAH\",\n  zloty: \"PLN\", zlotys: \"PLN\",\n  forint: \"HUF\",\n  koruna: \"CZK\",\n  dirham: \"AED\", dirhams: \"AED\",\n  riyal: \"SAR\", riyals: \"SAR\", rial: \"SAR\", rials: \"SAR\",\n  ringgit: \"MYR\",\n  rupiah: \"IDR\",\n  baht: \"THB\",\n  dong: \"VND\",\n  naira: \"NGN\",\n};\n\n/**\n * Resolve a raw lexed unit/symbol string to its canonical ISO 4217 code\n * e.g. `\"euro\"` -> `\"EUR\"`, `\"$\"` -> `\"USD\"`, `\"USD\"` -> `\"USD\"` (already\n * canonical, returned unchanged). Returns `undefined` if `text` isn't a\n * recognized currency alias at all (distinct from \"already canonical\"\n * callers should fall back to the original text in that case).\n */\nexport function resolveCurrencyAlias(text: string): string | undefined {\n  return CURRENCY_SYMBOL_ALIASES[text] ?? CURRENCY_WORD_ALIASES[text.toLowerCase()];\n}\n\n/** How a currency's amount and symbol are conventionally arranged for display. */\nexport interface CurrencyDisplayInfo {\n  /** The symbol/abbreviation to render, e.g. \"$\", \"kr\", \"R$\". */\n  readonly symbol: string;\n  /** Whether the symbol comes before or after the formatted amount. */\n  readonly position: \"prefix\" | \"suffix\";\n  /** Whether a space separates the symbol from the amount. */\n  readonly spaced: boolean;\n}\n\n/**\n * Display convention per ISO code, for currencies with a widely-recognized\n * symbol/abbreviation and an unambiguous placement convention. NOT\n * exhaustive, any code absent here (most of the ~150 codes\n * `CurrencyExchange.isCurrency()` recognizes) falls back to the existing\n * \"amount CODE\" format (e.g. \"100.00 AED\") in `FormatEngine.formatUom()`,\n * exactly as before this table existed. Extend as needed, same pattern as\n * this session's other \"not exhaustive, additive\" tables (city timezones,\n * ingredient densities).\n *\n * Several currencies share the same symbol (USD/AUD/CAD/NZD/HKD/SGD/MXN\n * all conventionally use \"$\" locally). This is safe here because OUTPUT\n * formatting always starts from an already-resolved, unambiguous ISO code\n * (`value.unit`), unlike INPUT parsing where a bare \"$\" genuinely is\n * ambiguous (see `CURRENCY_SYMBOL_ALIASES`'s USD default above).\n */\nexport const CURRENCY_DISPLAY: Record<string, CurrencyDisplayInfo> = {\n  USD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  AUD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  CAD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  NZD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  HKD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  SGD: { symbol: \"$\", position: \"prefix\", spaced: false },\n  MXN: { symbol: \"$\", position: \"prefix\", spaced: false },\n  GBP: { symbol: \"£\", position: \"prefix\", spaced: false },\n  // English-language convention (€100.00), many EU locales instead suffix\n  // with a space (\"100,00 €\"); this engine's default locale is \"en\", so\n  // the English convention was chosen. A locale-aware override would be a\n  // reasonable future extension, not attempted here.\n  EUR: { symbol: \"€\", position: \"prefix\", spaced: false },\n  JPY: { symbol: \"¥\", position: \"prefix\", spaced: false },\n  CNY: { symbol: \"¥\", position: \"prefix\", spaced: false },\n  KRW: { symbol: \"₩\", position: \"prefix\", spaced: false },\n  INR: { symbol: \"₹\", position: \"prefix\", spaced: false },\n  // Russian convention places the ruble sign AFTER the amount, with a space.\n  RUB: { symbol: \"₽\", position: \"suffix\", spaced: true },\n  TRY: { symbol: \"₺\", position: \"prefix\", spaced: false },\n  UAH: { symbol: \"₴\", position: \"suffix\", spaced: true },\n  ILS: { symbol: \"₪\", position: \"prefix\", spaced: false },\n  // Vietnamese convention: no space, symbol after the amount.\n  VND: { symbol: \"₫\", position: \"suffix\", spaced: false },\n  NGN: { symbol: \"₦\", position: \"prefix\", spaced: false },\n  PHP: { symbol: \"₱\", position: \"prefix\", spaced: false },\n  BRL: { symbol: \"R$\", position: \"prefix\", spaced: false },\n  ZAR: { symbol: \"R\", position: \"prefix\", spaced: false },\n  // Scandinavian convention: amount then \"kr\", space-separated.\n  SEK: { symbol: \"kr\", position: \"suffix\", spaced: true },\n  NOK: { symbol: \"kr\", position: \"suffix\", spaced: true },\n  DKK: { symbol: \"kr\", position: \"suffix\", spaced: true },\n  PLN: { symbol: \"zł\", position: \"suffix\", spaced: true },\n  CHF: { symbol: \"Fr\", position: \"suffix\", spaced: true },\n  HUF: { symbol: \"Ft\", position: \"suffix\", spaced: true },\n  CZK: { symbol: \"Kč\", position: \"suffix\", spaced: true },\n};\n"]}