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

package/dist/{chunk-GW32KPCU.cjs → chunk-R24DI24X.cjs}

@@ -49,6 +49,18 @@ var TokenTypes = {
   PI: "PI",
   E: "E",
   MOD: "MOD",
+  // The English word "and", which is NOT the same thing as "+" even though it
+  // adds. It used to map straight onto PLUS in the locale keyword map, which
+  // made "3 and 4" evaluate to 7 correctly and then quietly broke every phrase
+  // that uses "and" as a list separator: "average of 36, 42, 19 and 81" parsed
+  // its last argument as "19 + 81" and returned 178/3 rather than 178/4.
+  //
+  // Giving it its own type lets a parselet tell the two apart. It is still an
+  // infix addition (see ArithmeticPackage.ts) so "3 and 4" is unchanged, but it
+  // binds at BindingPower.Conjunction, one step looser than Sum, so a phrase
+  // parselet can parse an argument at Conjunction and get "1 + 2" whole while
+  // still stopping at "and".
+  AND_CONJ: "AND_CONJ",
   OF: "OF",
   INCREASE_BY: "INCREASE_BY",
   DECREASE_BY: "DECREASE_BY",
@@ -108,6 +120,13 @@ var TokenTypes = {
   ELSE: "ELSE",
   AS: "AS",
   CONVERTER_NAME: "CONVERTER_NAME",
+  // Rounding (packages/converters/). "rounded" is a bare keyword: it is a
+  // past participle with no plausible use as a :variableName, the same
+  // accepted-risk category as "between"/"from". TO_NEAREST and
+  // DECIMAL_PLACES are fused, since "to" already means percentage change.
+  ROUNDED: "ROUNDED",
+  TO_NEAREST: "TO_NEAREST",
+  DECIMAL_PLACES: "DECIMAL_PLACES",
   // Fused two-word phrase tokens (see MathPhrasesPackage.ts's `phrases`
   // field), deliberately NOT bare single-word keywords: "average"
   // "total", "count", etc. are common variable names, and this codebase
@@ -124,8 +143,26 @@ var TokenTypes = {
   SMALLER_OF: "SMALLER_OF",
   HALF_OF: "HALF_OF",
   MIDPOINT_BETWEEN: "MIDPOINT_BETWEEN",
+  REMAINDER_OF: "REMAINDER_OF",
+  NTH_ROOT: "NTH_ROOT",
+  LOG_PHRASE: "LOG_PHRASE",
+  LOG_BASE: "LOG_BASE",
+  GCD_OF: "GCD_OF",
+  LCM_OF: "LCM_OF",
+  SQUARE_ROOT_OF: "SQUARE_ROOT_OF",
+  CUBE_ROOT_OF: "CUBE_ROOT_OF",
   RANDOM_NUMBER: "RANDOM_NUMBER",
   IS_TO: "IS_TO",
+  // Bare "is", the trigger for the solve-for-the-unknown percentage family
+  // (packages/percentage/IsWhatParselet.ts). Safe as a bare keyword: it is a
+  // verb, not a plausible :variableName, and the "is to" proportion phrase is
+  // fused earlier so it still wins.
+  IS: "IS",
+  PCT_ON: "PCT_ON",
+  PCT_OFF: "PCT_OFF",
+  OF_WHAT: "OF_WHAT",
+  OFF_WHAT: "OFF_WHAT",
+  ON_WHAT: "ON_WHAT",
   // CLAMP stays a bare single-word keyword: "clamp X between Y and Z" has
   // the value X between the trigger and "between", so it can't be
   // phrase-fused like the others above (same structural reason
@@ -208,6 +245,23 @@ var TokenTypes = {
   // create an unintended coupling if "@" is ever wired up.
   OVER: "OVER",
   RATE_AT: "RATE_AT",
+  // The investment grammar's connectives (packages/finance/), same
+  // accepted-risk category as OVER/RATE_AT above. "after"/"for" are
+  // prepositions; "compounding", "invested" and "returned" are participles,
+  // and none is a plausible `:variableName`.
+  //
+  // "after" and "for" are the pivots Soulver's own documented syntax uses,
+  // `$1,000 after 3 years at 7%` and `$1,000 for 3 years at 7% compounding
+  // monthly`. This package originally substituted "over" for both and said so
+  // in CompoundInterestParselet.ts's doc comment; the documented spellings now
+  // work as well, and "over" is kept so nothing that already parsed stops.
+  AFTER: "AFTER",
+  PRESENT_VALUE_OF: "PRESENT_VALUE_OF",
+  ANNUAL_RETURN_ON: "ANNUAL_RETURN_ON",
+  FOR_DURATION: "FOR_DURATION",
+  COMPOUNDING: "COMPOUNDING",
+  INVESTED: "INVESTED",
+  RETURNED: "RETURNED",
   // Fused phrase tokens (see FinancePackage.ts's `phrases` field)
   // deliberately NOT bare single-word keywords: "interest", "tax", "vat",
   // "repayment", "principal" etc. are all common, plausible variable names
@@ -228,6 +282,7 @@ var TokenTypes = {
   TOTAL_LOAN_INTEREST_ON: "TOTAL_LOAN_INTEREST_ON",
   TAX_ON: "TAX_ON",
   TAX_OFF: "TAX_OFF",
+  TAX_IN_PHRASE: "TAX_IN_PHRASE",
   // Inflation-adjusted value (packages/finance/) -- fused phrase
   // tokens (see FinancePackage.ts's `phrases` field), same reasoning
   // as the tax/interest phrases above: "what"/"was"/"value"/"worth"
@@ -280,6 +335,10 @@ var TokenTypes = {
   MONTH_ON: "MONTH_ON",
   MONTH_IN: "MONTH_IN",
   WEEK_ON: "WEEK_ON",
+  DAYS_IN_PERIOD: "DAYS_IN_PERIOD",
+  IN_TWO_UNITS: "IN_TWO_UNITS",
+  PER_UNIT: "PER_UNIT",
+  AT_RATE: "AT_RATE",
   WEEK_IN: "WEEK_IN",
   // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like
   // UNTIL_UNIT/SINCE_UNIT above.
@@ -356,5 +415,5 @@ exports.registerAllTokenTypes = registerAllTokenTypes;
 exports.registerTokenType = registerTokenType;
 exports.tokenTypeId = tokenTypeId;
 exports.tokenTypeName = tokenTypeName;
-//# sourceMappingURL=chunk-GW32KPCU.cjs.map
-//# sourceMappingURL=chunk-GW32KPCU.cjs.map
+//# sourceMappingURL=chunk-R24DI24X.cjs.map
+//# sourceMappingURL=chunk-R24DI24X.cjs.map

package/dist/chunk-R24DI24X.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-R24DI24X.cjs","sourcesContent":["/**\n * Lexer token produced by {@link ExpressionLexer} and consumed by parsers.\n *\n * Each token carries:\n * - `type`: string name (e.g. \"NUMBER\", \"PLUS\") for diagnostics and parselet lookup\n * - `typeId`: integer ID for O(1) comparison in parser hot paths\n * - `value`/`text`: the token's semantic value and raw source text\n * - `offset`/`line`/`col`: source position for error messages and highlighting\n */\nexport interface Token {\n\t/** String token type (e.g., \"NUMBER\", \"PLUS\", \"IDENT\"). Used by ParseletRegistry string-keyed maps and error messages. */\n\ttype: string;\n\t/** Integer token type ID for fast comparison in Parser hot path.\n\t * Populated by the Lexer via registerTokenType(). Use tokenTypeId(type) to get a type's ID. */\n\ttypeId: number;\n\tvalue: string;\n\ttext: string;\n\toffset: number;\n\tlineBreaks: number;\n\tline: number;\n\tcol: number;\n\t/**\n\t * End offset of the source text this token was fused from, exclusive.\n\t *\n\t * Only set on tokens the normalizer built by fusing several lexer tokens\n\t * into one, and only there because those are the tokens whose `value` no\n\t * longer describes the text they came from. `10 frames` fuses into a\n\t * FRAME_COUNT whose value is `10`, so `offset + value.length` would cover\n\t * two characters of a nine-character phrase.\n\t *\n\t * Evaluation never reads this. It exists so that a consumer painting a line\n\t * (see `LanguageService.getSemanticTokens`) can highlight a fused phrase as\n\t * the one thing the parser will see rather than as its parts.\n\t */\n\tsourceEnd?: number;\n}\n\n/**\n * Canonical token type name constants.\n * All token types used by the lexer, parser, and VM are defined here.\n * Custom/plugin token types should be registered via {@link registerTokenType}.\n */\nexport const TokenTypes = {\n  NUMBER: \"NUMBER\",\n  BIGINT: \"BIGINT\",\n  STRING: \"STRING\",\n  IDENT: \"IDENT\",\n  PLUS: \"PLUS\",\n  MINUS: \"MINUS\",\n  STAR: \"STAR\",\n  SLASH: \"SLASH\",\n  CARET: \"CARET\",\n  PERCENT: \"PERCENT\",\n  LSHIFT: \"LSHIFT\",\n  RSHIFT: \"RSHIFT\",\n  URSHIFT: \"URSHIFT\",\n  LPAREN: \"LPAREN\",\n  RPAREN: \"RPAREN\",\n  LBRACKET: \"LBRACKET\",\n  RBRACKET: \"RBRACKET\",\n  LBRACE: \"LBRACE\",\n  RBRACE: \"RBRACE\",\n  COMMA: \"COMMA\",\n  DOT: \"DOT\",\n  COLON: \"COLON\",\n  SEMICOLON: \"SEMICOLON\",\n  EQUALS: \"EQUALS\",\n  DOLLAR: \"DOLLAR\",\n  POUND: \"POUND\",\n  EURO: \"EURO\",\n  YEN: \"YEN\",\n  RUBLE: \"RUBLE\",\n  WON: \"WON\",\n  QUESTION: \"QUESTION\",\n  BANG: \"BANG\",\n  BIT_AND: \"BIT_AND\",\n  BIT_OR: \"BIT_OR\",\n  BIT_NOT: \"BIT_NOT\",\n  KEYWORD: \"KEYWORD\",\n  EOF: \"EOF\",\n  ERROR: \"ERROR\",\n  WS: \"WS\",\n  NEWLINE: \"NEWLINE\",\n  DATETIME_LITERAL: \"DATETIME_LITERAL\",\n  DURATION: \"DURATION\",\n  UNIT: \"UNIT\",\n  ROLL: \"ROLL\",\n  PI: \"PI\",\n  E: \"E\",\n  MOD: \"MOD\",\n  // The English word \"and\", which is NOT the same thing as \"+\" even though it\n  // adds. It used to map straight onto PLUS in the locale keyword map, which\n  // made \"3 and 4\" evaluate to 7 correctly and then quietly broke every phrase\n  // that uses \"and\" as a list separator: \"average of 36, 42, 19 and 81\" parsed\n  // its last argument as \"19 + 81\" and returned 178/3 rather than 178/4.\n  //\n  // Giving it its own type lets a parselet tell the two apart. It is still an\n  // infix addition (see ArithmeticPackage.ts) so \"3 and 4\" is unchanged, but it\n  // binds at BindingPower.Conjunction, one step looser than Sum, so a phrase\n  // parselet can parse an argument at Conjunction and get \"1 + 2\" whole while\n  // still stopping at \"and\".\n  AND_CONJ: \"AND_CONJ\",\n  OF: \"OF\",\n  INCREASE_BY: \"INCREASE_BY\",\n  DECREASE_BY: \"DECREASE_BY\",\n  // Percentage solve-for-unknown (packages/percentage/), \"N% of what is\n  // X\" solves N% * base = X for base. Fused as a full 3-word phrase (see\n  // PercentagePackage.ts's `phrases` field) rather than a bare \"what\"\n  // keyword, \"what\" is common enough as a variable name to be worth the\n  // same phrase-fusion treatment this codebase gives \"total\"/\"average\"/etc.\n  OF_WHAT_IS: \"OF_WHAT_IS\",\n  // Sibling solve-for-unknown forms accounting for a +/-1 offset, \"N% on\n  // what is X\" (increase) / \"N% off what is X\" (decrease). Same\n  // phrase-fusion reasoning as OF_WHAT_IS above.\n  ON_WHAT_IS: \"ON_WHAT_IS\",\n  OFF_WHAT_IS: \"OFF_WHAT_IS\",\n  NOW: \"NOW\",\n  TODAY: \"TODAY\",\n  TOMORROW: \"TOMORROW\",\n  YESTERDAY: \"YESTERDAY\",\n  DURATION_DAY: \"DURATION_DAY\",\n  DURATION_WEEK: \"DURATION_WEEK\",\n  DURATION_MONTH: \"DURATION_MONTH\",\n  DURATION_YEAR: \"DURATION_YEAR\",\n  DURATION_HOUR: \"DURATION_HOUR\",\n  DURATION_MINUTE: \"DURATION_MINUTE\",\n  DURATION_SECOND: \"DURATION_SECOND\",\n  FUNC: \"FUNC\",\n  CONVERT: \"CONVERT\",\n  TO: \"TO\",\n  BEST: \"BEST\",\n  NEXT: \"NEXT\",\n  LAST: \"LAST\",\n  UNTIL: \"UNTIL\",\n  SINCE: \"SINCE\",\n  BETWEEN: \"BETWEEN\",\n  FROM: \"FROM\",\n  INCREASE: \"INCREASE\",\n  DECREASE: \"DECREASE\",\n  UNICODE_MATH: \"UNICODE_MATH\",\n  TIMES_BY: \"TIMES_BY\",\n  MULTIPLY_BY: \"MULTIPLY_BY\",\n  DIVIDE_BY: \"DIVIDE_BY\",\n  NEQ: \"NEQ\",\n  IN: \"IN\",\n  BIT_XOR: \"BIT_XOR\",\n  EQUALITY: \"EQUALITY\",\n  GTE: \"GTE\",\n  LTE: \"LTE\",\n  LT: \"LT\",\n  GT: \"GT\",\n  LOGICAL_AND: \"LOGICAL_AND\",\n  LOGICAL_OR: \"LOGICAL_OR\",\n  OR: \"OR\",\n  TRUE: \"TRUE\",\n  FALSE: \"FALSE\",\n  IF: \"IF\",\n  THEN: \"THEN\",\n  ELSE: \"ELSE\",\n  AS: \"AS\",\n  CONVERTER_NAME: \"CONVERTER_NAME\",\n  // Rounding (packages/converters/). \"rounded\" is a bare keyword: it is a\n  // past participle with no plausible use as a :variableName, the same\n  // accepted-risk category as \"between\"/\"from\". TO_NEAREST and\n  // DECIMAL_PLACES are fused, since \"to\" already means percentage change.\n  ROUNDED: \"ROUNDED\",\n  TO_NEAREST: \"TO_NEAREST\",\n  DECIMAL_PLACES: \"DECIMAL_PLACES\",\n  // Fused two-word phrase tokens (see MathPhrasesPackage.ts's `phrases`\n  // field), deliberately NOT bare single-word keywords: \"average\"\n  // \"total\", \"count\", etc. are common variable names, and this codebase\n  // has a tested policy that colon-prefixed variable names can't be\n  // keyword-shaped words (see VariableParselet.ts's doc comment). Fusing\n  // the full \"<word> of\"/\"<word> between\" phrase means the bare word\n  // itself never becomes its own token type, so \":total = ...\" keeps\n  // working exactly as before.\n  AVERAGE_OF: \"AVERAGE_OF\",\n  MEDIAN_OF: \"MEDIAN_OF\",\n  TOTAL_OF: \"TOTAL_OF\",\n  COUNT_OF: \"COUNT_OF\",\n  LARGER_OF: \"LARGER_OF\",\n  SMALLER_OF: \"SMALLER_OF\",\n  HALF_OF: \"HALF_OF\",\n  MIDPOINT_BETWEEN: \"MIDPOINT_BETWEEN\",\n  REMAINDER_OF: \"REMAINDER_OF\",\n  NTH_ROOT: \"NTH_ROOT\",\n  LOG_PHRASE: \"LOG_PHRASE\",\n  LOG_BASE: \"LOG_BASE\",\n  GCD_OF: \"GCD_OF\",\n  LCM_OF: \"LCM_OF\",\n  SQUARE_ROOT_OF: \"SQUARE_ROOT_OF\",\n  CUBE_ROOT_OF: \"CUBE_ROOT_OF\",\n  RANDOM_NUMBER: \"RANDOM_NUMBER\",\n  IS_TO: \"IS_TO\",\n  // Bare \"is\", the trigger for the solve-for-the-unknown percentage family\n  // (packages/percentage/IsWhatParselet.ts). Safe as a bare keyword: it is a\n  // verb, not a plausible :variableName, and the \"is to\" proportion phrase is\n  // fused earlier so it still wins.\n  IS: \"IS\",\n  PCT_ON: \"PCT_ON\",\n  PCT_OFF: \"PCT_OFF\",\n  OF_WHAT: \"OF_WHAT\",\n  OFF_WHAT: \"OFF_WHAT\",\n  ON_WHAT: \"ON_WHAT\",\n  // CLAMP stays a bare single-word keyword: \"clamp X between Y and Z\" has\n  // the value X between the trigger and \"between\", so it can't be\n  // phrase-fused like the others above (same structural reason\n  // ClampParselet.ts is hand-written instead of PhrasePattern-based).\n  // Matches this codebase's existing accepted risk for \"between\"/\"from\"/\n  // \"next\"/\"last\"/\"best\", also bare, also can't be used as `:name`.\n  CLAMP: \"CLAMP\",\n  // map/reduce/sum/prod (packages/mapreduce/), bare single-word keywords\n  // each with its own dedicated parselet (custom argument grammar: a bare\n  // builtin/user-function name, an inline transform expression, or\n  // `name=collection` zipped pairs, none of which fit the ordinary\n  // FunctionCallParselet path, so these can't just reuse the generic FUNC\n  // token type the way sqrt/abs/... do).\n  MAP: \"MAP\",\n  REDUCE: \"REDUCE\",\n  SUM_FN: \"SUM_FN\",\n  PROD_FN: \"PROD_FN\",\n  // The algebra verbs (packages/symbolic/), fused from an ordinary IDENT only\n  // when immediately followed by `(`, so `factor`/`solve`/`expand` stay usable\n  // as variable names. Declared here rather than left to be minted on first use\n  // by `tokenTypeId()`, which is what {@link registerAllTokenTypes} exists for:\n  // a lazily-minted id depends on what else happened to be minted before it, so\n  // in a single-process run the id a normalizer rule produces can stop matching\n  // the id the parselet was registered under. Every token type a built-in\n  // package relies on belongs in this table.\n  EXPAND_FN: \"EXPAND_FN\",\n  FACTOR_FN: \"FACTOR_FN\",\n  SOLVE_FN: \"SOLVE_FN\",\n  DER_FN: \"DER_FN\",\n  INTEGRAL_FN: \"INTEGRAL_FN\",\n  TAYLOR_FN: \"TAYLOR_FN\",\n  JACOBIAN_FN: \"JACOBIAN_FN\",\n  CONJ_FN: \"CONJ_FN\",\n  RE_FN: \"RE_FN\",\n  IM_FN: \"IM_FN\",\n  CANCEL_FN: \"CANCEL_FN\",\n  APART_FN: \"APART_FN\",\n  // The imaginary-literal suffix, fused from a number followed immediately by\n  // `i`. Same registration reasoning as the verbs above.\n  IMAGINARY: \"IMAGINARY\",\n  // `=>`, \"therefore\"/solve operator. The algebra itself lives in symbolic/;\n  // packages/symbolic/ carries the grammar surface for the named operations.\n  // A genuine 2-char lexer token (ExpressionLexer.ts's TWO_CHAR_OPS table),\n  // same mechanism as ==/!=/>=/<=, not a normalizer-level fusion, \"=\" then\n  // \">\" is the opposite char order from GTE's \">=\", so there's no collision.\n  THEREFORE: \"THEREFORE\",\n  // Timezone query phrases (see TimePackage.ts's `phrases` field). Same\n  // phrase-fusion reasoning as above: \"time\"/\"date\"/\"difference\" are\n  // common variable names, so the fused trigger is the full phrase.\n  // CITY_NAME is the fused-token type for multi-word city/country names\n  // (e.g. \"new york\"). See timezones/CityZones.ts's MULTI_WORD_CITY_ZONES.\n  TIME_IN: \"TIME_IN\",\n  DATE_IN: \"DATE_IN\",\n  TIME_DIFFERENCE_BETWEEN: \"TIME_DIFFERENCE_BETWEEN\",\n  CITY_NAME: \"CITY_NAME\",\n  BACKTICK_OPEN: \"BACKTICK_OPEN\",\n  INLINE_SOLVE_START: \"INLINE_SOLVE_START\",\n  // Comment marker, `#` or `//` to end of line. Emitted by\n  // ExpressionLexer.tokenizeComment()/tokenizeOperator() but never reaches\n  // a parselet: ExpressionEngine.prepareExpression() filters COMMENT\n  // tokens out of the stream before normalization/parsing (see\n  // ExpressionEngine.ts's \"Filter COMMENT tokens\" comments). Listed here\n  // for discoverability even though tokenTypeId() would lazily register\n  // it anyway on first use.\n  COMMENT: \"COMMENT\",\n  // Vector types (referenced in locale keywordMap as vec2→VEC2, etc.)\n  VEC2: \"VEC2\",\n  VEC3: \"VEC3\",\n  VEC4: \"VEC4\",\n  FLOAT: \"FLOAT\",\n  GLOBAL: \"GLOBAL\",\n  // ── Finance (packages/finance/) ──\n  // OVER/RATE_AT are bare single-word keywords (not phrase-fused): both are\n  // prepositions with near-zero plausibility as a variable name (nobody\n  // writes \":over = 5\" or \":at = 3\"), the same accepted-risk category as\n  // this codebase's existing bare \"between\"/\"from\"/\"next\"/\"last\"/\"best\"\n  // keywords (see VariableParselet.ts's doc comment). RATE_AT is deliberately\n  // NOT named \"AT\", that name is already reserved (dormant) for a future\n  // \"@\" symbol token in TokenNormalizer.NON_WORD_NAMES; reusing it here would\n  // create an unintended coupling if \"@\" is ever wired up.\n  OVER: \"OVER\",\n  RATE_AT: \"RATE_AT\",\n  // The investment grammar's connectives (packages/finance/), same\n  // accepted-risk category as OVER/RATE_AT above. \"after\"/\"for\" are\n  // prepositions; \"compounding\", \"invested\" and \"returned\" are participles,\n  // and none is a plausible `:variableName`.\n  //\n  // \"after\" and \"for\" are the pivots Soulver's own documented syntax uses,\n  // `$1,000 after 3 years at 7%` and `$1,000 for 3 years at 7% compounding\n  // monthly`. This package originally substituted \"over\" for both and said so\n  // in CompoundInterestParselet.ts's doc comment; the documented spellings now\n  // work as well, and \"over\" is kept so nothing that already parsed stops.\n  AFTER: \"AFTER\",\n  PRESENT_VALUE_OF: \"PRESENT_VALUE_OF\",\n  ANNUAL_RETURN_ON: \"ANNUAL_RETURN_ON\",\n  FOR_DURATION: \"FOR_DURATION\",\n  COMPOUNDING: \"COMPOUNDING\",\n  INVESTED: \"INVESTED\",\n  RETURNED: \"RETURNED\",\n  // Fused phrase tokens (see FinancePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"interest\", \"tax\", \"vat\",\n  // \"repayment\", \"principal\" etc. are all common, plausible variable names\n  // (a shipped playground example uses \":total = :subtotal + :tax\". See\n  // MathPhrasesPackage.ts's doc comment for the regression this caused\n  // once already). Fusing the full \"<word> on\"/\"<word> off\" phrase means\n  // the bare leading word itself never becomes its own token type, so\n  // \":tax = ...\" keeps working exactly as before.\n  COMPOUND_INTEREST_ON: \"COMPOUND_INTEREST_ON\",\n  INTEREST_ON: \"INTEREST_ON\",\n  DAILY_REPAYMENT_ON: \"DAILY_REPAYMENT_ON\",\n  MONTHLY_REPAYMENT_ON: \"MONTHLY_REPAYMENT_ON\",\n  ANNUAL_REPAYMENT_ON: \"ANNUAL_REPAYMENT_ON\",\n  TOTAL_REPAYMENT_ON: \"TOTAL_REPAYMENT_ON\",\n  DAILY_LOAN_INTEREST_ON: \"DAILY_LOAN_INTEREST_ON\",\n  MONTHLY_LOAN_INTEREST_ON: \"MONTHLY_LOAN_INTEREST_ON\",\n  ANNUAL_LOAN_INTEREST_ON: \"ANNUAL_LOAN_INTEREST_ON\",\n  TOTAL_LOAN_INTEREST_ON: \"TOTAL_LOAN_INTEREST_ON\",\n  TAX_ON: \"TAX_ON\",\n  TAX_OFF: \"TAX_OFF\",\n  TAX_IN_PHRASE: \"TAX_IN_PHRASE\",\n  // Inflation-adjusted value (packages/finance/) -- fused phrase\n  // tokens (see FinancePackage.ts's `phrases` field), same reasoning\n  // as the tax/interest phrases above: \"what\"/\"was\"/\"value\"/\"worth\"\n  // are all plausible variable names, so only the full phrases are\n  // ever claimed as keywords, never the bare leading word.\n  WHAT_IS: \"WHAT_IS\",\n  WHAT_WAS: \"WHAT_WAS\",\n  VALUE_OF: \"VALUE_OF\",\n  WORTH_IN: \"WORTH_IN\",\n  // Bare single-word keyword (not phrase-fused) -- \"assuming\" has\n  // near-zero plausibility as a variable name, the same accepted-risk\n  // category as this codebase's existing bare \"over\"/\"at\" keywords\n  // (see the OVER/RATE_AT comment above). Registered so its bare word\n  // is a recognized phrase-starter (`canStartPhrase`), which suppresses\n  // implicit-multiply insertion between the futureYear NUMBER and this\n  // word in \"value of $X in <year> assuming N% inflation\" -- without\n  // this, \"<year> assuming\" was silently rewritten to \"<year> *\n  // assuming\" before parsing ever ran.\n  ASSUMING: \"ASSUMING\",\n  // Fused by a custom NormalizerRule (not `phrases`), carrying the\n  // year as its value -- see\n  // finance/normalizer/InYearDollarsNormalizerRule.ts.\n  IN_YEAR_DOLLARS: \"IN_YEAR_DOLLARS\",\n  // Cooking/UoM (packages/uom/) -- fused ingredient name (single- or\n  // multi-word, e.g. \"butter\"/\"olive oil\") carrying the matched name\n  // as its value. NOT a bare-word phrase-trie keyword -- see\n  // uom/normalizer/IngredientNameNormalizerRule.ts's doc comment for\n  // why this is a context-sensitive NormalizerRule instead (so a bare\n  // `:butter = 5` variable definition is completely unaffected).\n  INGREDIENT_NAME: \"INGREDIENT_NAME\",\n  // ── Datetime, workdays/weekdays/timestamps (packages/datetime/) ──\n  // Fused phrase tokens (see DatetimePackage.ts's `phrases` field)\n  // deliberately NOT bare single-word keywords: \"workdays\"/\"weekday\"/\n  // \"timestamp\"/\"date\" are all plausible variable names, same\n  // reasoning/regression risk as MathPhrasesPackage.ts's \"total\" note and\n  // FinancePackage.ts's \"tax\" note above. Fusing the full phrase means the\n  // bare leading word itself never becomes its own token type, so e.g.\n  // \":timestamp = 5\" keeps working.\n  WORKDAYS_IN: \"WORKDAYS_IN\",\n  WEEKDAY_ON: \"WEEKDAY_ON\",\n  CURRENT_TIMESTAMP: \"CURRENT_TIMESTAMP\",\n  TO_DATE: \"TO_DATE\",\n  TO_TIMESTAMP: \"TO_TIMESTAMP\",\n  // Natural-question forms over the same date fields, \"what day is it in\n  // 30 days\", \"what month is it on 25/12/2026\", \"what week is it\". Each is\n  // a fully-fused phrase for the same reason as WEEKDAY_ON above: claiming\n  // bare \"day\"/\"month\"/\"week\" as keywords would break \":day = 5\" and\n  // collide with the UNIT tokens of the same name.\n  WEEKDAY_IN: \"WEEKDAY_IN\",\n  MONTH_ON: \"MONTH_ON\",\n  MONTH_IN: \"MONTH_IN\",\n  WEEK_ON: \"WEEK_ON\",\n  DAYS_IN_PERIOD: \"DAYS_IN_PERIOD\",\n  IN_TWO_UNITS: \"IN_TWO_UNITS\",\n  PER_UNIT: \"PER_UNIT\",\n  AT_RATE: \"AT_RATE\",\n  WEEK_IN: \"WEEK_IN\",\n  // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like\n  // UNTIL_UNIT/SINCE_UNIT above.\n  BETWEEN_UNIT: \"BETWEEN_UNIT\",\n  // Postfix day-type predicates, \"<date> is a weekend\" / \"is a workday\".\n  IS_WEEKEND: \"IS_WEEKEND\",\n  IS_WORKDAY: \"IS_WORKDAY\",\n  // ── Time, video timecode (packages/time/) ──\n  // Fused from a raw `HH:MM:SS:FF` token sequence (see\n  // packages/time/normalizer/VideoTimecodeNormalizerRule.ts) and from\n  // `NUMBER frames` (see FrameCountNormalizerRule.ts), not a bare-keyword\n  // collision risk the way the datetime tokens above are, since neither\n  // fusion claims a plain English word as its own token type.\n  VIDEO_TIMECODE: \"VIDEO_TIMECODE\",\n  FRAME_COUNT: \"FRAME_COUNT\",\n  // \"@\". See ExpressionLexer.ts's OP_MAP entry for why this was\n  // previously dormant/unproduced despite being anticipated by name here\n  // and in TokenNormalizer.ts's NON_WORD_NAMES.\n  AT: \"AT\",\n  // Generic token for every currency symbol added AFTER the original\n  // DOLLAR/POUND/EURO/YEN/RUBLE/WON set (each of which kept its own\n  // specific token type for backward compatibility). See\n  // uom/CurrencyAliases.ts's CURRENCY_SYMBOL_ALIASES and\n  // ExpressionLexer.ts's dispatch for the full symbol list. One shared\n  // type avoids needing a new TokenTypes entry + TokenCategoryMap entry +\n  // CurrencyPackage.ts prefixParselets entry per additional symbol.\n  CURRENCY_SYMBOL: \"CURRENCY_SYMBOL\",\n  // ── Cross-line data access (packages/lines/) ──\n  // \"prev\" -- bare keyword (nothing to phrase-fuse against, same shape as\n  // CLAMP -- accepted collision risk per that package's own precedent).\n  PREV: \"PREV\",\n  // \"line1\" / \"line 1\" / \"l1\" -- fused by LineRefNormalizerRule (never a\n  // bare lexer keyword, so \":line = 5\"/\":l = 5\" stay untouched). Carries\n  // the parsed line number as its .value.\n  LINE_REF: \"LINE_REF\",\n  // \"sum(\" / \"total(\" -- fused ONLY when immediately followed by LPAREN\n  // (see LineRefNormalizerRule's lookahead guard), so \":sum = 100\" and\n  // MathPhrases' \"total of X, Y\" (no paren after \"of\") are unaffected.\n  SUM_RANGE_CALL: \"SUM_RANGE_CALL\",\n  AVERAGE_RANGE_CALL: \"AVERAGE_RANGE_CALL\",\n  // \"total above\" / \"sum above\" / \"average above\" -- phrase-fused (see\n  // LinesPackage.ts's `phrases` field), a deliberate departure from\n  // Numi/Numbr's bare \"total\"/\"sum\" wording to avoid the exact bare-\n  // keyword collision this codebase already regressed on once.\n  TOTAL_ABOVE: \"TOTAL_ABOVE\",\n  SUM_ABOVE: \"SUM_ABOVE\",\n  AVERAGE_ABOVE: \"AVERAGE_ABOVE\",\n} as const;\n\n/**\n * A token's kind, as a string.\n *\n * Deliberately open rather than an enum: a package registers its own token\n * types at runtime, and a closed set would make that impossible.\n */\nexport type TokenType = (typeof TokenTypes)[keyof typeof TokenTypes];\n\n// ── Integer Token Type ID System ──────────────────────────────────────────────\n// Enables O(1) integer comparison in Parser hot path instead of string hashing.\n\n/** Auto-incrementing integer ID for each token type. */\nlet _nextTokenTypeId = 0;\n\n/** String → integer ID lookup. Populated lazily via registerTokenType(). */\nconst _tokenTypeNameToId = new Map<string, number>();\n\n/** Integer ID → string lookup. For debug/error messages. */\nconst _tokenTypeIdToName = new Map<number, string>();\n\n/**\n * Register a token type name and get back its integer ID.\n * Idempotent, returns existing ID if already registered.\n * Call once per token type at module initialization time.\n */\nexport function registerTokenType(name: string): number {\n\tconst existing = _tokenTypeNameToId.get(name);\n\tif (existing !== undefined) return existing;\n\tconst id = _nextTokenTypeId++;\n\t_tokenTypeNameToId.set(name, id);\n\t_tokenTypeIdToName.set(id, name);\n\treturn id;\n}\n\n/**\n * Get the integer ID for a token type name.\n * Lazily registers unknown token types on first access, enabling plugin providers\n * to define custom token types (VEC2, VEC3, etc.) without pre-registration.\n * All built-in TokenTypes are pre-registered via registerAllTokenTypes().\n */\nexport function tokenTypeId(name: string): number {\n\treturn registerTokenType(name);  // registerTokenType is idempotent\n}\n\n/**\n * Get the string name for a token type ID (for error messages and debugging).\n * Returns `UNKNOWN_${id}` if the ID is not registered.\n */\nexport function tokenTypeName(id: number): string {\n\treturn _tokenTypeIdToName.get(id) ?? `UNKNOWN_${id}`;\n}\n\n/**\n * Bootstrap all known token types from TokenTypes at module load.\n * Call this once after TokenTypes is defined.\n */\nexport function registerAllTokenTypes(): void {\n\tfor (const name of Object.values(TokenTypes)) {\n\t\tregisterTokenType(name);\n\t}\n}\n"]}

package/dist/{chunk-XVWCOTR6.js → chunk-SFQWJMKT.js}

@@ -1,6 +1,6 @@
-import { registerAllTokenTypes, tokenTypeId } from './chunk-RIN643A3.js';
-import { getLocale } from './chunk-GOLDJNMZ.js';
-import { knownUnits } from './chunk-LIPPNDBE.js';
+import { registerAllTokenTypes, tokenTypeId } from './chunk-GPPLSM2Z.js';
+import { getLocale } from './chunk-XBTEO4OB.js';
+import { knownUnits } from './chunk-M5E34VG5.js';
 import { ErrorFactory } from './chunk-6RDSQURE.js';
 
 // src/lexer/ExpressionLexer.ts
@@ -47,7 +47,7 @@ function buildCharClassTable() {
   return table;
 }
 var LexerToken = class {
-  constructor(type, typeId, value, text, offset, lineBreaks, line, col) {
+  constructor(type, typeId, value, text, offset, lineBreaks, line, col, sourceEnd) {
     this.type = type;
     this.typeId = typeId;
     this.value = value;
@@ -56,6 +56,7 @@ var LexerToken = class {
     this.lineBreaks = lineBreaks;
     this.line = line;
     this.col = col;
+    this.sourceEnd = sourceEnd;
   }
 };
 var TWO_CHAR_OPS = {
@@ -1320,5 +1321,5 @@ _ExpressionLexer.CHAR_CLASS = buildCharClassTable();
 var ExpressionLexer = _ExpressionLexer;
 
 export { ExpressionLexer, LexerToken };
-//# sourceMappingURL=chunk-XVWCOTR6.js.map
-//# sourceMappingURL=chunk-XVWCOTR6.js.map
+//# sourceMappingURL=chunk-SFQWJMKT.js.map
+//# sourceMappingURL=chunk-SFQWJMKT.js.map

package/dist/chunk-SFQWJMKT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/ExpressionLexer.ts"],"names":["input","text"],"mappings":"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","file":"chunk-SFQWJMKT.js","sourcesContent":["import { Token, tokenTypeId, registerAllTokenTypes } from '@solve-js/lexer/Token';\nimport { knownUnits } from '@solve-js/lexer/units';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { ErrorFactory } from '@solve-js/errors/UnifiedErrorFramework';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\n\n// Bootstrap all token types at module load\nregisterAllTokenTypes();\n\n// ── Markdown line classification (Phase B) ──────────────────────────────\n\n/** What a line is, structurally, before anything tries to evaluate it. */\nexport type MarkdownLineType =\n  | 'expression'\n  | 'prose'\n  | 'heading'\n  | 'blockquote'\n  | 'list'\n  | 'code_fence'\n  | 'math_fence'\n  | 'table'\n  | 'table_separator'\n  | 'hr'\n  | 'wikilink'\n  | 'comment'\n  | 'empty';\n\n/**\n * What a line is and whether it holds anything to evaluate.\n *\n * Produced by a character-level scan that never consults the keyword, unit or\n * operator tables, so any lexer gives the same answer for the same line. See\n * `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n */\nexport interface LineClassification {\n  /** The type of this markdown line */\n  type: MarkdownLineType;\n  /** Whether this line should be skipped (no expression evaluation) */\n  skip: boolean;\n  /** Whether the line contains inline solve markers (`s`...``) */\n  hasInlineSolve: boolean;\n}\n\n/** Inline solve position with precise coordinates */\nexport interface InlineSolveSpan {\n  /** Character offset of the `s`` marker */\n  start: number;\n  /** Character offset past the closing `` ` `` */\n  end: number;\n  /** The expression text between the backticks */\n  expression: string;\n  /** 1-based column of the `s`` marker */\n  columnNumber: number;\n  /** Token index of INLINE_SOLVE_START in the line's token array (set during tokenization). */\n  startTokenIndex?: number;\n  /** Token index of closing BACKTICK_OPEN in the line's token array (set during tokenization). */\n  endTokenIndex?: number;\n}\n\n/**\n * Result from a single line processed by scanDocument().\n * Combines line classification, tokenized tokens, and inline solve spans\n * into a single structure, eliminating the need for separate classifyLine()\n * findInlineSolves(), and per-line Lexer.reset() calls.\n */\nexport interface ScanLineResult {\n  /** The raw line text (without trailing newline). */\n  text: string;\n  /** 1-based line number within the document. */\n  lineNumber: number;\n  /** Character offset of the line start within the document. */\n  startOffset: number;\n  /** Character offset of the line end (before newline). */\n  endOffset: number;\n  /** The line classification. */\n  classification: LineClassification;\n  /** Tokenized tokens (empty array if line is skipped). */\n  tokens: Token[];\n  /** Inline solve spans found in this line (empty if none). */\n  inlineSolves: InlineSolveSpan[];\n}\n\n// ── Character class constants ─────────────────────────────────────────────\n// Used as the result of the CHAR_CLASS lookup table. V8 compiles the\n// outer switch on these small integer constants into a jump table.\nconst enum CharClass {\n  SKIP       = 0,  // Invalid / control / unicode fallback\n  WHITESPACE = 1,  // space, tab, \\n, \\r\n  DIGIT      = 2,  // 0-9\n  ALPHA      = 3,  // a-z, A-Z, _\n  DOT        = 4,  // . (could be decimal point or DOT token)\n  OPERATOR   = 5,  // + - * / ^ % ( ) [ ] { } , : ; = ? & | ~ ! < >\n  QUOTE      = 6,  // \"\n  HASH       = 7,  // # (comment)\n  DOLLAR     = 8,  // $\n  POUND      = 9,  // £ (U+00A3)\n  EURO       = 10, // € (U+20AC)\n  BACKTICK   = 11, // `\n}\n\n// ── Static character class table (built once at module load) ──────────────\nfunction buildCharClassTable(): Uint8Array {\n  const table = new Uint8Array(128);\n\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) table[i] = CharClass.DIGIT;\n\n  // Uppercase A-Z\n  for (let i = 65; i <= 90; i++) table[i] = CharClass.ALPHA;\n\n  // Lowercase a-z\n  for (let i = 97; i <= 122; i++) table[i] = CharClass.ALPHA;\n\n  // Underscore\n  table[95] = CharClass.ALPHA;\n\n  // Dot\n  table[46] = CharClass.DOT;\n\n  // Whitespace\n  table[32] = CharClass.WHITESPACE;  // space\n  table[9]  = CharClass.WHITESPACE;  // tab\n  table[10] = CharClass.WHITESPACE;  // \\n\n  table[13] = CharClass.WHITESPACE;  // \\r\n\n  // Operators / punctuation\n  table[33] = CharClass.OPERATOR;  // !\n  table[37] = CharClass.OPERATOR;  // %\n  table[38] = CharClass.OPERATOR;  // &\n  table[40] = CharClass.OPERATOR;  // (\n  table[41] = CharClass.OPERATOR;  // )\n  table[42] = CharClass.OPERATOR;  // *\n  table[43] = CharClass.OPERATOR;  // +\n  table[44] = CharClass.OPERATOR;  // ,\n  table[45] = CharClass.OPERATOR;  // -\n  table[47] = CharClass.OPERATOR;  // /\n  table[58] = CharClass.OPERATOR;  // :\n  table[59] = CharClass.OPERATOR;  // ;\n  table[60] = CharClass.OPERATOR;  // <\n  table[61] = CharClass.OPERATOR;  // =\n  table[62] = CharClass.OPERATOR;  // >\n  table[63] = CharClass.OPERATOR;  // ?\n  table[91] = CharClass.OPERATOR;  // [\n  table[93] = CharClass.OPERATOR;  // ]\n  table[94] = CharClass.OPERATOR;  // ^\n  table[123] = CharClass.OPERATOR; // {\n  table[124] = CharClass.OPERATOR; // |\n  table[125] = CharClass.OPERATOR; // }\n  table[126] = CharClass.OPERATOR; // ~\n  // \"@\" was previously unclassified (defaulted to CharClass.SKIP, silently\n  // dropped before ever reaching OP_MAP). See OP_MAP's own \"@\" entry doc\n  // comment for why this is being activated now.\n  table[64] = CharClass.OPERATOR;  // @\n\n  // Other\n  table[34] = CharClass.QUOTE;    // \"\n  table[35] = CharClass.HASH;     // #\n  table[36] = CharClass.DOLLAR;   // $\n  table[96] = CharClass.BACKTICK; // `\n\n  return table;\n}// ── Monomorphic Token class ───────────────────────────────────────────────\n// V8 assigns a single stable HiddenClass because all properties are\n// initialized in the constructor and never added/removed afterwards.\n// This enables fast property access (inline cache hits) and allows\n// allocation in V8's nursery (cheap GC).\n// All 9 fields are always set, no optional fields, no different shapes.\n/**\n * A token, as the lexer produces it.\n *\n * A class rather than an object literal because tokens are created on every\n * keystroke and a shared hidden class keeps that path predictable for the\n * engine running it.\n */\nexport class LexerToken implements Token {\n  constructor(\n    public type: string,\n    public typeId: number,\n    public value: string,\n    public text: string,\n    public offset: number,\n    public lineBreaks: number,\n    public line: number,\n    public col: number,\n    /** See {@link Token.sourceEnd}. Set only on normalizer-fused tokens. */\n    public sourceEnd?: number,\n  ) {}\n}\n\n// ── Two-character operator lookup ─────────────────────────────────────────\n// Maps first-char → (second-char → token type). Used for operators like\n// ==, !=, >=, <=, **, <<, >>.\ninterface TwoCharOpMap {\n  [firstChar: number]: { [secondChar: number]: string };\n}\nconst TWO_CHAR_OPS: TwoCharOpMap = {\n  61: { 61: 'EQUALITY', 62: 'THEREFORE' },  // ==, => (opposite char order from >='s GTE below — no collision)\n  33: { 61: 'NEQ' },       // !=\n  62: { 61: 'GTE' },       // >=\n  60: { 61: 'LTE' },       // <=\n  38: { 38: 'LOGICAL_AND' }, // &&\n  124: { 124: 'LOGICAL_OR' }, // ||\n  // Note: ** is NOT a single token, the existing moo lexer emits two\n  // separate STAR tokens, and the parser consumes them that way.\n  // 42: { 42: 'EXPONENT' },  // **, disabled for moo compatibility\n};\n// Note: LSHIFT (<<) and RSHIFT (>>) are handled separately because\n// 60 is also used for LTE, so we check LTE first then LSHIFT.\n\n// ── Single-character operator lookup ──────────────────────────────────────\nconst OP_MAP: Record<number, string> = {\n  43: 'PLUS',     // +\n  45: 'MINUS',    // -\n  42: 'STAR',     // *\n  47: 'SLASH',    // /\n  94: 'CARET',    // ^\n  37: 'PERCENT',  // %\n  40: 'LPAREN',   // (\n  41: 'RPAREN',   // )\n  91: 'LBRACKET', // [\n  93: 'RBRACKET', // ]\n  123: 'LBRACE',  // {\n  125: 'RBRACE',  // }\n  44: 'COMMA',    // ,\n  58: 'COLON',    // :\n  59: 'SEMICOLON',// ;\n  61: 'EQUALS',   // =\n  63: 'QUESTION', // ?\n  33: 'BANG',     // !\n  38: 'BIT_AND',  // &\n  124: 'BIT_OR',  // |\n  60: 'LT',       // <\n  62: 'GT',       // >\n  126: 'BIT_NOT', // ~\n  // \"@\", activates the token type name already dormant-reserved for this\n  // exact purpose (see Token.ts's OVER/RATE_AT doc comment and\n  // normalizer/TokenNormalizer.ts's NON_WORD_NAMES, both of which already\n  // anticipated \"AT\" as a future \"@\" symbol token before this addition).\n  // Backs the time package's video-timecode literal's alternate fps\n  // separator (`01:02:03:04 @ 30fps`, equivalent to `... at 30fps`). See\n  // packages/time/parselets/VideoTimecodeParselet.ts.\n  64: 'AT',       // @\n};\n\n/**\n * Plugin interface for extending the ExpressionLexer with custom tokens.\n *\n * Plugins can register:\n * - `keywords`: Map identifier strings to custom token types (checked after locale keywords).\n * - `operators`: Map multi-character operator sequences to custom token types.\n * - `units`: Register additional unit identifiers (checked alongside built-in units).\n *\n * Multi-word phrase matching has been moved to the TokenNormalizer post-lexer\n * stage. To register phrase patterns, use `IEnginePackage.normalizerRules` instead.\n *\n * All registrations are additive, built-in patterns still work.\n */\nexport interface LexerVocabulary {\n  /**\n   * Keyword → tokenType mappings. Each key is a lowercase identifier that,\n   * when encountered, will emit the specified token type instead of IDENT.\n   * These are checked AFTER the locale's built-in keywordMap, so locale\n   * keywords take priority.\n   */\n  keywords?: Record<string, string>;\n\n  /**\n   * Multi-character operator → tokenType mappings. Each key is the exact\n   * character sequence (e.g., \"::\", \"->\", \"=>\") and the value is the token\n   * type to emit. Two-character operators take priority during matching.\n   * Built-in operators (==, !=, >=, <=, <<, >>) always take priority.\n   */\n  operators?: Record<string, string>;\n\n  /**\n   * Additional unit identifiers to recognize (e.g., \"gp\", \"osrs\", \"tile\").\n   * These are checked alongside the built-in `knownUnits` set.\n   */\n  units?: string[];\n\n  /**\n   * Whole-line patterns matched against the RAW line text, BEFORE any\n   * per-character tokenization begins.\n   *\n   * Every other extension point in this file (`keywords`/`operators`/\n   * `units`, plus `IEnginePackage.phrases`/`normalizerRules`) transforms\n   * a token STREAM -- they all assume the line is, at some granularity,\n   * valid Solve syntax. This hook exists for the one shape that isn't:\n   * a package whose grammar captures arbitrary free-form text terminated\n   * by a fixed marker (e.g. a natural-language query ending in `= ?`),\n   * where the text itself (\"distance to the moon\") would never tokenize\n   * or parse as a normal expression and must be captured verbatim\n   * instead -- see `packages/knowledge/` for the reference use.\n   *\n   * Each entry's `pattern` is tested (via `RegExp.exec`) against the\n   * full, untrimmed line text. If it matches AND capture group 1 is\n   * non-empty after trimming, the ENTIRE line becomes a single\n   * synthetic token of `tokenType` whose `value`/`text` is the trimmed\n   * capture group -- the character-by-character scanner never runs for\n   * that line. Patterns are tried in registration order; the first\n   * match wins. A package registering a rule here still needs a\n   * `prefixParselets` entry for `tokenType` to actually consume the\n   * resulting token.\n   *\n   * Because this bypasses tokenization entirely, a matching line can\n   * contain characters that would otherwise be lexer errors (unmatched\n   * quotes, stray symbols, ...) -- by design, since the whole point is\n   * to hand the package raw text the normal pipeline was never meant to\n   * parse.\n   */\n  rawLinePatterns?: Array<{ pattern: RegExp; tokenType: string }>;\n}\n\n// ── Expression gating (L1) ──────────────────────────────────────────────\n// Pre-computed Set of character codes that indicate an expression might\n// be present. Used by hasExpressionIndicators() to gate prose lines\n// before full tokenization.\n//\n// NOTE: Currently unused, L1 prose gating was removed from classifyFromPositions()\n// because it incorrectly skipped keyword-only lines (\"pi\"), single identifiers\n// (\"hello\"), and short alpha lines. Retained for future re-implementation with\n// keyword-awareness and proper test coverage.\nconst EXPRESSION_INDICATOR_CODES = (() => {\n  const set = new Set<number>();\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) set.add(i);\n  // Operators / punctuation\n  // Note: colon (58) is intentionally excluded, it's common in prose\n  // (e.g., \"Subject: Hello world\") and would cause false-positive\n  // expression classification. Variable assignment lines like\n  // \":myVar = 5\" are still caught by '=' and digit indicators.\n  const opCodes = [43, 45, 42, 47, 94, 37, 40, 41, 91, 93, 123, 125, 61, 60, 62, 33, 38, 124, 126, 59, 63];\n  for (const c of opCodes) set.add(c);\n  // Currency\n  set.add(36);   // $\n  set.add(0x00A3); // £\n  set.add(0x20AC); // €\n  set.add(0x00A5); // ¥\n  set.add(0x20BD); // ₽\n  set.add(0x20A9); // ₩\n  // Backtick (inline solve)\n  set.add(96);   // `\n  // Dot (could be decimal)\n  set.add(46);   // .\n  // Hash (comment, still an expression indicator)\n  set.add(35);   // #\n  return set;\n})();\n\n// ── ExpressionLexer ───────────────────────────────────────────────────────\n/**\n * Character-by-character tokenizer for expression text.\n *\n * Scans a raw line/expression string into a stream of typed tokens\n * (numbers, identifiers, operators, units, keywords, ...), handling\n * markdown-line classification (`classifyLine`), inline `` s`...` `` solve\n * spans, and package-contributed vocabulary (registered via\n * {@link registerVocabulary}/{@link unregisterVocabulary}, keywords\n * operators, and units a package wants recognized as their own token\n * types rather than falling through to generic identifiers).\n *\n * Most consumers should use the higher-level {@link Lexer} wrapper, which\n * adds streaming `next()`/`peek()` access over this class's scan results.\n */\nexport class ExpressionLexer {\n  private static readonly CHAR_CLASS = buildCharClassTable();\n  /**\n   * Configured TokenLookup from TokenClassRegistry. When set, replaces\n   * the internal keyword map and unit set with registry-built equivalents.\n   * Enables data-driven keyword/unit registration across locale keywords,\n   * provider keywords, and plugins.\n   *\n   * Set at construction time via the constructor parameter. Plugin-registered\n   * keywords/units (via registerVocabulary()) are checked alongside\n   * the configuredLookup, neither source is bypassed.\n   */\tprivate configuredLookup: TokenLookup | null = null;\n\n\t// Instance state\n  private input: string = '';\n  private pos: number = 0;\n  private len: number = 0;\n\n  // Line / column tracking (1-indexed)\n  private line: number = 1;\n  private lineStartPos: number = 0;\n\n  // Keyword map: lowercase identifier → token type (locale keywords only)\n  private keywordMap: Map<string, string>;\n\n  // ── Merged lookup collections (keywordMap + pluginKeywordMap, knownUnits + pluginUnits)\n  private mergedKeywords: Map<string, string>;\n  private mergedUnits: Set<string>;\n\n  // Plugin-extensible keyword map (merged with locale keywordMap)\n  private pluginKeywordMap: Map<string, string> = new Map();\n\n  // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)\n  private pluginOperators: Map<number, Map<number, string>> = new Map();\n\n  // Plugin-extensible units (merged with knownUnits)\n  private pluginUnits: Set<string> = new Set();\t// Fast-path guards: skip plugin lookups entirely when no plugins registered\n\tprivate hasPluginOps = false;\n\n  // Locale for function-identifier lookups\n  private localeCode: string;\n  private locale: ILocale;\n\n  /**\n   * Inline solve spans collected during the most recent tokenization pass.\n   * Populated by [Symbol.iterator]() and consumed by scanDocument().\n   */\n  _inlineSolveSpans: InlineSolveSpan[] = [];\n\n  // Plugin-extensible raw-line patterns. See LexerVocabulary.rawLinePatterns.\n  private pluginRawLinePatterns: Array<{ pattern: RegExp; tokenType: string }> = [];\n\n  /**\n   * If a `rawLinePatterns` rule matches the FULL text most recently passed\n   * to {@link reset}, this holds the single synthetic token that\n   * {@link tokenizeAll} should return instead of running the\n   * character-by-character scanner. Cleared (re-evaluated) on every\n   * {@link reset} call. `null` when no plugin registered any raw-line\n   * patterns, or none matched, the overwhelmingly common case, checked\n   * with a `length === 0` guard before ever touching this field so a\n   * plugin-free lexer pays zero cost for the feature.\n   */\n  private pendingRawLineToken: Token | null = null;\n\n  /**\n   * Test `text` against every registered `rawLinePatterns` rule, in\n   * registration order. Returns a synthetic token for the first rule\n   * whose `pattern` matches AND whose capture group 1 is non-empty after\n   * trimming; returns `null` if no rule matches (the normal\n   * character-by-character scanner should run instead).\n   */\n  private matchRawLine(text: string): Token | null {\n    for (const rule of this.pluginRawLinePatterns) {\n      const m = rule.pattern.exec(text);\n      if (m && typeof m[1] === 'string') {\n        const value = m[1].trim();\n        if (value.length > 0) {\n          return new LexerToken(rule.tokenType, tokenTypeId(rule.tokenType), value, value, 0, 0, this.line, 1);\n        }\n      }\n    }\n    return null;\n  }\n\n  /** Rebuild merged keyword and unit collections after plugin registration. */\n  private rebuildMergedCollections(): void {\n    this.mergedKeywords = new Map([...this.keywordMap, ...this.pluginKeywordMap]);\n    this.mergedUnits = new Set([...knownUnits, ...this.pluginUnits]);\n  }\n\n  constructor(localeCode = 'en', lookup?: TokenLookup) {\n    this.localeCode = localeCode;\n    this.locale = getLocale(localeCode);\n    this.configuredLookup = lookup ?? null;\n    this.keywordMap = new Map<string, string>();\n    for (const [k, v] of Object.entries(this.locale.keywordMap)) {\n      this.keywordMap.set(k.toLowerCase(), v);\n    }\n    this.mergedKeywords = new Map(this.keywordMap);\n    this.mergedUnits = new Set(knownUnits);\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   *\n   * All registrations are additive, built-in patterns still work.\n   * Keywords, operators, and units from the plugin are merged\n   * with existing ones. Calling multiple times adds more entries.\n   *\n   * Note: multi-word phrases are now handled by the TokenNormalizer\n   * (see `IEnginePackage.normalizerRules`), not the lexer.\n   *\n   * Built-in tokens CANNOT be overridden. Throws a EngineError if the\n   * plugin attempts to register a keyword, operator, or unit\n   * that conflicts with a built-in one.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const [keyword, tokenType] of Object.entries(plugin.keywords)) {\n        const lower = keyword.toLowerCase();\n        // Guard: prevent overriding built-in locale keywords\n        if (this.keywordMap.has(lower)) {\n          throw ErrorFactory.config(\n            'PLUGIN_KEYWORD_COLLISION',\n            `Plugin keyword \"${keyword}\" conflicts with built-in keyword ` +\n            `(type: ${this.keywordMap.get(lower)}). Built-in keywords cannot be overridden.`,\n            { keyword, builtinType: this.keywordMap.get(lower) }\n          );\n        }\n        this.pluginKeywordMap.set(lower, tokenType);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      this.hasPluginOps = true;\n      for (const [chars, tokenType] of Object.entries(plugin.operators)) {\n        // Only support 2-char operators for the fast path\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n\n          // Guard: prevent overriding built-in two-char operators (==, !=, >=, <=)\n          const builtInSecondMap = TWO_CHAR_OPS[first];\n          if (builtInSecondMap && builtInSecondMap[second] !== undefined) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: ${builtInSecondMap[second]}). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: builtInSecondMap[second] }\n            );\n          }\n          // Guard: prevent overriding LSHIFT (<<) and RSHIFT (>>)\n          if (first === 60 && second === 60) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: LSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'LSHIFT' }\n            );\n          }\n          if (first === 62 && second === 62) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: RSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'RSHIFT' }\n            );\n          }\n          // Guard: prevent overriding comment sequences (//)\n          if (first === 47 && second === 47) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in comment sequence. ` +\n              `Comment sequences cannot be overridden.`,\n              { operator: chars, builtinType: 'COMMENT' }\n            );\n          }\n\n          let inner = this.pluginOperators.get(first);\n          if (!inner) {\n            inner = new Map();\n            this.pluginOperators.set(first, inner);\n          }\n          inner.set(second, tokenType);\n        }\n      }\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        // Guard: prevent overriding built-in units\n        if (knownUnits.has(unit)) {\n          throw ErrorFactory.config(\n            'PLUGIN_UNIT_COLLISION',\n            `Plugin unit \"${unit}\" conflicts with a built-in unit. ` +\n            `Built-in units cannot be overridden.`,\n            { unit }\n          );\n        }\n        this.pluginUnits.add(unit);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      this.pluginRawLinePatterns.push(...plugin.rawLinePatterns);\n    }\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   *\n   * This is the inverse of registerVocabulary(). All keywords, operators,\n   * and units registered by the plugin are removed. After\n   * unregistration, those tokens will revert to their default behavior\n   * (e.g., keywords become IDENT, operators become ERROR).\n   *\n   * Calling unregisterVocabulary with a plugin that was never registered\n   * is safe, it simply has no effect.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const keyword of Object.keys(plugin.keywords)) {\n        this.pluginKeywordMap.delete(keyword.toLowerCase());\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      for (const chars of Object.keys(plugin.operators)) {\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n          const inner = this.pluginOperators.get(first);\n          if (inner) {\n            inner.delete(second);\n            if (inner.size === 0) {\n              this.pluginOperators.delete(first);\n            }\n          }\n        }\n      }\n      this.hasPluginOps = this.pluginOperators.size > 0;\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        this.pluginUnits.delete(unit);\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      const toRemove = new Set(plugin.rawLinePatterns);\n      this.pluginRawLinePatterns = this.pluginRawLinePatterns.filter((r) => !toRemove.has(r));\n    }\n  }\n\n  reset(input: string): void {\n    this.input = input;\n    this.pos = 0;\n    this.len = input.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n    this.pendingRawLineToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(input) : null;\n  }\n\n  /**\n   * Scan a full document text in a single pass, classifying each line and\n   * tokenizing non-skipped lines.\n   *\n   * Replaces the separate classifyLine() + findInlineSolves() + per-line\n   * reset() + tokenizeAll() pattern with a single character-by-character\n   * walk through the entire document. Key benefits:\n   *\n   * - **Single reset()**: `this.pos`, `this.len`, `this.line`, and\n   *   `this.lineStartPos` are set once for the whole document, not per-line.\n   * - **Single classification**: classifyLine() runs once per line inline;\n   *   skipped lines are jumped over without tokenization.\n   * - **Shared tokenization**: Non-skipped lines are tokenized using the\n   *   existing state machine, yielding Token[] without per-line reset().\n   * - **Inline solve detection**: findInlineSolves() is called only for\n   *   lines that classifyLine() marks as having inline solves.\n   *\n   * Tokenization is scoped to each line by temporarily restricting\n   * `this.len` to the line end position, so the [Symbol.iterator]\n   * generator naturally stops at the line boundary. After tokenization,\n   * `this.len` is restored and `this.pos` advances past the newline.\n   *\n   * @param text The full document text (with newlines).\n   * @returns Array of ScanLineResult, one per line, in document order.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    this.input = text;\n    this.pos = 0;\n    this.len = text.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n\n    const results: ScanLineResult[] = [];\n    const input = this.input;\n    const docLen = this.len;\n\n    while (this.pos < docLen) {\n      const lineStart = this.pos;\n\n      // ── Find end of current line (newline boundary) ───────────────\n      let lineEnd = this.pos;\n      while (lineEnd < docLen) {\n        const cc = input.charCodeAt(lineEnd);\n        if (cc === 10 || cc === 13) break;  // \\n or \\r\n        lineEnd++;\n      }\n\n      const lineNumber = this.line;\n\n      // ── Classify the line ─────────────────────────────────────────\n      // Uses classifyFromPositions() to read from this.input directly\n      // avoids allocating a substring and keeps classification reads\n      // within the same memory region as tokenization.\n      const classification = this.classifyFromPositions(lineStart, lineEnd);\n\n      // ── Slice line text for ScanLineResult.text ────────────────\n      // Hoisted above tokenization (rather than after, as originally) so the\n      // raw-line-pattern check below can test the exact substring a plugin\n      // registered via `LexerVocabulary.rawLinePatterns`. See reset()/\n      // tokenizeAll() for the single-expression-string equivalent of this\n      // same check.\n      const lineText = input.slice(lineStart, lineEnd);\n\n      // ── Tokenize non-skipped lines ────────────────────────────────\n      let tokens: Token[] = [];\n      if (!classification.skip) {\n        const rawToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(lineText) : null;\n        if (rawToken) {\n          tokens = [rawToken];\n        } else {\n          // Scope tokenization to just this line by temporarily restricting len.\n          // The [Symbol.iterator]() generator captures `this.len` at call time,\n          // so creating the iterator AFTER setting this.len = lineEnd ensures\n          // tokenization stops at the line boundary. After tokenization,\n          // this.pos will be at lineEnd (the newline position).\n          const savedLen = this.len;\n          this.len = lineEnd;\n          tokens = Array.from(this);\n          this.len = savedLen;\n          // this.pos is now at lineEnd, advance past newline below\n        }\n      }\n\n      // ── Detect inline solves ──────────────────────────────────────\n      // Two data sources are merged:\n      //   1. _inlineSolveSpans, token indices collected inline during\n      //      [Symbol.iterator](). Provides correct startTokenIndex /\n      //      endTokenIndex. Also handles \\` escape (skips the pair\n      //      instead of closing the span early).\n      //   2. findInlineSolves(), character-level string scan for\n      //      expression text. Still needed because token-based\n      //      reconstruction loses whitespace (the lexer skips spaces),\n      //      which breaks multi-word expressions like\n      //      \"2 weeks in days\" → \"2weeksindays\" (wrong tokenization).\n      let inlineSolves: InlineSolveSpan[] = [];\n      if (classification.hasInlineSolve) {\n        if (!classification.skip && tokens.length > 0) {\n          const charSpans = this.findInlineSolves(lineText);\n          inlineSolves = this._inlineSolveSpans.map((span, i) => ({\n            start: charSpans[i]?.start ?? 0,\n            end: charSpans[i]?.end ?? 0,\n            expression: charSpans[i]?.expression ?? '',\n            columnNumber: charSpans[i]?.columnNumber ?? span.columnNumber,\n            startTokenIndex: span.startTokenIndex,\n            endTokenIndex: span.endTokenIndex,\n          }));\n        } else {\n          // Skipped lines weren't tokenized, fall back to string scan\n          inlineSolves = this.findInlineSolves(lineText);\n        }\n      }\n\n      results.push({\n        text: lineText,\n        lineNumber,\n        startOffset: lineStart,\n        endOffset: lineEnd,\n        classification,\n        tokens,\n        inlineSolves,\n      });\n\n      // ── Advance past newline ─────────────────────────────────────\n      this.pos = lineEnd;\n      if (this.pos < docLen) {\n        const nlChar = input.charCodeAt(this.pos);\n        if (nlChar === 13) {  // \\r\n          this.pos++;\n          if (this.pos < docLen && input.charCodeAt(this.pos) === 10) {\n            this.pos++;  // skip \\n in \\r\\n\n          }\n        } else if (nlChar === 10) {  // \\n\n          this.pos++;\n        }\n      }\n      this.line++;\n      this.lineStartPos = this.pos;\n    }\n\n    return results;\n  }\n\n  /**\n   * Tokenize an expression string into an array of Tokens.\n   *\n   * Delegates to the lazy [Symbol.iterator]() generator and collects all\n   * yielded tokens via Array.from(). For memory-sensitive use cases, prefer\n   * iterating the lexer directly with for...of to avoid array allocation.\n   *\n   * Optimizations:\n   *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers\n   *  - Direct character-code dispatch (c0 cached pattern)\n   *  - Mathematical digit parsing (integer math, not slice+parseFloat)\n   *  - Inline operator tokenizer with two-char peek-ahead\n   *  - Whitespace eliminated in-lexer (never emitted)\n   *  - 0-char and 1-char fast paths\n   */\n  tokenizeAll(): Token[] {\n    if (this.pendingRawLineToken) {\n      this._inlineSolveSpans = [];\n      return [this.pendingRawLineToken];\n    }\n    return Array.from(this);\n  }\n\n  // ── Lazy iterator ─────────────────────────────────────────────────────\n  /**\n   * Lazy token-by-token generator. Yields each token without allocating an\n   * intermediate Token[] array. Supports for...of and spread usage.\n   *\n   * Usage:\n   *   for (const t of lexer) { ... }  // lazy, no array allocation\n   *   const tokens = [...lexer];       // materializes via spread\n   *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()\n   *\n   * IMPORTANT: This generator captures `this.len` ONCE at creation time\n   * (const len = this.len). `scanDocument()` relies on this behavior to\n   * scope tokenization to a single line by temporarily restricting\n   * `this.len` to the line end position before creating the iterator.\n   * Do NOT refactor to re-read `this.len` mid-loop without also updating\n   * `scanDocument()`.\n   */\n  *[Symbol.iterator](): Generator<Token, void, undefined> {\n    const len = this.len;\n\n    // ── 0-char fast path ────────────────────────────────────────────────\n    if (len === 0) { this._inlineSolveSpans = []; return; }\n\n    // Inline solve tracking state, collected inline during tokenization\n    let tokenIndex = 0;\n    let openSpan: { startTokenIndex: number; startColumn: number } | null = null;\n    const collectedSpans: InlineSolveSpan[] = [];\n\n    // ── 1-char fast path ────────────────────────────────────────────────\n    if (len === 1) {\n      const c0 = this.input.charCodeAt(0);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      switch (cc) {\n        case CharClass.DIGIT:\n        case CharClass.DOT:\n          yield new LexerToken('NUMBER', tokenTypeId('NUMBER'), this.input, this.input, 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.ALPHA: {\n          const input = this.input;\n          const identLower = input.toLowerCase();\n          // Use pre-merged collections (built-in + plugin), single lookup each\n          if (this.mergedUnits.has(input)) {\n            yield new LexerToken('UNIT', tokenTypeId('UNIT'), input, input, 0, 0, 1, 1);\n          } else {\n            const kwType = this.mergedKeywords.get(identLower);\n            if (kwType) {\n              yield new LexerToken(kwType, tokenTypeId(kwType), input, input, 0, 0, 1, 1);\n            } else {\n              yield new LexerToken('IDENT', tokenTypeId('IDENT'), input, input, 0, 0, 1, 1);\n            }\n          }\n          tokenIndex++;\n          break;\n        }\n\n        case CharClass.OPERATOR: {\n          const opType = OP_MAP[c0];\n          if (opType) {\n            yield new LexerToken(opType, tokenTypeId(opType), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n\n        case CharClass.QUOTE:\n          // Delegate to tokenizeString for correctness (handles unterminated)\n          this.pos = 0;\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        case CharClass.HASH:\n          // Delegate to tokenizeComment for correctness\n          this.pos = 0;\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        case CharClass.DOLLAR:\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.BACKTICK:\n          // s` is 2 chars, openSpan can never be set in the 1-char fast path\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        default: {\n          // CharClass.SKIP, includes non-ASCII characters (code >= 128)\n          if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility\n            yield new LexerToken('IDENT', tokenTypeId('IDENT'), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n      }\n      this._inlineSolveSpans = collectedSpans;\n      return;\n    }\n\n    const input = this.input;\n\n    // ── Main tokenization loop ──────────────────────────────────────────\n    while (this.pos < len) {\n      const c0 = input.charCodeAt(this.pos);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      // ── Escaped backtick inside inline solve ────────────────────────\n      // \\` is treated as an escaped backtick, skip both characters\n      // without closing the inline solve span. Without this, the\n      // backtick would close the span early, producing wrong expression\n      // text for expressions like s`hello \\` world`.\n      if (openSpan && c0 === 92 && this.pos + 1 < len && input.charCodeAt(this.pos + 1) === 96) {\n        this.pos += 2;  // skip \\ and `\n        continue;\n      }\n\n      switch (cc) {\n        // ── Whitespace, skip entirely, track newlines ────────────────\n        case CharClass.WHITESPACE:\n          this.pos++;\n          if (c0 === 10) {  // \\n\n            this.line++;\n            this.lineStartPos = this.pos;\n          } else if (c0 === 13) {  // \\r\n            this.line++;\n            if (this.pos < len && input.charCodeAt(this.pos) === 10) {\n              this.pos++;  // skip \\n in \\r\\n\n            }\n            this.lineStartPos = this.pos;\n          }\n          break;\n\n        // ── Digit, inline number tokenizer ───────────────────────────\n        case CharClass.DIGIT:\n          yield this.tokenizeNumber();\n          tokenIndex++;\n          break;\n\n        // ── Alpha / underscore, identifier or keyword ────────────────\n        case CharClass.ALPHA: {\n          const token = this.tokenizeIdentifier();\n          if (token.type === 'INLINE_SOLVE_START') {\n            openSpan = { startTokenIndex: tokenIndex, startColumn: token.col };\n          }\n          yield token;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Dot, could be decimal (.5) or DOT token ─────────────────\n        case CharClass.DOT:\n          if (this.pos + 1 < len) {\n            const nextCc = ExpressionLexer.CHAR_CLASS[input.charCodeAt(this.pos + 1)] ?? CharClass.SKIP;\n            if (nextCc === CharClass.DIGIT) {\n              yield this.tokenizeNumber();\n            } else {\n              const col = this.pos - this.lineStartPos + 1;\n              yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n              this.pos++;\n            }\n          } else {\n            const col = this.pos - this.lineStartPos + 1;\n            yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n            this.pos++;\n          }\n          tokenIndex++;\n          break;\n\n        // ── Operator / punctuation ────────────────────────────────────\n        case CharClass.OPERATOR:\n          yield this.tokenizeOperator();\n          tokenIndex++;\n          break;\n\n        // ── String literal ────────────────────────────────────────────\n        case CharClass.QUOTE:\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        // ── Comment (# or //) ─────────────────────────────────────────\n        case CharClass.HASH:\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        // ── Dollar sign $ ─────────────────────────────────────────────\n        case CharClass.DOLLAR: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', this.pos, 0, this.line, col);\n          this.pos++;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Backtick ` ───────────────────────────────────────────────\n        case CharClass.BACKTICK: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', this.pos, 0, this.line, col);\n          this.pos++;\n          if (openSpan) {\n            const span = openSpan;  // narrow for TS\n            collectedSpans.push({\n              start: 0, end: 0, expression: '',\n              columnNumber: span.startColumn,\n              startTokenIndex: span.startTokenIndex,\n              endTokenIndex: tokenIndex,\n            });\n            openSpan = null;\n          }\n          tokenIndex++;\n          break;\n        }\n\n        // ── Non-ASCII characters ─────────────────────────────────────\n        default: {\n          const col = this.pos - this.lineStartPos + 1;\n          if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility.\n            // tokenizeIdentifier() now includes cc >= 128 in its reading loop,\n            // so this properly advances past all consecutive Unicode chars.\n            yield this.tokenizeIdentifier();\n            tokenIndex++;\n          } else {\n            // Unknown ASCII, silently skip\n            this.pos++;\n          }\n          break;\n        }\n      }\n    }\n    this._inlineSolveSpans = collectedSpans;\n  }\n\n  // ── Inline number tokenizer ────────────────────────────────────────────\n  /**\n   * Character-by-character number parsing.\n   *\n   * Supports: integers, floats, scientific notation (1.5e10, 1.5e-10),\n   * hex (0xFF), binary (0b1010), octal (0o17), BigInt suffix (123n),\n   * thousands separators (1,234 or 1.234.567).\n   *\n   * Returns a LexerToken and advances `this.pos` past the number.\n   */\n  private tokenizeNumber(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // ── Hex literal: 0x / 0X ───────────────────────────────────────────\n    if (input.charCodeAt(pos) === 48 && pos + 1 < len) {\n      const next = input.charCodeAt(pos + 1);\n      if (next === 0x78 || next === 0x58) {  // 'x' or 'X'\n        pos += 2;\n        while (\n          pos < len &&\n          ((cc = input.charCodeAt(pos)),\n            (cc >= 48 && cc <= 57) || (cc >= 65 && cc <= 70) || (cc >= 97 && cc <= 102))\n        ) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Binary literal: 0b / 0B ─────────────────────────────────────\n      if (next === 0x62 || next === 0x42) {  // 'b' or 'B'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc === 48 || cc === 49)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Octal literal: 0o / 0O ───────────────────────────────────────\n      if (next === 0x6F || next === 0x4F) {  // 'o' or 'O'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 55)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    let hasIntPart = false;\n\n    // ── Integer part ───────────────────────────────────────────────────\n    while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n      hasIntPart = true;\n      pos++;\n    }\n\n    // ── Thousands separators, coalesce with digits ────────────────────\n    while (hasIntPart && pos < len && (input.charCodeAt(pos) === 44 || input.charCodeAt(pos) === 46)) {\n      if (pos + 4 <= len) {\n        const d1 = input.charCodeAt(pos + 1);\n        const d2 = input.charCodeAt(pos + 2);\n        const d3 = input.charCodeAt(pos + 3);\n        // A genuine thousands group is always exactly 3 digits, followed\n        // by either another separator, or a non-digit (end of number,\n        // operator, unit, EOF), never a 4th consecutive digit. Without\n        // this check, a plain decimal fraction with 4+ digits after the\n        // point, e.g. \"0.0001\", had its first 3 fractional digits\n        // misread as a \".\" thousands-group, silently truncating the\n        // number to \"0.000\" and leaving the remaining digit(s) as a\n        // separate, unrelated NUMBER token right after it (so\n        // \"0.0001 BTC to USD\" tokenized as \"0.000\", \"1\", \"BTC\", \"to\",\n        // \"USD\", two number literals instead of one, and evaluated to\n        // a bare 0 instead of a real BTC quantity).\n        const d4 = pos + 4 < len ? input.charCodeAt(pos + 4) : -1;\n        const isGroupOfExactlyThree = !(d4 >= 48 && d4 <= 57);\n        if (\n          d1 >= 48 && d1 <= 57 &&\n          d2 >= 48 && d2 <= 57 &&\n          d3 >= 48 && d3 <= 57 &&\n          isGroupOfExactlyThree\n        ) {\n          pos += 4;\n          hasIntPart = true;\n          continue;\n        }\n      }\n      break;\n    }\n\n    // ── Decimal part (.xxx) ───────────────────────────────────────────\n    let hasDecimal = false;\n    if (pos < len && input.charCodeAt(pos) === 46) {\n      if (pos + 1 < len) {\n        const nextCc = input.charCodeAt(pos + 1);\n        if (nextCc >= 48 && nextCc <= 57) {\n          hasDecimal = true;\n          pos++;\n          while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n            pos++;\n          }\n        }\n      }\n    }\n\n    // ── Exponent (e / E [+-]? \\n+) ────────────────────────────────────\n    let hasExponent = false;\n    if (pos < len) {\n      const ec = input.charCodeAt(pos);\n      if (ec === 0x65 || ec === 0x45) {  // 'e' or 'E'\n        if (pos + 1 < len) {\n          const next = input.charCodeAt(pos + 1);\n          if (\n            (next >= 48 && next <= 57) ||\n            next === 43 || next === 45  // + or -\n          ) {\n            hasExponent = true;\n            pos++;\n            if (next === 43 || next === 45) pos++;\n            while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n              pos++;\n            }\n          }\n        }\n      }\n    }\n\n    // ── BigInt suffix check ────────────────────────────────────────────\n    if (pos < len && input.charCodeAt(pos) === 110) {  // 'n'\n      if (hasIntPart && !hasDecimal && !hasExponent) {\n        pos++;\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('BIGINT', tokenTypeId('BIGINT'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Emit NUMBER token ──────────────────────────────────────────────\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n  }\n\n  // ── Inline identifier / keyword tokenizer ──────────────────────────────\n  /**\n   * Reads [a-zA-Z_][a-zA-Z0-9_]* and resolves to:\n   *   - A unit type (via knownUnits, case-sensitive)\n   *   - A keyword type (via locale keywordMap, case-insensitive)\n   *   - IDENT if none of the above\n   *\n   * Multi-word phrases (e.g., \"to the power of\") are handled by the\n   * TokenNormalizer post-lexer pass, not the lexer.\n   */\n  private tokenizeIdentifier(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // Read [a-zA-Z0-9_]* plus any Unicode (>= 128) including emoji surrogate pairs.\n    // Without this, non-ASCII characters cause an infinite loop: the default case\n    // calls tokenizeIdentifier(), the while loop doesn't match the Unicode char,\n    // pos never advances, and the outer loop re-reads the same char forever.\n    while (\n      pos < len &&\n      ((cc = input.charCodeAt(pos)),\n        (cc >= 48 && cc <= 57) ||   // 0-9\n        (cc >= 65 && cc <= 90) ||   // A-Z\n        (cc >= 97 && cc <= 122) ||  // a-z\n        cc === 95 ||                 // _\n        cc >= 128)                   // Unicode (accented chars, emoji, etc.)\n    ) {\n      pos++;\n    }\n\n    const identText = input.slice(start, pos);\n    const identLower = identText.toLowerCase();\n\n    // ── Inline solve marker: s` (lowercase 's' followed by backtick) ──\n    if (identLower === 's' && pos < len && input.charCodeAt(pos) === 96) {\n      pos++;\n      this.pos = pos;\n      const fullText = input.slice(start, pos);\n      return new LexerToken('INLINE_SOLVE_START', tokenTypeId('INLINE_SOLVE_START'), fullText, fullText, start, 0, this.line, startCol);\n    }\n\n    // ── Unit lookup (case-sensitive)\n    const isKnownUnit = this.mergedUnits.has(identText);\n    if (isKnownUnit) {\n      if (!this.isFollowedByLParen(pos)) {\n        this.pos = pos;\n        return new LexerToken('UNIT', tokenTypeId('UNIT'), identText, identText, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Keyword lookup (case-insensitive)\n    const localeKwType = this.mergedKeywords.get(identLower);\n    if (localeKwType) {\n      this.pos = pos;\n      return new LexerToken(localeKwType, tokenTypeId(localeKwType), identText, identText, start, 0, this.line, startCol);\n    }\n\n    // ── Fall through: emit IDENT\n    // Multi-word phrases are now handled by the TokenNormalizer post-lexer pass,\n    // which keeps the lexer slim and focused on single-token production.\n    this.pos = pos;\n    return new LexerToken('IDENT', tokenTypeId('IDENT'), identText, identText, start, 0, this.line, startCol);\n  }\n\n  /**\n   * Peek past in-expression whitespace (space, tab) from `pos` to check\n   * if the next significant character is '('.\n   */\n  private isFollowedByLParen(pos: number): boolean {\n    const len = this.len;\n    let lookPos = pos;\n    while (lookPos < len) {\n      const cc = this.input.charCodeAt(lookPos);\n      if (cc === 40) return true;\n      if (cc !== 32 && cc !== 9) break;\n      lookPos++;\n    }\n    return false;\n  }\n\n  // ── Inline operator tokenizer ─────────────────────────────────────────\n  /**\n   * Reads an operator/punctuation token.\n   * Handles two-char operators (==, !=, >=, <=, **) and the special\n   * cases << (LSHIFT) and >> (RSHIFT).\n   */\n  private tokenizeOperator(): Token {\n    const input = this.input;\n    const pos = this.pos;\n    const col = pos - this.lineStartPos + 1;\n    const c0 = input.charCodeAt(pos);\n    const len = this.len;\n\n    // ── Two-character operators ────────────────────────────────────────\n    if (pos + 1 < len) {\n      const c1 = input.charCodeAt(pos + 1);\n\n      // ==, !=, >=, <=\n      const secondMap = TWO_CHAR_OPS[c0];\n      if (secondMap) {\n        const twoCharType = secondMap[c1];\n        if (twoCharType) {\n          const text = input.slice(pos, pos + 2);\n          this.pos = pos + 2;\n          return new LexerToken(twoCharType, tokenTypeId(twoCharType), text, text, pos, 0, this.line, col);\n        }\n      }\n\n      // // comment\n      if (c0 === 47 && c1 === 47) {\n        let commentPos = pos + 2;\n        while (commentPos < len) {\n          const cc = input.charCodeAt(commentPos);\n          if (cc === 10 || cc === 13) break;\n          commentPos++;\n        }\n        const text = input.slice(pos, commentPos);\n        this.pos = commentPos;\n        return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, pos, 0, this.line, col);\n      }\n\n      // << (LSHIFT), >> (RSHIFT) and >>> (URSHIFT).\n      //\n      // >>> is tested before >>, or the two-char match would consume the first\n      // two angle brackets and leave a stray > for the parser to choke on.\n      if (c0 === 60 && c1 === 60) {\n        this.pos = pos + 2;\n        return new LexerToken('LSHIFT', tokenTypeId('LSHIFT'), '<<', '<<', pos, 0, this.line, col);\n      }\n      if (c0 === 62 && c1 === 62) {\n        if (input.charCodeAt(pos + 2) === 62) {\n          this.pos = pos + 3;\n          return new LexerToken('URSHIFT', tokenTypeId('URSHIFT'), '>>>', '>>>', pos, 0, this.line, col);\n        }\n        this.pos = pos + 2;\n        return new LexerToken('RSHIFT', tokenTypeId('RSHIFT'), '>>', '>>', pos, 0, this.line, col);\n      }\n\n      // ── Plugin-registered two-char operators ──────────────────────\n      if (this.hasPluginOps) {\n        const pluginInner = this.pluginOperators.get(c0);\n        if (pluginInner) {\n          const pluginType = pluginInner.get(c1);\n          if (pluginType) {\n            const text = input.slice(pos, pos + 2);\n            this.pos = pos + 2;\n            return new LexerToken(pluginType, tokenTypeId(pluginType), text, text, pos, 0, this.line, col);\n          }\n        }\n      }\n    }\n\n    // ── Single-character operator ──────────────────────────────────────\n    this.pos = pos + 1;\n    const opType = OP_MAP[c0];\n    const text = input.charAt(pos);\n    return new LexerToken(opType || 'ERROR', tokenTypeId(opType || 'ERROR'), text, text, pos, 0, this.line, col);\n  }\n\n  // ── String literal tokenizer ──────────────────────────────────────────\n  /**\n   * Reads a double-quoted string literal. Supports backslash escapes.\n   */\n  private tokenizeString(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n    let pos = start + 1;\n    let lineBreaks = 0;\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 34) {\n        pos++;\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('STRING', tokenTypeId('STRING'), text, text, start, lineBreaks, this.line, startCol);\n      }\n      if (c0 === 92 && pos + 1 < len) {\n        pos += 2;\n        continue;\n      }\n      if (c0 === 10) {\n        this.line++;\n        this.lineStartPos = pos + 1;\n        lineBreaks++;\n      }\n      pos++;\n    }\n\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('STRING', tokenTypeId('STRING'), text, text, start, lineBreaks, this.line, startCol);\n  }\n\n  // ── Markdown line scanner (Phase B) ───────────────────────────────────\n\n  /**\n   * L1 expression gating: quickly determine if a line contains any\n   * characters that indicate an expression (digits, operators, currency,\n   * backticks, parentheses, etc.).\n   *\n   * Pure prose lines (e.g., \"The quick brown fox jumps over the lazy dog\")\n   * return false and can be skipped without full tokenization (L2).\n   *\n   * This is a fast character-by-character scan that stops at the first\n   * expression indicator. Called once per line in classifyFromPositions().\n   */\n  static hasExpressionIndicators(input: string, start: number, end: number): boolean {\n    const indicatorCodes = EXPRESSION_INDICATOR_CODES;\n    for (let i = start; i < end; i++) {\n      const cc = input.charCodeAt(i);\n      // Check digits and operators via pre-computed Set (O(1) lookup)\n      if (indicatorCodes.has(cc)) return true;\n      // Unicode math/currency symbols (≥ 128, not in the 128-byte table)\n      if (cc >= 128) {\n        // ×, ÷, ≠, £, €, ¥, ₽, ₩, common expression symbols\n        if (cc === 0x00D7 || cc === 0x00F7 || cc === 0x2260 ||\n            cc === 0x00A3 || cc === 0x20AC ||\n            cc === 0x00A5 || cc === 0x20BD || cc === 0x20A9) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Classify a line by its character positions within this.input.\n   * Reads directly from this.input using start/end boundaries.\n   * DOES NOT modify this.pos, purely a read-only classifier.\n   */\n  private classifyFromPositions(start: number, end: number): LineClassification {\n    const len = end;\n\n    if (start >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const input = this.input;\n    let pos = start;\n\n    while (pos < len) {\n      const cc = input.charCodeAt(pos);\n      if (cc !== 32 && cc !== 9) break;\n      pos++;\n    }\n\n    if (pos >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const c0 = input.charCodeAt(pos);\n    let hasInline: boolean | undefined;\n\n    // ── Heading: #{1,6} ' ' ──────────────────────────────────────────\n    if (c0 === 35) {\n      let hashCount = 1;\n      while (pos + hashCount < len && input.charCodeAt(pos + hashCount) === 35) {\n        hashCount++;\n      }\n      if (hashCount <= 6 && pos + hashCount < len && input.charCodeAt(pos + hashCount) === 32) {\n        return { type: 'heading', skip: true, hasInlineSolve: false };\n      }\n      return { type: 'heading', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Blockquote: > ' ' ────────────────────────────────────────────\n    if (c0 === 62) {\n      if (pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n        return { type: 'blockquote', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Code fence: ``` or ~~~ ────────────────────────────────────────\n    if (c0 === 96 && pos + 2 < len && input.charCodeAt(pos + 1) === 96 && input.charCodeAt(pos + 2) === 96) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 126 && pos + 2 < len && input.charCodeAt(pos + 1) === 126 && input.charCodeAt(pos + 2) === 126) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Math fence: $$ ────────────────────────────────────────────────\n    if (c0 === 36 && pos + 1 < len && input.charCodeAt(pos + 1) === 36) {\n      return { type: 'math_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Horizontal rule: ---, ***, ___ (3+ same char, then only whitespace)\n    if (c0 === 45 || c0 === 42 || c0 === 95) {\n      let count = 1;\n      while (pos + count < len && input.charCodeAt(pos + count) === c0) {\n        count++;\n      }\n      if (count >= 3) {\n        let trailPos = pos + count;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'hr', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Unordered list: - ' ', * ' ', + ' ' ──────────────────────────\n    if ((c0 === 45 || c0 === 42 || c0 === 43) && pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n      if (hasInline === undefined) {\n        const idx = input.indexOf('s`', pos);\n        hasInline = idx !== -1 && idx < len;\n      }\n      return { type: 'list', skip: false, hasInlineSolve: hasInline };\n    }\n\n    // ── Ordered list: \\n+ '. ' ────────────────────────────────────────\n    if (c0 >= 48 && c0 <= 57) {\n      let digitPos = pos;\n      while (digitPos < len && input.charCodeAt(digitPos) >= 48 && input.charCodeAt(digitPos) <= 57) {\n        digitPos++;\n      }\n      if (digitPos < len && input.charCodeAt(digitPos) === 46) {\n        if (digitPos + 1 < len && input.charCodeAt(digitPos + 1) === 32) {\n          if (hasInline === undefined) {\n            const idx = input.indexOf('s`', pos);\n            hasInline = idx !== -1 && idx < len;\n          }\n          return { type: 'list', skip: false, hasInlineSolve: hasInline };\n        }\n      }\n    }\n\n    // ── Table / table separator: | ────────────────────────────────────\n    if (c0 === 124) {\n      let tPos = pos + 1;\n      while (tPos < len) {\n        const tc = input.charCodeAt(tPos);\n        if (tc !== 45 && tc !== 58 && tc !== 124 && tc !== 32 && tc !== 9 && tc !== 13) break;\n        tPos++;\n      }\n      if (tPos >= len) {\n        return { type: 'table_separator', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Wikilink / embed: [[ or ![[ ───────────────────────────────────\n    if (c0 === 91 && pos + 1 < len && input.charCodeAt(pos + 1) === 91) {\n      const closePos = input.indexOf(']]', pos + 2);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n    if (c0 === 33 && pos + 2 < len && input.charCodeAt(pos + 1) === 91 && input.charCodeAt(pos + 2) === 91) {\n      const closePos = input.indexOf(']]', pos + 3);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Comment: // ──────────────────────────────────────────────────\n    if (c0 === 47 && pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      return { type: 'comment', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Default: expression or prose line ─────────────────────────────\n    if (c0 === 62) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'blockquote', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 45 || c0 === 42 || c0 === 43) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'list', skip: false, hasInlineSolve: false };\n    }\n    if (hasInline === undefined) {\n      const idx = input.indexOf('s`', pos);\n      hasInline = idx !== -1 && idx < len;\n    }\n\n    // Return expression, all non-markdown-structure lines are tokenized.\n    // (L1 prose gating removed: it incorrectly skipped keyword-only lines\n    // like \"pi\", single identifiers like \"hello\", and any line without\n    // digits/operators/currency. Can be re-added with keyword-awareness\n    // and proper test coverage.)\n    return { type: 'expression', skip: false, hasInlineSolve: hasInline };\n  }\n\n  /**\n   * Classify a single line of markdown text.\n   */\n  classifyLine(lineText: string): LineClassification {\n    const savedInput = this.input;\n    const savedLen = this.len;\n    const savedPos = this.pos;\n    this.input = lineText;\n    this.len = lineText.length;\n    this.pos = 0;\n    const result = this.classifyFromPositions(0, lineText.length);\n    this.input = savedInput;\n    this.len = savedLen;\n    this.pos = savedPos;\n    return result;\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes, locale keywords\n   * (`pi`, `sqrt`, `convert`, ...) merged with any plugin-contributed ones\n   * from `registerVocabulary()` (e.g. a package's custom keywords), mapped to\n   * the token type they lex to. A snapshot copy, not a live reference\n   * mutating the return value has no effect on the lexer.\n   */\n  getKeywords(): Record<string, string> {\n    return Object.fromEntries(this.mergedKeywords);\n  }\n\n  /**\n   * Find all inline solve markers in a line with precise coordinate mapping.\n   */\n  findInlineSolves(lineText: string): InlineSolveSpan[] {\n    const results: InlineSolveSpan[] = [];\n    const len = lineText.length;\n    let pos = 0;\n\n    while (pos < len) {\n      const sPos = lineText.indexOf('s`', pos);\n      if (sPos === -1) break;\n\n      const exprStart = sPos + 2;\n\n      let exprEnd = exprStart;\n      while (exprEnd < len) {\n        const cc = lineText.charCodeAt(exprEnd);\n        if (cc === 92 && exprEnd + 1 < len) {\n          exprEnd += 2;\n          continue;\n        }\n        if (cc === 96) break;\n        exprEnd++;\n      }\n\n      if (exprEnd >= len) {\n        exprEnd = len;\n      }\n\n      const expression = lineText.slice(exprStart, exprEnd);\n      const end = exprEnd < len ? exprEnd + 1 : exprEnd;\n\n      results.push({\n        start: sPos,\n        end,\n        expression,\n        columnNumber: sPos + 1,\n      });\n\n      pos = end;\n    }\n\n    return results;\n  }\n\n  // ── Comment tokenizer ─────────────────────────────────────────────────\n  /**\n   * Reads a comment: # to end of line, or // to end of line.\n   */\n  private tokenizeComment(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n    let pos = this.pos;\n\n    if (pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      pos += 2;\n    } else {\n      pos++;\n    }\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 10 || c0 === 13) break;\n      pos++;\n    }\n\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, start, 0, this.line, startCol);\n  }\n}"]}

package/dist/{chunk-6BKTCEUP.cjs → chunk-TY3TLZAW.cjs}

@@ -39,6 +39,9 @@ var TOKEN_CATEGORY_MAP = {
   ELSE: "keyword",
   AS: "keyword",
   CONVERTER_NAME: "keyword",
+  ROUNDED: "keyword",
+  TO_NEAREST: "keyword",
+  DECIMAL_PLACES: "keyword",
   AVERAGE_OF: "keyword",
   MEDIAN_OF: "keyword",
   TOTAL_OF: "keyword",
@@ -47,6 +50,14 @@ var TOKEN_CATEGORY_MAP = {
   SMALLER_OF: "keyword",
   HALF_OF: "keyword",
   MIDPOINT_BETWEEN: "keyword",
+  REMAINDER_OF: "keyword",
+  NTH_ROOT: "keyword",
+  LOG_PHRASE: "keyword",
+  LOG_BASE: "keyword",
+  GCD_OF: "keyword",
+  LCM_OF: "keyword",
+  SQUARE_ROOT_OF: "keyword",
+  CUBE_ROOT_OF: "keyword",
   CLAMP: "keyword",
   MAP: "keyword",
   REDUCE: "keyword",
@@ -73,6 +84,14 @@ var TOKEN_CATEGORY_MAP = {
   TIME_DIFFERENCE_BETWEEN: "keyword",
   CITY_NAME: "keyword",
   OVER: "keyword",
+  // The investment grammar's connectives (packages/finance/).
+  AFTER: "keyword",
+  PRESENT_VALUE_OF: "keyword",
+  ANNUAL_RETURN_ON: "keyword",
+  FOR_DURATION: "keyword",
+  COMPOUNDING: "keyword",
+  INVESTED: "keyword",
+  RETURNED: "keyword",
   RATE_AT: "keyword",
   COMPOUND_INTEREST_ON: "keyword",
   INTEREST_ON: "keyword",
@@ -86,7 +105,14 @@ var TOKEN_CATEGORY_MAP = {
   TOTAL_LOAN_INTEREST_ON: "keyword",
   TAX_ON: "keyword",
   TAX_OFF: "keyword",
+  TAX_IN_PHRASE: "keyword",
   IS_TO: "keyword",
+  IS: "keyword",
+  PCT_ON: "operator",
+  PCT_OFF: "operator",
+  OF_WHAT: "keyword",
+  OFF_WHAT: "keyword",
+  ON_WHAT: "keyword",
   RANDOM_NUMBER: "keyword",
   WHAT_IS: "keyword",
   WHAT_WAS: "keyword",
@@ -105,6 +131,10 @@ var TOKEN_CATEGORY_MAP = {
   MONTH_ON: "keyword",
   MONTH_IN: "keyword",
   WEEK_ON: "keyword",
+  DAYS_IN_PERIOD: "keyword",
+  IN_TWO_UNITS: "unit",
+  PER_UNIT: "unit",
+  AT_RATE: "keyword",
   WEEK_IN: "keyword",
   BETWEEN_UNIT: "keyword",
   IS_WEEKEND: "keyword",
@@ -117,6 +147,10 @@ var TOKEN_CATEGORY_MAP = {
   AT: "keyword",
   // Arithmetic / assignment-style operators
   PLUS: "operator",
+  // The word "and". An operator rather than a keyword: it adds, and syntax
+  // highlighting that painted it as a keyword would make "5 and 3" look
+  // structurally different from "5 + 3" when the two mean the same thing.
+  AND_CONJ: "operator",
   MINUS: "operator",
   STAR: "operator",
   SLASH: "operator",
@@ -229,5 +263,5 @@ exports.UNCATEGORIZED_TOKEN_TYPES = UNCATEGORIZED_TOKEN_TYPES;
 exports.getTokenCategory = getTokenCategory;
 exports.registerTokenCategory = registerTokenCategory;
 exports.unregisterTokenCategory = unregisterTokenCategory;
-//# sourceMappingURL=chunk-6BKTCEUP.cjs.map
-//# sourceMappingURL=chunk-6BKTCEUP.cjs.map
+//# sourceMappingURL=chunk-TY3TLZAW.cjs.map
+//# sourceMappingURL=chunk-TY3TLZAW.cjs.map