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

package/dist/chunk-RIN643A3.js

@@ -0,0 +1,354 @@
+// src/lexer/Token.ts
+var TokenTypes = {
+  NUMBER: "NUMBER",
+  BIGINT: "BIGINT",
+  STRING: "STRING",
+  IDENT: "IDENT",
+  PLUS: "PLUS",
+  MINUS: "MINUS",
+  STAR: "STAR",
+  SLASH: "SLASH",
+  CARET: "CARET",
+  PERCENT: "PERCENT",
+  LSHIFT: "LSHIFT",
+  RSHIFT: "RSHIFT",
+  URSHIFT: "URSHIFT",
+  LPAREN: "LPAREN",
+  RPAREN: "RPAREN",
+  LBRACKET: "LBRACKET",
+  RBRACKET: "RBRACKET",
+  LBRACE: "LBRACE",
+  RBRACE: "RBRACE",
+  COMMA: "COMMA",
+  DOT: "DOT",
+  COLON: "COLON",
+  SEMICOLON: "SEMICOLON",
+  EQUALS: "EQUALS",
+  DOLLAR: "DOLLAR",
+  POUND: "POUND",
+  EURO: "EURO",
+  YEN: "YEN",
+  RUBLE: "RUBLE",
+  WON: "WON",
+  QUESTION: "QUESTION",
+  BANG: "BANG",
+  BIT_AND: "BIT_AND",
+  BIT_OR: "BIT_OR",
+  BIT_NOT: "BIT_NOT",
+  KEYWORD: "KEYWORD",
+  EOF: "EOF",
+  ERROR: "ERROR",
+  WS: "WS",
+  NEWLINE: "NEWLINE",
+  DATETIME_LITERAL: "DATETIME_LITERAL",
+  DURATION: "DURATION",
+  UNIT: "UNIT",
+  ROLL: "ROLL",
+  PI: "PI",
+  E: "E",
+  MOD: "MOD",
+  OF: "OF",
+  INCREASE_BY: "INCREASE_BY",
+  DECREASE_BY: "DECREASE_BY",
+  // Percentage solve-for-unknown (packages/percentage/), "N% of what is
+  // X" solves N% * base = X for base. Fused as a full 3-word phrase (see
+  // PercentagePackage.ts's `phrases` field) rather than a bare "what"
+  // keyword, "what" is common enough as a variable name to be worth the
+  // same phrase-fusion treatment this codebase gives "total"/"average"/etc.
+  OF_WHAT_IS: "OF_WHAT_IS",
+  // Sibling solve-for-unknown forms accounting for a +/-1 offset, "N% on
+  // what is X" (increase) / "N% off what is X" (decrease). Same
+  // phrase-fusion reasoning as OF_WHAT_IS above.
+  ON_WHAT_IS: "ON_WHAT_IS",
+  OFF_WHAT_IS: "OFF_WHAT_IS",
+  NOW: "NOW",
+  TODAY: "TODAY",
+  TOMORROW: "TOMORROW",
+  YESTERDAY: "YESTERDAY",
+  DURATION_DAY: "DURATION_DAY",
+  DURATION_WEEK: "DURATION_WEEK",
+  DURATION_MONTH: "DURATION_MONTH",
+  DURATION_YEAR: "DURATION_YEAR",
+  DURATION_HOUR: "DURATION_HOUR",
+  DURATION_MINUTE: "DURATION_MINUTE",
+  DURATION_SECOND: "DURATION_SECOND",
+  FUNC: "FUNC",
+  CONVERT: "CONVERT",
+  TO: "TO",
+  BEST: "BEST",
+  NEXT: "NEXT",
+  LAST: "LAST",
+  UNTIL: "UNTIL",
+  SINCE: "SINCE",
+  BETWEEN: "BETWEEN",
+  FROM: "FROM",
+  INCREASE: "INCREASE",
+  DECREASE: "DECREASE",
+  UNICODE_MATH: "UNICODE_MATH",
+  TIMES_BY: "TIMES_BY",
+  MULTIPLY_BY: "MULTIPLY_BY",
+  DIVIDE_BY: "DIVIDE_BY",
+  NEQ: "NEQ",
+  IN: "IN",
+  BIT_XOR: "BIT_XOR",
+  EQUALITY: "EQUALITY",
+  GTE: "GTE",
+  LTE: "LTE",
+  LT: "LT",
+  GT: "GT",
+  LOGICAL_AND: "LOGICAL_AND",
+  LOGICAL_OR: "LOGICAL_OR",
+  OR: "OR",
+  TRUE: "TRUE",
+  FALSE: "FALSE",
+  IF: "IF",
+  THEN: "THEN",
+  ELSE: "ELSE",
+  AS: "AS",
+  CONVERTER_NAME: "CONVERTER_NAME",
+  // 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
+  // has a tested policy that colon-prefixed variable names can't be
+  // keyword-shaped words (see VariableParselet.ts's doc comment). Fusing
+  // the full "<word> of"/"<word> between" phrase means the bare word
+  // itself never becomes its own token type, so ":total = ..." keeps
+  // working exactly as before.
+  AVERAGE_OF: "AVERAGE_OF",
+  MEDIAN_OF: "MEDIAN_OF",
+  TOTAL_OF: "TOTAL_OF",
+  COUNT_OF: "COUNT_OF",
+  LARGER_OF: "LARGER_OF",
+  SMALLER_OF: "SMALLER_OF",
+  HALF_OF: "HALF_OF",
+  MIDPOINT_BETWEEN: "MIDPOINT_BETWEEN",
+  RANDOM_NUMBER: "RANDOM_NUMBER",
+  IS_TO: "IS_TO",
+  // 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
+  // ClampParselet.ts is hand-written instead of PhrasePattern-based).
+  // Matches this codebase's existing accepted risk for "between"/"from"/
+  // "next"/"last"/"best", also bare, also can't be used as `:name`.
+  CLAMP: "CLAMP",
+  // map/reduce/sum/prod (packages/mapreduce/), bare single-word keywords
+  // each with its own dedicated parselet (custom argument grammar: a bare
+  // builtin/user-function name, an inline transform expression, or
+  // `name=collection` zipped pairs, none of which fit the ordinary
+  // FunctionCallParselet path, so these can't just reuse the generic FUNC
+  // token type the way sqrt/abs/... do).
+  MAP: "MAP",
+  REDUCE: "REDUCE",
+  SUM_FN: "SUM_FN",
+  PROD_FN: "PROD_FN",
+  // The algebra verbs (packages/symbolic/), fused from an ordinary IDENT only
+  // when immediately followed by `(`, so `factor`/`solve`/`expand` stay usable
+  // as variable names. Declared here rather than left to be minted on first use
+  // by `tokenTypeId()`, which is what {@link registerAllTokenTypes} exists for:
+  // a lazily-minted id depends on what else happened to be minted before it, so
+  // in a single-process run the id a normalizer rule produces can stop matching
+  // the id the parselet was registered under. Every token type a built-in
+  // package relies on belongs in this table.
+  EXPAND_FN: "EXPAND_FN",
+  FACTOR_FN: "FACTOR_FN",
+  SOLVE_FN: "SOLVE_FN",
+  DER_FN: "DER_FN",
+  INTEGRAL_FN: "INTEGRAL_FN",
+  TAYLOR_FN: "TAYLOR_FN",
+  JACOBIAN_FN: "JACOBIAN_FN",
+  CONJ_FN: "CONJ_FN",
+  RE_FN: "RE_FN",
+  IM_FN: "IM_FN",
+  CANCEL_FN: "CANCEL_FN",
+  APART_FN: "APART_FN",
+  // The imaginary-literal suffix, fused from a number followed immediately by
+  // `i`. Same registration reasoning as the verbs above.
+  IMAGINARY: "IMAGINARY",
+  // `=>`, "therefore"/solve operator. The algebra itself lives in symbolic/;
+  // packages/symbolic/ carries the grammar surface for the named operations.
+  // A genuine 2-char lexer token (ExpressionLexer.ts's TWO_CHAR_OPS table),
+  // same mechanism as ==/!=/>=/<=, not a normalizer-level fusion, "=" then
+  // ">" is the opposite char order from GTE's ">=", so there's no collision.
+  THEREFORE: "THEREFORE",
+  // Timezone query phrases (see TimePackage.ts's `phrases` field). Same
+  // phrase-fusion reasoning as above: "time"/"date"/"difference" are
+  // common variable names, so the fused trigger is the full phrase.
+  // CITY_NAME is the fused-token type for multi-word city/country names
+  // (e.g. "new york"). See timezones/CityZones.ts's MULTI_WORD_CITY_ZONES.
+  TIME_IN: "TIME_IN",
+  DATE_IN: "DATE_IN",
+  TIME_DIFFERENCE_BETWEEN: "TIME_DIFFERENCE_BETWEEN",
+  CITY_NAME: "CITY_NAME",
+  BACKTICK_OPEN: "BACKTICK_OPEN",
+  INLINE_SOLVE_START: "INLINE_SOLVE_START",
+  // Comment marker, `#` or `//` to end of line. Emitted by
+  // ExpressionLexer.tokenizeComment()/tokenizeOperator() but never reaches
+  // a parselet: ExpressionEngine.prepareExpression() filters COMMENT
+  // tokens out of the stream before normalization/parsing (see
+  // ExpressionEngine.ts's "Filter COMMENT tokens" comments). Listed here
+  // for discoverability even though tokenTypeId() would lazily register
+  // it anyway on first use.
+  COMMENT: "COMMENT",
+  // Vector types (referenced in locale keywordMap as vec2→VEC2, etc.)
+  VEC2: "VEC2",
+  VEC3: "VEC3",
+  VEC4: "VEC4",
+  FLOAT: "FLOAT",
+  GLOBAL: "GLOBAL",
+  // ── Finance (packages/finance/) ──
+  // OVER/RATE_AT are bare single-word keywords (not phrase-fused): both are
+  // prepositions with near-zero plausibility as a variable name (nobody
+  // writes ":over = 5" or ":at = 3"), the same accepted-risk category as
+  // this codebase's existing bare "between"/"from"/"next"/"last"/"best"
+  // keywords (see VariableParselet.ts's doc comment). RATE_AT is deliberately
+  // NOT named "AT", that name is already reserved (dormant) for a future
+  // "@" symbol token in TokenNormalizer.NON_WORD_NAMES; reusing it here would
+  // create an unintended coupling if "@" is ever wired up.
+  OVER: "OVER",
+  RATE_AT: "RATE_AT",
+  // 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
+  // (a shipped playground example uses ":total = :subtotal + :tax". See
+  // MathPhrasesPackage.ts's doc comment for the regression this caused
+  // once already). Fusing the full "<word> on"/"<word> off" phrase means
+  // the bare leading word itself never becomes its own token type, so
+  // ":tax = ..." keeps working exactly as before.
+  COMPOUND_INTEREST_ON: "COMPOUND_INTEREST_ON",
+  INTEREST_ON: "INTEREST_ON",
+  DAILY_REPAYMENT_ON: "DAILY_REPAYMENT_ON",
+  MONTHLY_REPAYMENT_ON: "MONTHLY_REPAYMENT_ON",
+  ANNUAL_REPAYMENT_ON: "ANNUAL_REPAYMENT_ON",
+  TOTAL_REPAYMENT_ON: "TOTAL_REPAYMENT_ON",
+  DAILY_LOAN_INTEREST_ON: "DAILY_LOAN_INTEREST_ON",
+  MONTHLY_LOAN_INTEREST_ON: "MONTHLY_LOAN_INTEREST_ON",
+  ANNUAL_LOAN_INTEREST_ON: "ANNUAL_LOAN_INTEREST_ON",
+  TOTAL_LOAN_INTEREST_ON: "TOTAL_LOAN_INTEREST_ON",
+  TAX_ON: "TAX_ON",
+  TAX_OFF: "TAX_OFF",
+  // 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"
+  // are all plausible variable names, so only the full phrases are
+  // ever claimed as keywords, never the bare leading word.
+  WHAT_IS: "WHAT_IS",
+  WHAT_WAS: "WHAT_WAS",
+  VALUE_OF: "VALUE_OF",
+  WORTH_IN: "WORTH_IN",
+  // Bare single-word keyword (not phrase-fused) -- "assuming" has
+  // near-zero plausibility as a variable name, the same accepted-risk
+  // category as this codebase's existing bare "over"/"at" keywords
+  // (see the OVER/RATE_AT comment above). Registered so its bare word
+  // is a recognized phrase-starter (`canStartPhrase`), which suppresses
+  // implicit-multiply insertion between the futureYear NUMBER and this
+  // word in "value of $X in <year> assuming N% inflation" -- without
+  // this, "<year> assuming" was silently rewritten to "<year> *
+  // assuming" before parsing ever ran.
+  ASSUMING: "ASSUMING",
+  // Fused by a custom NormalizerRule (not `phrases`), carrying the
+  // year as its value -- see
+  // finance/normalizer/InYearDollarsNormalizerRule.ts.
+  IN_YEAR_DOLLARS: "IN_YEAR_DOLLARS",
+  // Cooking/UoM (packages/uom/) -- fused ingredient name (single- or
+  // multi-word, e.g. "butter"/"olive oil") carrying the matched name
+  // as its value. NOT a bare-word phrase-trie keyword -- see
+  // uom/normalizer/IngredientNameNormalizerRule.ts's doc comment for
+  // why this is a context-sensitive NormalizerRule instead (so a bare
+  // `:butter = 5` variable definition is completely unaffected).
+  INGREDIENT_NAME: "INGREDIENT_NAME",
+  // ── Datetime, workdays/weekdays/timestamps (packages/datetime/) ──
+  // Fused phrase tokens (see DatetimePackage.ts's `phrases` field)
+  // deliberately NOT bare single-word keywords: "workdays"/"weekday"/
+  // "timestamp"/"date" are all plausible variable names, same
+  // reasoning/regression risk as MathPhrasesPackage.ts's "total" note and
+  // FinancePackage.ts's "tax" note above. Fusing the full phrase means the
+  // bare leading word itself never becomes its own token type, so e.g.
+  // ":timestamp = 5" keeps working.
+  WORKDAYS_IN: "WORKDAYS_IN",
+  WEEKDAY_ON: "WEEKDAY_ON",
+  CURRENT_TIMESTAMP: "CURRENT_TIMESTAMP",
+  TO_DATE: "TO_DATE",
+  TO_TIMESTAMP: "TO_TIMESTAMP",
+  // Natural-question forms over the same date fields, "what day is it in
+  // 30 days", "what month is it on 25/12/2026", "what week is it". Each is
+  // a fully-fused phrase for the same reason as WEEKDAY_ON above: claiming
+  // bare "day"/"month"/"week" as keywords would break ":day = 5" and
+  // collide with the UNIT tokens of the same name.
+  WEEKDAY_IN: "WEEKDAY_IN",
+  MONTH_ON: "MONTH_ON",
+  MONTH_IN: "MONTH_IN",
+  WEEK_ON: "WEEK_ON",
+  WEEK_IN: "WEEK_IN",
+  // `<unit> between <date> and <date>`, fused UNIT+BETWEEN, exactly like
+  // UNTIL_UNIT/SINCE_UNIT above.
+  BETWEEN_UNIT: "BETWEEN_UNIT",
+  // Postfix day-type predicates, "<date> is a weekend" / "is a workday".
+  IS_WEEKEND: "IS_WEEKEND",
+  IS_WORKDAY: "IS_WORKDAY",
+  // ── Time, video timecode (packages/time/) ──
+  // Fused from a raw `HH:MM:SS:FF` token sequence (see
+  // packages/time/normalizer/VideoTimecodeNormalizerRule.ts) and from
+  // `NUMBER frames` (see FrameCountNormalizerRule.ts), not a bare-keyword
+  // collision risk the way the datetime tokens above are, since neither
+  // fusion claims a plain English word as its own token type.
+  VIDEO_TIMECODE: "VIDEO_TIMECODE",
+  FRAME_COUNT: "FRAME_COUNT",
+  // "@". See ExpressionLexer.ts's OP_MAP entry for why this was
+  // previously dormant/unproduced despite being anticipated by name here
+  // and in TokenNormalizer.ts's NON_WORD_NAMES.
+  AT: "AT",
+  // Generic token for every currency symbol added AFTER the original
+  // DOLLAR/POUND/EURO/YEN/RUBLE/WON set (each of which kept its own
+  // specific token type for backward compatibility). See
+  // uom/CurrencyAliases.ts's CURRENCY_SYMBOL_ALIASES and
+  // ExpressionLexer.ts's dispatch for the full symbol list. One shared
+  // type avoids needing a new TokenTypes entry + TokenCategoryMap entry +
+  // CurrencyPackage.ts prefixParselets entry per additional symbol.
+  CURRENCY_SYMBOL: "CURRENCY_SYMBOL",
+  // ── Cross-line data access (packages/lines/) ──
+  // "prev" -- bare keyword (nothing to phrase-fuse against, same shape as
+  // CLAMP -- accepted collision risk per that package's own precedent).
+  PREV: "PREV",
+  // "line1" / "line 1" / "l1" -- fused by LineRefNormalizerRule (never a
+  // bare lexer keyword, so ":line = 5"/":l = 5" stay untouched). Carries
+  // the parsed line number as its .value.
+  LINE_REF: "LINE_REF",
+  // "sum(" / "total(" -- fused ONLY when immediately followed by LPAREN
+  // (see LineRefNormalizerRule's lookahead guard), so ":sum = 100" and
+  // MathPhrases' "total of X, Y" (no paren after "of") are unaffected.
+  SUM_RANGE_CALL: "SUM_RANGE_CALL",
+  AVERAGE_RANGE_CALL: "AVERAGE_RANGE_CALL",
+  // "total above" / "sum above" / "average above" -- phrase-fused (see
+  // LinesPackage.ts's `phrases` field), a deliberate departure from
+  // Numi/Numbr's bare "total"/"sum" wording to avoid the exact bare-
+  // keyword collision this codebase already regressed on once.
+  TOTAL_ABOVE: "TOTAL_ABOVE",
+  SUM_ABOVE: "SUM_ABOVE",
+  AVERAGE_ABOVE: "AVERAGE_ABOVE"
+};
+var _nextTokenTypeId = 0;
+var _tokenTypeNameToId = /* @__PURE__ */ new Map();
+var _tokenTypeIdToName = /* @__PURE__ */ new Map();
+function registerTokenType(name) {
+  const existing = _tokenTypeNameToId.get(name);
+  if (existing !== void 0) return existing;
+  const id = _nextTokenTypeId++;
+  _tokenTypeNameToId.set(name, id);
+  _tokenTypeIdToName.set(id, name);
+  return id;
+}
+function tokenTypeId(name) {
+  return registerTokenType(name);
+}
+function tokenTypeName(id) {
+  return _tokenTypeIdToName.get(id) ?? `UNKNOWN_${id}`;
+}
+function registerAllTokenTypes() {
+  for (const name of Object.values(TokenTypes)) {
+    registerTokenType(name);
+  }
+}
+
+export { TokenTypes, registerAllTokenTypes, registerTokenType, tokenTypeId, tokenTypeName };
+//# sourceMappingURL=chunk-RIN643A3.js.map
+//# sourceMappingURL=chunk-RIN643A3.js.map

package/dist/chunk-RIN643A3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-RIN643A3.js","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}\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  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  // 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  RANDOM_NUMBER: \"RANDOM_NUMBER\",\n  IS_TO: \"IS_TO\",\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  // 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  // 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  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"]}