solve-engine 1.1.1 → 2.0.0

package/dist/chunk-4D6NIHE2.js

@@ -1,451 +0,0 @@
-// src/lexer/Token.ts
-var TokenTypes = {
-  NUMBER: "NUMBER",
-  BIGINT: "BIGINT",
-  STRING: "STRING",
-  IDENT: "IDENT",
-  PLUS: "PLUS",
-  MINUS: "MINUS",
-  STAR: "STAR",
-  SLASH: "SLASH",
-  // The uncertainty operator, `±` (U+00B1) or the ASCII `+/-`. The symbol is
-  // lexed directly (ExpressionLexer.ts, alongside `×`/`÷`), and the ASCII
-  // spelling is fused from PLUS SLASH MINUS by a normalizer rule (see
-  // packages/uncertainty/). Registered here rather than left to be lazily
-  // minted so its id is stable, the same reasoning as the algebra verbs below.
-  PLUS_MINUS: "PLUS_MINUS",
-  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",
-  // 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, looser than both Sum and Conditional, so
-  // a phrase parselet can parse an argument at Conjunction and get "1 + 2"
-  // whole while still stopping at "and", and so "5 > 3 and 2 > 1" reads as the
-  // conjunction of two comparisons rather than "5 > (3 and 2) > 1".
-  AND_CONJ: "AND_CONJ",
-  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",
-  // 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
-  // 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",
-  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",
-  // Successive percentage change (packages/percentage/UpDownParselet.ts):
-  // `X up N%` grows, `X down N%` shrinks, chainable with `then` and
-  // repeatable with `N times`. Retyped from a bare `up`/`down` IDENT only
-  // when a percentage immediately follows (PercentUpDownNormalizerRule), so
-  // prose that merely mentions the words is untouched. Declared here rather
-  // than minted lazily for the same reason as the algebra verbs below: a
-  // normalizer rule and its parselet must agree on the id.
-  PCT_UP: "PCT_UP",
-  PCT_DOWN: "PCT_DOWN",
-  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
-  // 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",
-  // A `#hex` colour literal (`#ff0000`), recognised by the lexer where `#`
-  // would otherwise be a heading/comment; the colour package's parselet turns
-  // it into a colour value. See ExpressionLexer.matchHexColourEnd().
-  HEX_COLOUR: "HEX_COLOUR",
-  // A colour function call fused by the colour package's normalizer, e.g.
-  // `rgb(`/`lighten(`. Carries the function name; see ColourCallParselet.
-  COLOUR_CALL: "COLOUR_CALL",
-  // 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",
-  // 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
-  // (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",
-  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"
-  // 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",
-  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.
-  BETWEEN_UNIT: "BETWEEN_UNIT",
-  // Business-day arithmetic in words, "N working/business days after|from|
-  // before <date>" (infix, the count is the left operand) and "working/
-  // business days between <date> and <date>" (prefix). Full phrases for the
-  // same reason as WORKDAYS_IN above: "working"/"business" are ordinary words,
-  // so only the complete phrase is claimed, never the bare leading word. See
-  // WorkdayOffsetParselet.ts / WorkdaysBetweenParselet.ts.
-  WORKDAYS_AFTER: "WORKDAYS_AFTER",
-  WORKDAYS_BEFORE: "WORKDAYS_BEFORE",
-  WORKDAYS_BETWEEN: "WORKDAYS_BETWEEN",
-  // 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",
-  // ── Goal seek (packages/goalseek/) ──
-  // "solve line 4 for rate = 900" -- fused by GoalSeekNormalizerRule when the
-  // bare word "solve" is immediately followed by a LINE_REF (never a bare
-  // lexer keyword, so ":solve = 2" and the existing "solve(...)" call form
-  // both stay untouched, since neither is "solve" directly before a LINE_REF).
-  GOAL_SEEK: "GOAL_SEEK"
-};
-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-4D6NIHE2.js.map
-//# sourceMappingURL=chunk-4D6NIHE2.js.map

package/dist/chunk-4D6NIHE2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/Token.ts"],"names":[],"mappings":"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","file":"chunk-4D6NIHE2.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\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  // The uncertainty operator, `±` (U+00B1) or the ASCII `+/-`. The symbol is\n  // lexed directly (ExpressionLexer.ts, alongside `×`/`÷`), and the ASCII\n  // spelling is fused from PLUS SLASH MINUS by a normalizer rule (see\n  // packages/uncertainty/). Registered here rather than left to be lazily\n  // minted so its id is stable, the same reasoning as the algebra verbs below.\n  PLUS_MINUS: \"PLUS_MINUS\",\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, looser than both Sum and Conditional, so\n  // a phrase parselet can parse an argument at Conjunction and get \"1 + 2\"\n  // whole while still stopping at \"and\", and so \"5 > 3 and 2 > 1\" reads as the\n  // conjunction of two comparisons rather than \"5 > (3 and 2) > 1\".\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  // Successive percentage change (packages/percentage/UpDownParselet.ts):\n  // `X up N%` grows, `X down N%` shrinks, chainable with `then` and\n  // repeatable with `N times`. Retyped from a bare `up`/`down` IDENT only\n  // when a percentage immediately follows (PercentUpDownNormalizerRule), so\n  // prose that merely mentions the words is untouched. Declared here rather\n  // than minted lazily for the same reason as the algebra verbs below: a\n  // normalizer rule and its parselet must agree on the id.\n  PCT_UP: \"PCT_UP\",\n  PCT_DOWN: \"PCT_DOWN\",\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  // A `#hex` colour literal (`#ff0000`), recognised by the lexer where `#`\n  // would otherwise be a heading/comment; the colour package's parselet turns\n  // it into a colour value. See ExpressionLexer.matchHexColourEnd().\n  HEX_COLOUR: \"HEX_COLOUR\",\n  // A colour function call fused by the colour package's normalizer, e.g.\n  // `rgb(`/`lighten(`. Carries the function name; see ColourCallParselet.\n  COLOUR_CALL: \"COLOUR_CALL\",\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  // Business-day arithmetic in words, \"N working/business days after|from|\n  // before <date>\" (infix, the count is the left operand) and \"working/\n  // business days between <date> and <date>\" (prefix). Full phrases for the\n  // same reason as WORKDAYS_IN above: \"working\"/\"business\" are ordinary words,\n  // so only the complete phrase is claimed, never the bare leading word. See\n  // WorkdayOffsetParselet.ts / WorkdaysBetweenParselet.ts.\n  WORKDAYS_AFTER: \"WORKDAYS_AFTER\",\n  WORKDAYS_BEFORE: \"WORKDAYS_BEFORE\",\n  WORKDAYS_BETWEEN: \"WORKDAYS_BETWEEN\",\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  // ── Goal seek (packages/goalseek/) ──\n  // \"solve line 4 for rate = 900\" -- fused by GoalSeekNormalizerRule when the\n  // bare word \"solve\" is immediately followed by a LINE_REF (never a bare\n  // lexer keyword, so \":solve = 2\" and the existing \"solve(...)\" call form\n  // both stay untouched, since neither is \"solve\" directly before a LINE_REF).\n  GOAL_SEEK: \"GOAL_SEEK\",\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"]}