solve-engine 2.24.0 → 2.25.0

package/dist/chunk-UPH22K2T.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/ExpressionLexer.ts","../src/lexer/BuiltinPhrases.ts"],"names":["registerAllTokenTypes","buildCharClassTable","table","i","isUnicodeSpace","cc","LexerToken","type","typeId","value","text","offset","lineBreaks","line","col","sourceEnd","TWO_CHAR_OPS","OP_MAP","EXPRESSION_INDICATOR_CODES","set","opCodes","c","_ExpressionLexer","localeCode","lookup","getLocale","k","v","knownUnits","rule","m","tokenTypeId","plugin","keyword","tokenType","lower","ErrorFactory","chars","first","second","builtInSecondMap","inner","unit","toRemove","r","input","results","docLen","lineStart","lineEnd","lineNumber","classification","lineText","tokens","rawToken","savedLen","inlineSolves","charSpans","span","nlChar","len","tokenIndex","openSpan","collectedSpans","c0","identLower","kwType","opType","token","pos","start","startCol","next","hasIntPart","d1","d2","d3","d4","isGroupOfExactlyThree","hasDecimal","nextCc","hasExponent","ec","identText","fullText","localeKwType","lookPos","parenPos","isWord","ch","isAlpha","wordEnd","hasAlpha","word","keywordType","c1","secondMap","twoCharType","commentPos","pluginInner","pluginType","end","indicatorCodes","from","after","hashPos","p","n","hasInline","idx","hashCount","count","trailPos","digitPos","tPos","tc","closePos","trail","onlySkippable","code","savedInput","savedPos","result","sPos","exprStart","exprEnd","expression","hexEnd","isLetter","prevCode","prevIsWordChar","tagEnd","name","ExpressionLexer","BUILTIN_PHRASES"],"mappings":"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","file":"chunk-UPH22K2T.cjs","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   * Offset of the first evaluable character, when structural markup precedes\n   * it. Absolute, in the same coordinates the classification was asked for,\n   * and absent when the whole line is evaluable.\n   *\n   * A list marker is markup, not arithmetic. `- 100 + 20` is a bullet holding\n   * `100 + 20`, but `-` is also a prefix operator, so without this the line\n   * evaluated as negative one hundred and answered -80: a wrong answer that\n   * looks like a right one. `*` and `+` in the same position could not even do\n   * that, one erroring and the other correct by luck, so the three markers\n   * disagreed with each other about the same document.\n   *\n   * Consumers must slice both the text and the token stream from here, or the\n   * two describe different lines.\n   */\n  contentOffset?: number;\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}\n\n/**\n * Whether a non-ASCII code point separates tokens rather than joining them.\n *\n * The CHAR_CLASS table above is 128 entries wide, so every code point past\n * ASCII falls through to one branch that reads it as part of an identifier.\n * That is right for `café`, `日本語` and emoji, and wrong for the dozen or so\n * code points that are whitespace without being ASCII whitespace. Without this,\n * a no-break space between two operands JOINED them: `1<NBSP>+<NBSP>1` lexed as\n * one identifier and reported \"Undefined variable: 1 + 1\", and a byte-order\n * mark at the head of a file did the same to its first line. Both arrive\n * constantly in pasted text, from a web page, a word processor, a spreadsheet\n * export, or a Windows editor that writes a BOM.\n *\n * The zero-width JOINERS are deliberately absent. U+200D is what holds a family\n * emoji together as one grapheme, and U+200C is its non-joining partner; both\n * bind their neighbours rather than separating them, so they stay identifier\n * characters. U+200B, the zero-width SPACE, is a separator despite being\n * invisible, which is exactly why it is worth handling: it is unreadable on\n * screen and would otherwise silently break the line it lands in.\n *\n * @param cc - A UTF-16 code unit, only meaningful for values >= 128.\n * @returns True when the character should be skipped like a space.\n */\nfunction isUnicodeSpace(cc: number): boolean {\n  return (\n    cc === 0x0085 ||                    // NEL, next line\n    cc === 0x00A0 ||                    // no-break space\n    cc === 0x1680 ||                    // ogham space mark\n    (cc >= 0x2000 && cc <= 0x200A) ||   // en quad through hair space, incl. figure/thin space\n    cc === 0x200B ||                    // zero-width space\n    cc === 0x2028 ||                    // line separator\n    cc === 0x2029 ||                    // paragraph separator\n    cc === 0x202F ||                    // narrow no-break space\n    cc === 0x205F ||                    // medium mathematical space\n    cc === 0x3000 ||                    // ideographic space\n    cc === 0xFEFF                       // byte-order mark / zero-width no-break space\n  );\n}\n\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  43: { 61: 'PLUS_EQUALS' },  // +=  (compound assignment, running totals)\n  45: { 61: 'MINUS_EQUALS' }, // -=  (neither + nor - had a two-char op before)\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  // Open-bracket context stack for the current line, one entry per unclosed\n  // `(`/`[`, `true` when a comma inside it is a separator rather than a\n  // thousands group. A `[` (vector/matrix) and a CALL `(` (`rgb(255,255,255)`,\n  // preceded by an identifier) are separator contexts; a bare GROUPING `(`\n  // (`(1,000)`, preceded by an operator or the line start) is not, so a\n  // parenthesised thousands number still reads as one scalar. The number scanner\n  // consults the innermost entry. Tracked here because the flat token stream\n  // carries no nesting otherwise; reset per line, so an unbalanced bracket\n  // cannot bleed the decision into the next.\n  private groupingStack: boolean[] = [];\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  // ReadonlySet: only membership is ever tested, which lets the common\n  // no-plugin-units case share the built-in `knownUnits` set without a copy.\n  private mergedUnits: ReadonlySet<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  // `knownUnits` is a 1000+ entry built-in set. A single combined rebuild used\n  // to copy it (and the whole keyword map) on every registerVocabulary call, so\n  // each keyword-only package paid for it for nothing, the single largest cost\n  // in engine construction. The merged keyword map is now maintained\n  // incrementally (a plugin keyword can never shadow a built-in, so it is a plain\n  // set/delete on the existing map, see registerVocabulary), and only the units\n  // still need an occasional rebuild, done here.\n  private rebuildMergedUnits(): void {\n    // No plugin units is the common case: reference the built-in set directly\n    // rather than copying 1000+ entries. mergedUnits is read-only (membership\n    // tests only), so sharing the constant is safe; a later plugin unit builds a\n    // fresh union instead of mutating it.\n    this.mergedUnits = this.pluginUnits.size === 0\n      ? knownUnits\n      : 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    // No plugin units yet: share the built-in set (read-only). A later plugin\n    // unit builds a fresh union in rebuildMergedUnits() rather than mutating it.\n    this.mergedUnits = 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        // Straight into the merged view: guarded above against shadowing a\n        // built-in, so no full rebuild is needed.\n        this.mergedKeywords.set(lower, tokenType);\n      }\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.rebuildMergedUnits();\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        const lower = keyword.toLowerCase();\n        this.pluginKeywordMap.delete(lower);\n        this.mergedKeywords.delete(lower);\n      }\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.rebuildMergedUnits();\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          // Start past any structural marker, so the marker never becomes a\n          // token. Token source offsets stay absolute, so everything\n          // downstream (spans, highlighting, inline solves) still lines up\n          // with the raw document.\n          if (classification.contentOffset !== undefined) this.pos = classification.contentOffset;\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 (isUnicodeSpace(c0)) {\n            // A line holding nothing but a no-break space or a byte-order mark\n            // holds no expression, exactly as a line holding one space does.\n            // Yielding an IDENT for it made it an undefined variable instead.\n          } else 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 === 0x00B1) {  // U+00B1 plus-minus sign, the uncertainty operator\n            yield new LexerToken('PLUS_MINUS', tokenTypeId('PLUS_MINUS'), '\\u00B1', '\\u00B1', 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    // Fresh nesting stack for this pass (see the field's doc).\n    this.groupingStack.length = 0;\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            this.groupingStack.length = 0;  // each line groups thousands on its own\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            this.groupingStack.length = 0;\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 (isUnicodeSpace(c0)) {\n            // Separates its neighbours instead of joining them. See\n            // isUnicodeSpace()'s doc comment: this branch is why a sum pasted\n            // out of a web page or a spreadsheet evaluates at all.\n            this.pos++;\n            if (c0 === 0x2028 || c0 === 0x2029 || c0 === 0x0085) {\n              // The three that are line breaks rather than spaces, tracked the\n              // same way \"\\n\" is above so a later token reports its own line.\n              this.line++;\n              this.lineStartPos = this.pos;\n            }\n          } else 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 === 0x00B1) {  // U+00B1 plus-minus sign, the uncertainty operator\n            yield new LexerToken('PLUS_MINUS', tokenTypeId('PLUS_MINUS'), '\\u00B1', '\\u00B1', 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      // A comma inside a call or bracket is an argument/element separator, not a\n      // thousands group: `rgb(255,255,255)` is three numbers and `[100,200,300]`\n      // a three-element vector, not `255255255`/`100200300`. A comma in a bare\n      // grouping paren (`(1,000)`) still groups thousands, and so does a\n      // top-level comma (`1,000,000`). The innermost bracket's context decides;\n      // the `.` grouping form is context-free and unaffected. See\n      // {@link groupingStack}.\n      if (\n        input.charCodeAt(pos) === 44 &&\n        this.groupingStack.length > 0 &&\n        this.groupingStack[this.groupingStack.length - 1]\n      ) {\n        break;\n      }\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 && !isUnicodeSpace(cc)))  // Unicode (accented chars, emoji, etc.), but not Unicode whitespace\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   * Whether the `(` at `parenPos` opens a function call rather than a bare\n   * grouping, deciding whether a comma inside it is a separator or a thousands\n   * group (see {@link groupingStack}).\n   *\n   * It is a call when the nearest non-whitespace character before it belongs to\n   * the value the call applies to: a closing `)`/`]` (a call on a result), or an\n   * IDENTIFIER (`rgb(`, `vec2(`). A run of digits alone is a number, not an\n   * identifier, so `2(1,000)` is implicit multiplication over the grouping\n   * `(1,000)`, not a call, while `vec2(` and `atan2(` (identifiers that end in a\n   * digit) are calls. A `(` after an operator, a comma, or the line start is a\n   * grouping.\n   */\n  private precededByCallTarget(parenPos: number): boolean {\n    const input = this.input;\n    const start = this.lineStartPos;\n    let i = parenPos - 1;\n    while (i >= start && (input.charCodeAt(i) === 32 || input.charCodeAt(i) === 9)) i--;  // skip spaces/tabs\n    if (i < start) return false;  // line start (or only whitespace before): a grouping\n    const c = input.charCodeAt(i);\n    const isWord = (ch: number): boolean =>\n      (ch >= 48 && ch <= 57) || (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch === 95;\n    const isAlpha = (ch: number): boolean =>\n      (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch === 95;\n    // A non-word char before \"(\" (an operator, a comma, a `)`/`]`, or the line\n    // start) is a grouping. There is no curried/first-class call or index-\n    // application in this grammar, so `)(` and `](` are implicit multiplication\n    // over a grouping (`(2)(1,000)` is `2 * 1000`), not a call. The only call\n    // targets are an identifier or a FUNC keyword, handled below.\n    if (!isWord(c)) return false;\n    // Walk back over the whole word run. A bare number run (`2(1,000)`) is\n    // implicit multiplication over a grouping, not a call.\n    const wordEnd = i + 1;\n    let hasAlpha = false;\n    while (i >= start) {\n      const ch = input.charCodeAt(i);\n      if (!isWord(ch)) break;\n      if (isAlpha(ch)) hasAlpha = true;\n      i--;\n    }\n    if (!hasAlpha) return false;\n    // The word is an identifier. A KEYWORD that is not a function name is a\n    // word-operator or connective (`mod`, `xor`, `and`, `to`, `in`) or a\n    // constant (`pi`, `e`), and the `(...)` after it is a grouped operand, so\n    // its comma still groups thousands (`100 mod (1,000)` is `100 mod 1000`).\n    // A plain identifier (a function like `rgb`, or a variable) or a function\n    // keyword (`sqrt`, `max`) is a real call target, where the comma separates.\n    const word = input.slice(i + 1, wordEnd).toLowerCase();\n    const keywordType = this.mergedKeywords.get(word);\n    return keywordType === undefined || keywordType === \"FUNC\";\n  }\n\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    // Track `(`/`[` nesting so the number scanner can tell a thousands group\n    // from an argument/element separator (see {@link groupingStack}). `[` always\n    // opens a separator context (a vector/matrix). `(` opens a separator context\n    // only when it is a CALL, i.e. it directly follows a value the call applies\n    // to, an identifier/unit, or a closing `)`/`]`; a bare GROUPING `(`, after an\n    // operator or the line start, keeps thousands so `(1,000)` stays one number.\n    // `)`/`]` pop; a stray closer with an empty stack is ignored.\n    if (c0 === 91) {  // [\n      this.groupingStack.push(true);\n    } else if (c0 === 40) {  // (\n      this.groupingStack.push(this.precededByCallTarget(pos));\n    } else if (c0 === 41 || c0 === 93) {  // ) or ]\n      if (this.groupingStack.length > 0) this.groupingStack.pop();\n    }\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   * `text` is the raw source slice, quotes included, because that is what\n   * `offset` + `text.length` has to span for a host to underline the literal.\n   * `value` is the PAYLOAD, quotes excluded, because that is what\n   * `PUSH_STRING` puts into the Value.\n   *\n   * The two used to be the same string. `\"abc\"` carried the five characters\n   * `\"abc\"` as its value, which was invisible on screen (the formatter prints\n   * the payload raw and the retained quotes landed where a display would have\n   * put them back) and not invisible anywhere else: `parseFloat('\"5\"')` is NaN\n   * whatever the digits say, so `\"5\" + 5` answered 5.\n   *\n   * An unterminated literal is an error rather than a string that happens to\n   * reach the end of the line. It used to return what it had, so `\"abc` and\n   * `\"abc\"` were indistinguishable by payload once the quotes were stripped,\n   * which is the other half of why they are stripped here rather than later.\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        const value = input.slice(start + 1, pos - 1);\n        this.pos = pos;\n        return new LexerToken('STRING', tokenTypeId('STRING'), value, 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    this.pos = pos;\n    throw ErrorFactory.parsing(\n      \"UNTERMINATED_STRING\",\n      `Unterminated string literal: ${input.slice(start, pos)}`,\n      { literal: input.slice(start, pos), offset: start },\n    );\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  /**\n   * Advance past the whitespace after a list marker, and past a task-item\n   * checkbox if one follows.\n   *\n   * The checkbox is included because it is markup by the same argument the\n   * marker is, and because leaving it stopped the line dead: `- [ ] 100 + 20`\n   * lexed `[ ]` as a matrix literal and reported that a matrix cannot be\n   * empty, which tells a user writing a to-do list nothing they can act on.\n   *\n   * @param from - Offset just past the marker character.\n   * @param end - Line end, never read past.\n   * @returns Offset of the first evaluable character.\n   */\n  private skipMarkerGap(from: number, end: number): number {\n    const input = this.input;\n    let pos = from;\n    while (pos < end && (input.charCodeAt(pos) === 32 || input.charCodeAt(pos) === 9)) pos++;\n\n    // `[ ]`, `[x]`, `[X]`, or any single-character state Obsidian allows.\n    if (pos + 2 < end && input.charCodeAt(pos) === 91 && input.charCodeAt(pos + 2) === 93) {\n      let after = pos + 3;\n      while (after < end && (input.charCodeAt(after) === 32 || input.charCodeAt(after) === 9)) after++;\n      // Only when whitespace followed, so `[1,2]` opening a real matrix is\n      // never mistaken for a checkbox.\n      if (after > pos + 3) return after;\n    }\n    return pos;\n  }\n\n  /**\n   * The end offset (exclusive) of a `#hex` colour literal starting at `hashPos`,\n   * or -1 if the run there is not one. A colour is `#` followed by EXACTLY 3, 4,\n   * 6 or 8 hex digits (the CSS forms `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa`) and\n   * then a boundary, not a longer word or number. This is the one predicate that\n   * carves colours out of the two things `#` otherwise means, a markdown heading\n   * at line start and a comment mid-line, and it is pure character logic so line\n   * classification stays vocabulary-independent. Examples: `#f00`, `#ff0000`,\n   * `#deadbeef` match; `# Heading` (space), `#tag`/`#todo` (non-hex letter),\n   * `#12345` (length 5), `#ff0000zz` (trailing word) do not.\n   */\n  private matchHexColourEnd(hashPos: number, end: number): number {\n    const input = this.input;\n    let p = hashPos + 1;\n    let n = 0;\n    while (p < end) {\n      const c = input.charCodeAt(p);\n      const isHex = (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102);\n      if (!isHex) break;\n      n++;\n      p++;\n    }\n    if (n !== 3 && n !== 4 && n !== 6 && n !== 8) return -1;\n    if (p < end) {\n      const c = input.charCodeAt(p);\n      const isWord = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;\n      if (isWord) return -1;\n    }\n    return p;\n  }\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      // A bare #hex colour is a value, not a heading. A real heading has a space\n      // after its #(s), so the colour shape (# + 3/4/6/8 hex digits) never\n      // collides with one. This line is tokenized like any expression.\n      if (this.matchHexColourEnd(pos, len) !== -1) {\n        if (hasInline === undefined) {\n          const idx = input.indexOf('s`', pos);\n          hasInline = idx !== -1 && idx < len;\n        }\n        return { type: 'expression', skip: false, hasInlineSolve: hasInline };\n      }\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      // The space is what makes this a marker rather than an operator, and it\n      // is required by CommonMark for exactly that reason. `-100 + 20` has no\n      // space and stays arithmetic; `- 100 + 20` is a bullet.\n      return { type: 'list', skip: false, hasInlineSolve: hasInline, contentOffset: this.skipMarkerGap(pos + 1, len) };\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, contentOffset: this.skipMarkerGap(digitPos + 1, len) };\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    // A line built only from characters the tokenizer discards produces no\n    // tokens, so it has nothing to evaluate. Whitespace-only lines already\n    // classify as empty above; the gap was an unknown ASCII character like a\n    // backslash, which the lexer skips (it falls through to CharClass.SKIP)\n    // rather than tokenising. A run of them (\"\\\\\", \"\\\\\\\\\") reached the\n    // expression path, lexed to an empty token stream, and the engine reported\n    // that stream as the number 0: a result on screen for a line that holds no\n    // expression at all. Classify it as empty, the same as a blank line, so\n    // every surface (the batch parse, the incremental evaluator, and the\n    // playground's shouldEvaluateLine) skips it rather than answering 0. A\n    // non-ASCII code point is real content (it lexes as an IDENT for forward\n    // compatibility), so only ASCII whitespace and skip characters count here.\n    if (!hasInline) {\n      let onlySkippable = true;\n      for (let i = pos; i < len; i++) {\n        const code = input.charCodeAt(i);\n        if (code >= 128 || ExpressionLexer.CHAR_CLASS[code] > CharClass.WHITESPACE) {\n          onlySkippable = false;\n          break;\n        }\n      }\n      if (onlySkippable) {\n        return { type: 'empty', skip: true, hasInlineSolve: false };\n      }\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\n    // A `#hex` colour literal is not a comment. Recognised here (the single\n    // choke-point both `#` call sites reach) so `#ff0000` becomes a HEX_COLOUR\n    // token while `# comment`, `#tag`, `#face` (length 4 all-hex still counts as a\n    // colour) and `// c` stay comments. Only fires when the char is `#`, never `/`.\n    if (input.charCodeAt(start) === 35) {\n      const hexEnd = this.matchHexColourEnd(start, len);\n      if (hexEnd !== -1) {\n        const text = input.slice(start, hexEnd);\n        this.pos = hexEnd;\n        return new LexerToken('HEX_COLOUR', tokenTypeId('HEX_COLOUR'), text, text, start, 0, this.line, startCol);\n      }\n\n      // A bounded `#tag` annotation: `#` then a letter then a run of\n      // `[A-Za-z0-9_-]`, consuming only the tag, not the rest of the line. So\n      // `1200 #housing // note` keeps the `// note` comment, and a mid-line tag\n      // no longer swallows the line. `# ` (space) and `#123` (leading digit)\n      // still fall through to a comment; a line-start `#` is a heading\n      // (classified elsewhere); a `#hex` colour is caught above.\n      const first = input.charCodeAt(start + 1);\n      const isLetter = (first >= 65 && first <= 90) || (first >= 97 && first <= 122);\n      // #198: a `#` glued to the end of a word or number is not a tag. The\n      // category-tag scanner (packages/tags/TagScanner.ts) only counts a tag at\n      // a non-word boundary (`(?:^|[^0-9A-Za-z_])#...`), so `100#food`, `$100#food`\n      // and `a#b` are excluded there; the lexer must agree, or a line renders\n      // tagged but is silently left out of the totals. A line-first `#` never\n      // reaches here (the classifier makes it a heading), so a mid-line tag only\n      // needs its preceding character to be a non-word char.\n      const prevCode = start > this.lineStartPos ? input.charCodeAt(start - 1) : -1;\n      const prevIsWordChar =\n        (prevCode >= 48 && prevCode <= 57) ||\n        (prevCode >= 65 && prevCode <= 90) ||\n        (prevCode >= 97 && prevCode <= 122) ||\n        prevCode === 95;\n      if (isLetter && !prevIsWordChar) {\n        let tagEnd = start + 2;\n        while (tagEnd < len) {\n          const c = input.charCodeAt(tagEnd);\n          const isTagChar = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 45;\n          if (!isTagChar) break;\n          tagEnd++;\n        }\n        // Store the name without the `#`, matching how LINE_REF keeps the bare\n        // number.\n        const name = input.slice(start + 1, tagEnd);\n        this.pos = tagEnd;\n        return new LexerToken('TAG', tokenTypeId('TAG'), name, name, start, 0, this.line, startCol);\n      }\n    }\n\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}","/**\n * The engine's own multi-word phrases and the token each one fuses into.\n *\n * One table, read by two consumers: the lexer's token lookup\n * (`lexer/tokenRegistration.ts`) and the normalizer's phrase trie\n * (`engine/ExpressionEngine.ts`, via `normalizer/BuiltinNormalizerRules.ts`).\n * It used to be two hand-copied tables, and they drifted: the lexer's copy\n * never learned \"divided by\". A phrase added here reaches both.\n *\n * @module BuiltinPhrases\n */\n\n/** Built-in phrase → token type. See the module doc. */\nexport const BUILTIN_PHRASES: Record<string, string> = {\n\t\"to the power of\": \"CARET\",\n\t\"power of\": \"CARET\",\n\t\"increase by\": \"INCREASE_BY\",\n\t\"decrease by\": \"DECREASE_BY\",\n\t\"times by\": \"TIMES_BY\",\n\t\"multiply by\": \"MULTIPLY_BY\",\n\t\"divide by\": \"DIVIDE_BY\",\n\t// The past-tense spellings, which is how the operation is usually written\n\t// out: \"3 multiplied by 4\". Same tokens, so no new parselets.\n\t\"multiplied by\": \"MULTIPLY_BY\",\n\t\"divided by\": \"DIVIDE_BY\",\n};\n"]}

package/dist/chunk-UY3ID6JF.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../package.json","../src/constants/version.ts","../src/constants/Configuration.ts"],"names":["version","ENGINE_VERSION","DEFAULT_CONFIG","mergeEngineConfig","base","override","ConfigManager","config","path","keys","current","key","ErrorFactory","value","section","property","sectionConfig","errors"],"mappings":"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","file":"chunk-UY3ID6JF.cjs","sourcesContent":["{\n  \"name\": \"solve-engine\",\n  \"version\": \"2.24.0\",\n  \"description\": \"An embeddable expression engine for natural-language calculations: units, currencies, percentages, dates and matrices, with the parsing and evaluation plumbing already built.\",\n  \"keywords\": [\n    \"expression-evaluator\",\n    \"calculator\",\n    \"bytecode-vm\",\n    \"parser\",\n    \"lexer\",\n    \"dsl\",\n    \"markdown\",\n    \"obsidian\"\n  ],\n  \"license\": \"MIT\",\n  \"author\": \"Liam Riddell\",\n  \"homepage\": \"https://liamriddell.github.io/solve-engine/\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git+https://github.com/LiamRiddell/solve-engine.git\",\n    \"directory\": \"packages/engine\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/LiamRiddell/solve-engine/issues\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"type\": \"module\",\n  \"engines\": {\n    \"node\": \">=22\"\n  },\n  \"files\": [\n    \"dist\",\n    \"LICENSE\"\n  ],\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./engine\": {\n      \"import\": {\n        \"types\": \"./dist/engine.d.ts\",\n        \"default\": \"./dist/engine.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/engine.d.cts\",\n        \"default\": \"./dist/engine.cjs\"\n      }\n    },\n    \"./vm\": {\n      \"import\": {\n        \"types\": \"./dist/vm.d.ts\",\n        \"default\": \"./dist/vm.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/vm.d.cts\",\n        \"default\": \"./dist/vm.cjs\"\n      }\n    },\n    \"./format\": {\n      \"import\": {\n        \"types\": \"./dist/format.d.ts\",\n        \"default\": \"./dist/format.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/format.d.cts\",\n        \"default\": \"./dist/format.cjs\"\n      }\n    },\n    \"./language\": {\n      \"import\": {\n        \"types\": \"./dist/language.d.ts\",\n        \"default\": \"./dist/language.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/language.d.cts\",\n        \"default\": \"./dist/language.cjs\"\n      }\n    },\n    \"./packages\": {\n      \"import\": {\n        \"types\": \"./dist/packages.d.ts\",\n        \"default\": \"./dist/packages.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/packages.d.cts\",\n        \"default\": \"./dist/packages.cjs\"\n      }\n    },\n    \"./constants\": {\n      \"import\": {\n        \"types\": \"./dist/constants.d.ts\",\n        \"default\": \"./dist/constants.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/constants.d.cts\",\n        \"default\": \"./dist/constants.cjs\"\n      }\n    },\n    \"./lexer\": {\n      \"import\": {\n        \"types\": \"./dist/lexer.d.ts\",\n        \"default\": \"./dist/lexer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/lexer.d.cts\",\n        \"default\": \"./dist/lexer.cjs\"\n      }\n    },\n    \"./parser\": {\n      \"import\": {\n        \"types\": \"./dist/parser.d.ts\",\n        \"default\": \"./dist/parser.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/parser.d.cts\",\n        \"default\": \"./dist/parser.cjs\"\n      }\n    },\n    \"./normalizer\": {\n      \"import\": {\n        \"types\": \"./dist/normalizer.d.ts\",\n        \"default\": \"./dist/normalizer.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/normalizer.d.cts\",\n        \"default\": \"./dist/normalizer.cjs\"\n      }\n    },\n    \"./resolvers\": {\n      \"import\": {\n        \"types\": \"./dist/resolvers.d.ts\",\n        \"default\": \"./dist/resolvers.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/resolvers.d.cts\",\n        \"default\": \"./dist/resolvers.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/errors.d.ts\",\n        \"default\": \"./dist/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/errors.d.cts\",\n        \"default\": \"./dist/errors.cjs\"\n      }\n    },\n    \"./utilities\": {\n      \"import\": {\n        \"types\": \"./dist/utilities.d.ts\",\n        \"default\": \"./dist/utilities.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/utilities.d.cts\",\n        \"default\": \"./dist/utilities.cjs\"\n      }\n    },\n    \"./uom\": {\n      \"import\": {\n        \"types\": \"./dist/uom.d.ts\",\n        \"default\": \"./dist/uom.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/uom.d.cts\",\n        \"default\": \"./dist/uom.cjs\"\n      }\n    },\n    \"./services\": {\n      \"import\": {\n        \"types\": \"./dist/services.d.ts\",\n        \"default\": \"./dist/services.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/services.d.cts\",\n        \"default\": \"./dist/services.cjs\"\n      }\n    },\n    \"./worker\": {\n      \"import\": {\n        \"types\": \"./dist/worker.d.ts\",\n        \"default\": \"./dist/worker.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/worker.d.cts\",\n        \"default\": \"./dist/worker.cjs\"\n      }\n    },\n    \"./testing\": {\n      \"import\": {\n        \"types\": \"./dist/testing.d.ts\",\n        \"default\": \"./dist/testing.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/testing.d.cts\",\n        \"default\": \"./dist/testing.cjs\"\n      }\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"prepublishOnly\": \"npm run build && node ../../scripts/assert-publishable.mjs .\",\n    \"dev\": \"tsup --watch\",\n    \"test\": \"jest --config jest.config.cjs --no-coverage\",\n    \"typecheck\": \"tsgo --noEmit --skipLibCheck\",\n    \"typecheck:tsc\": \"tsc --noEmit --skipLibCheck\"\n  },\n  \"dependencies\": {\n    \"@tanstack/query-core\": \"^5.100.10\"\n  },\n  \"devDependencies\": {\n    \"@jest/globals\": \"^30.4.1\",\n    \"@types/node\": \"^26.2.0\",\n    \"convert\": \"^7.0.0\",\n    \"jest\": \"^30.4.2\",\n    \"ts-jest\": \"^29.4.12\",\n    \"tsup\": \"8.5.1\",\n    \"typescript\": \"5.9.3\"\n  },\n  \"//sideEffects\": \"Load-bearing claim, not boilerplate. tsup's splitting emits bare chunk imports at the top of dist/index.js, and this field tells Rollup, webpack and Vite they may delete them, which esbuild reports as [ignored-bare-import] once per import during `npm run size`. The engine does have module-level work to lose: registerAllTokenTypes(), _PrecedenceParser.BP_TABLE and its cached token ids, and several process-wide registries. It is safe because every chunk doing that work is also imported for its bindings somewhere, so no bundler can drop it. That is a property of how tsup currently splits the code rather than a design guarantee, so `npm run smoke:bundled` (scripts/check-tree-shaking.mjs) proves it on every run of `npm run verify` instead of assuming it, and its header explains the two fixes if it ever stops holding.\",\n  \"sideEffects\": false\n}\n","/**\n * The running engine's own semver version, sourced directly from this\n * package's package.json so it can never drift from what's actually\n * published. Exists so IEnginePackage.engineVersion range checks\n * (api/EngineVersionCompatibility.ts) have something real to check\n * against.\n */\nimport { version } from \"../../package.json\";\n\n/**\n * The running engine's version, taken from package.json.\n *\n * What a package's `engineVersion` range is checked against at registration.\n * A prerelease is compared by its coerced release version, so a 1.0.0 beta\n * satisfies `^1.0.0`. See `api/EngineVersionCompatibility.ts`.\n */\nexport const ENGINE_VERSION: string = version;\n","/**\n * Configuration Module for solve-js Engine\n * \n * This module provides the **single source of truth** for all engine configuration.\n * Every configurable aspect of the engine, from safety limits and performance\n * budgets to VM constraints and worker pool sizing, is defined here.\n * \n * ### Design principles\n * \n * 1. **Engine owns its config.** The engine defines its own config shape and defaults.\n *    Consumers (e.g., the Obsidian plugin) pass partial overrides; all unspecified\n *    fields fall back to `DEFAULT_CONFIG`.\n * \n * 2. **Self-documenting.** Every interface and field has descriptive JSDoc so the\n *    config is understandable at a glance, whether you're using the engine as an\n *    npm package or reading the source.\n * \n * 3. **Minimal consumer knowledge.** Consumers only need to pass `Partial<EngineConfig>`.\n *    They don't need to replicate the full config shape, just the fields they\n *    want to override.\n * \n * @module Configuration\n */\n\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * A host's test for whether a calendar date is a public holiday, given the\n * `Date` for that day at local midnight. Return `true` to exclude it from\n * working-day arithmetic.\n */\nexport type HolidayPredicate = (date: Date) => boolean;\n\n/**\n * The host-supplied public-holiday calendar, in the same \"bring your own data\"\n * shape the stocks and weather packages already use for a host callback (see\n * `packages/stocks/StocksPackage.ts`): weekends are decidable from the date\n * alone, holidays are not, so they come from the host or not at all.\n *\n * Either a {@link HolidayPredicate}, for a host that computes holidays itself\n * (an existing library, a region rule), or an iterable of specific dates as\n * `YYYY-MM-DD` strings, epoch-millisecond numbers or `Date` objects, for a host\n * that just has a list. Resolved to one internal predicate by\n * `vm/HolidayCalendar.ts`'s `resolveHolidayPredicate()`.\n *\n * Left unset, working-day arithmetic skips weekends only, which is the honest\n * default: the engine excludes exactly the days it can prove are non-working.\n */\nexport type HolidayCalendar = HolidayPredicate | Iterable<string | number | Date>;\n\n/**\n * Date-related configuration.\n * Controls the bounds and formatting for date/time expression evaluation\n * (e.g., `today + 20 days`, `last monday`).\n */\n/**\n * How an ambiguous all-numeric date literal is read.\n *\n * - `'auto'`: by separator, the historic behaviour. A slash date is\n *   day-first (`25/12/2023`), a hyphen date is month-first (`12-25-2023`)\n *   unless its first group is four digits, which makes it ISO (`2023-12-25`).\n * - `'DMY'` / `'MDY'` / `'YMD'`: a fixed order for every numeric separator, so\n *   a host can match its readers' locale. `'MDY'` is what lets a US reader's\n *   `12/25/2023` parse, which `'auto'` refuses because the slash defaults to\n *   day-first.\n *\n * Only the all-numeric literals are affected. A spelled-out month (`March 9,\n * 2024`) is never ambiguous, and an ISO timestamp is always read as ISO.\n */\nexport type DateInputOrder = 'auto' | 'DMY' | 'MDY' | 'YMD';\n\n/** Date-related engine configuration: offset limits, input order, holidays. */\nexport interface DateConfig {\n  /**\n   * The order an ambiguous all-numeric date literal is read in. Defaults to\n   * `'auto'` (by separator, the historic behaviour). See {@link DateInputOrder}.\n   */\n  readonly inputOrder: DateInputOrder;\n  /**\n   * How far forward a date offset whose COST grows with the offset may reach,\n   * in years. Enforced by `vm/VM.ts`'s `addBusinessDays()`.\n   *\n   * Bounds the walk, not the calendar. Every other date offset in the engine\n   * is arithmetic on a Date field, so `today + 100000 days` costs exactly what\n   * one day costs and needs no ceiling; workdays are the one offset that has\n   * to step day by day, because which days are skipped depends on where each\n   * step lands. `today + 100000000 workdays` therefore froze the host for\n   * thirteen seconds inside a single ADD opcode (where `vm.maxInstructions`\n   * cannot see it) and then answered \"Invalid Date\", and a trillion never\n   * returned at all.\n   *\n   * Release hardening: this field was declared, documented as a \"safety\n   * limit\", and read nowhere, so it bounded nothing. A limit a host can\n   * configure and the engine ignores is worse than no limit, because it reads\n   * as protection that is not there.\n   */\n  readonly maxOffsetYears: number;\n  /** How far BACK the same walk may reach, in years, as a negative number. See {@link maxOffsetYears}. */\n  readonly minOffsetYears: number;\n  /** Default date string format for display (moment.js format string) */\n  readonly defaultFormat: string;\n  /**\n   * Public-holiday calendar for working-day arithmetic (`N working days after\n   * <date>`, `working days between <date> and <date>`, `<date> + N workdays`).\n   * See {@link HolidayCalendar}.\n   *\n   * Optional and unset by default: with no calendar, working-day arithmetic\n   * skips weekends only. A host that wants holidays excluded too supplies one\n   * here (`new ExpressionEngine({ config: { date: { holidays } } })`), the\n   * same way stocks and weather take a host data source. Threaded into the VM\n   * by `engine/ExpressionEngine.ts` exactly as {@link maxOffsetYears} is,\n   * because working-day math is a VM operation several grammar forms share, so\n   * the calendar has to be one source the VM owns rather than per-package state\n   * the VM cannot see.\n   */\n  readonly holidays?: HolidayCalendar;\n}\n\n/**\n * Performance-related configuration.\n * Controls caching, timeouts, and processing limits to prevent runaway\n * resource consumption on large documents.\n */\nexport interface PerformanceConfig {\n  /**\n   * Maximum number of entries in {@link ExpressionEngine}'s bytecode cache\n   * (per-instance, keyed by expression text) before the oldest entry is\n   * evicted. Raise this for documents with many distinct expressions if\n   * repeated re-evaluation (e.g. scrolling) is re-parsing instead of\n   * hitting cache, bug fix (release hardening pass): this field used to\n   * be read nowhere; the cache size was a hardcoded, unconfigurable\n   * constant. Note this does NOT bound {@link LineCache}, which has no\n   * size limit of its own.\n   */\n  readonly defaultCacheSize: number;\n  /**\n   * Maximum lines a document may have for the engine to process it in one\n   * pass. Enforced by `ExpressionEngine.parseDocument()` and by\n   * `engine/DocumentModel.ts`'s `setDocument()`, the two entry points that\n   * take a whole document.\n   *\n   * A document costs memory per line whatever each line says: a parsed line\n   * record, a cache entry, a dependency-graph node. Two hundred thousand\n   * lines of `1 + 1` therefore exhausted the heap and aborted the process\n   * before any per-line limit had anything to object to, which is the same\n   * shape of hole as an unbounded expression and needs the same kind of\n   * ceiling. Refusing the document names the limit; a host that genuinely has\n   * a larger one raises this field.\n   *\n   * Release hardening: declared and read nowhere until now.\n   */\n  readonly maxDocumentLines: number;\n}\n\n/**\n * Validation / safety-limit configuration.\n * Protects against runaway expressions that could cause excessive memory use\n * or stack overflow. These limits are checked during lexing and parsing.\n */\n/** Bounds on untrusted input: expression length and nesting depth. */\nexport interface ValidationConfig {\n  /** Maximum expression length in characters. Prevents excessively long strings from entering the pipeline. */\n  readonly maxExpressionLength: number;\n  /** Maximum expression complexity score (`tokens + functionCalls×5 + nestingDepth×10`). Protects against deeply nested or combinatorially complex expressions. */\n  readonly maxComplexity: number;\n  /** Maximum parentheses nesting depth. Prevents stack overflow in the recursive-descent parser. */\n  readonly maxNestingDepth: number;\n  /**\n   * Auto-balance unmatched parentheses by appending missing closing parens\n   * or prepending missing opening parens. When disabled, unbalanced expressions\n   * cause parse errors instead of being silently corrected.\n   *\n   * Disabled by default for strict parsing. Enable for forgiving user input\n   * (e.g., chat-style calculators where users often omit closing parens).\n   * Has zero overhead when disabled, the O(n) paren-count scan is skipped.\n   */\n  readonly autoBalanceParens: boolean;\n}\n\n/**\n * Worker pool configuration.\n * Controls the parallel execution workers used for batch evaluation.\n */\nexport interface WorkerConfig {\n  /** Maximum number of concurrent Web Workers allowed */\n  readonly maxConcurrentWorkers: number;\n  /** Time (ms) a worker stays alive while idle before being terminated */\n  readonly idleTimeoutMs: number;\n  /** Maximum retry attempts for a failed worker operation */\n  readonly maxRetries: number;\n  /** Base backoff delay (ms) between retries (exponential backoff applied on top) */\n  readonly baseBackoffMs: number;\n}  /**\n   * Diagnostic / telemetry configuration.\n   * Controls the diagnostic event pipeline for profiling and debugging.\n   * All diagnostics are disabled by default for maximum production performance.\n   */\n  export interface DiagnosticConfig {\n    /** Master switch: enable the diagnostic pipeline (collectors receive events for all pipeline stages) */\n    readonly enabled: boolean;\n    /** Enable VM trace mode, emits per-opcode execution events (very verbose; disables some optimizations) */\n    readonly vmTraceEnabled: boolean;\n  }\n\n  /**\n   * Proactive background refresh of live async values.\n   *\n   * Off by default. When a live value (a stock quote, an FX rate) has gone\n   * stale, today it only refetches on the next re-evaluation (a keystroke), so a\n   * note left open silently ages. With this enabled, the engine drives a refetch\n   * on each such value's own cadence (the resolver's `refetchIntervalMs`) for the\n   * values currently on screen, and pushes the fresh result to the host through\n   * the same event stream the pull path uses. It needs timers and a live editor\n   * consuming that stream, so a headless or batch host leaves it off.\n   */\n  export interface BackgroundRefreshConfig {\n    /** Master switch. When false, no timers run and every value refreshes only on re-evaluation. */\n    readonly enabled: boolean;\n  }\n\n  /**\n   * Whether the engine may reach the network at all.\n   *\n   * On by default, which is the historic behaviour: a city name or a currency\n   * pair in a line fetches live data from a public endpoint as soon as the\n   * line evaluates. A host embedding the engine somewhere that must not make\n   * outbound requests (an offline document, a sandboxed evaluation, a tenant\n   * with egress rules) switches it off here and gets the same engine with no\n   * egress: every live-data form answers with a `NETWORK_DISABLED` error\n   * naming the setting, instead of a request.\n   *\n   * The gate closes before any request is made. It stops every async\n   * resolver a package registers (weather, currency, stocks, crypto,\n   * knowledge, and any host-supplied one) unless the resolver declares\n   * itself `local` (it reads engine state, never a network; the engine's own\n   * global-variable resolver is the one built-in case). It also refuses the\n   * result of a plugin function that returns a promise. That last case is a\n   * boundary rather than a guarantee: such a function has already run by the\n   * time the engine sees the promise, so a package that fetches inside a\n   * plugin function rather than through an async resolver may still have\n   * started its request. The documented shape for live data is the resolver\n   * (`createQueryResolver`), which this gate stops cold.\n   *\n   * Rates a host primes by hand (`currencyExchangeService.primeRates`) keep\n   * working with the network off, which is what an offline host with its own\n   * rate table wants.\n   */\n  export interface NetworkConfig {\n    /** Master switch. When false, no async resolver runs and no live value is fetched. */\n    readonly enabled: boolean;\n  }\n\n  /**\n   * Virtual Machine configuration.\n   * Controls the internal bytecode VM that executes compiled expressions.\n   */\n  export interface VMConfig {\n    /** Maximum stack depth (value slots) for VM execution, prevents stack overflow in recursive/pratt-parser generated bytecode */\n    readonly maxStackDepth: number;\n    /** Maximum opcodes executed per expression, halts runaway infinite loops */\n    readonly maxInstructions: number;\n    /**\n     * Maximum elements a collection may be expanded to before `map`/`reduce`/\n     * `sum`/`prod` will iterate it.\n     *\n     * A Range is stored as its two bounds and costs nothing until something\n     * materializes it, at which point it becomes one Value per element. Twenty\n     * characters (`sum(x, 1:100000000)`) therefore asked for a hundred million\n     * of them, and neither `maxInstructions` nor `maxStackDepth` could see it:\n     * the expansion happens inside a single opcode, so the instruction counter\n     * is never consulted while it runs, and the elements never reach the value\n     * stack. V8 aborted the whole process with \"Reached heap limit\", which a\n     * host embedding the engine cannot catch.\n     */\n    readonly maxCollectionSize: number;\n    /**\n     * Maximum elements (collection Values, matrix cells) one evaluation may\n     * materialize in total.\n     *\n     * `maxCollectionSize` above bounds a single collection. This bounds the sum\n     * of everything an expression asks for, which is a different question and\n     * the one that actually protects the host: two collections that are\n     * individually legal are legal together, and an operation whose result is\n     * the PRODUCT of two legal operands is bounded by neither of them. A matrix\n     * multiply is exactly that shape, so three lines within every other limit\n     * (`:a = map(1*x, 0:20000)`, `:b = transpose(a)`, `b * a`) asked for four\n     * hundred million cells and aborted the process.\n     *\n     * Counted in elements rather than bytes, because a count is what a call\n     * site has before it allocates. An element is 8 bytes as a numeric matrix\n     * cell and closer to a hundred as a full Value, so the default is worth\n     * roughly 16 MB of matrix or 200 MB of expanded collection: far past any\n     * document and far short of what an editor cannot survive.\n     */\n    readonly maxAllocatedElements: number;\n    /**\n     * Maximum user-defined-function calls one evaluation may make in TOTAL,\n     * however deeply or widely they nest.\n     *\n     * `maxFunctionRecursionDepth` bounds how DEEP calls nest and cannot see\n     * how MANY there are, and those are different numbers. Twenty-two lines of\n     * `f(n)(v) = f(n-1)(v) + f(n-1)(v)` reach a depth of only 22 against a\n     * limit of 50, and make 2,097,152 calls doing it: a fatal heap abort in\n     * under a second. `maxInstructions` cannot bound it either, because\n     * `executeBytecode()` re-enters itself per call and each reentrant call\n     * gets its OWN instruction count, so recursion refreshes its allowance on\n     * the way in. This is the tally that does not refresh; see\n     * `vm/AllocationBudget.ts`, which holds it for the same reason it holds\n     * the element tally.\n     *\n     * Counted in calls rather than in the instructions they run, because the\n     * call is the thing that multiplies: every call allocates a frame, its\n     * arguments and its result whatever its body says.\n     */\n    readonly maxFunctionCalls: number;\n    /**\n     * Hard ceiling on how many bisection steps goal seek (`solve line N for\n     * <var> = <target>`, see `packages/goalseek/`) may take before it gives up\n     * with a structured error rather than continuing.\n     *\n     * Goal seek re-evaluates the target line's expression once per step while\n     * narrowing an interval, and an untrusted document must never be able to\n     * make that loop spin. `maxInstructions` bounds each individual\n     * re-evaluation, but not how many of them the search performs, so this is\n     * the tally that bounds the search itself, the same reason `maxFunctionCalls`\n     * exists alongside `maxInstructions`. Bisection halves the interval every\n     * step, so a hundred steps resolves an input to roughly one part in 2^100:\n     * far past any precision a document needs, and a definite stop either way.\n     */\n    readonly maxGoalSeekIterations: number;\n  }\n\n/**\n * Complete engine configuration.\n *\n * Every field has a default in `DEFAULT_CONFIG`. To customize, pass a\n * `Partial<EngineConfig>` when constructing `ExpressionEngine`. Only the\n * sections/fields you supply are overridden; all others use their defaults.\n *\n * @example\n * ```typescript\n * import { ExpressionEngine } from \"solve-js\";\n *\n * const engine = new ExpressionEngine({ config: {\n *   validation: {\n *     maxExpressionLength: 1000,\n *     maxComplexity: 200,\n *   },\n *   // date, performance, vm, worker, diagnostic all use defaults\n * } });\n * ```\n */\nexport interface EngineConfig {\n    /** Date/time expression evaluation bounds and formatting */\n    readonly date: DateConfig;\n    /** Performance budgets and cache sizing */\n    readonly performance: PerformanceConfig;\n    /** Safety limits for expression complexity */\n    readonly validation: ValidationConfig;\n    /** Internal bytecode VM configuration */\n    readonly vm: VMConfig;\n    /** Parallel worker pool configuration */\n    readonly worker: WorkerConfig;\n    /** Diagnostic pipeline configuration */\n    readonly diagnostic: DiagnosticConfig;\n    /** Proactive background refresh of live async values */\n    readonly backgroundRefresh: BackgroundRefreshConfig;\n    /** Whether live data may be fetched at all. See {@link NetworkConfig}. */\n    readonly network: NetworkConfig;\n  }\n\n/**\n * A partial {@link EngineConfig} override, one section at a time.\n *\n * Overrides are merged per section over {@link DEFAULT_CONFIG}, so you can set a\n * single field of one section (`{ validation: { maxExpressionLength: 1000 } }`)\n * and keep every other default in that section. A plain `Partial<EngineConfig>`\n * cannot express that, it demands a whole section object, which is why the\n * documented overrides never typechecked against it. This is the type the\n * constructor and {@link createEngine} accept.\n */\nexport type EngineConfigOverride = {\n  readonly [K in keyof EngineConfig]?: Partial<EngineConfig[K]>;\n};\n\n/**\n * Default configuration values\n */\nexport const DEFAULT_CONFIG: EngineConfig = {\n   date: {\n     // A century of workdays is about 26,000 steps, which is microseconds,\n     // and past any offset a person means. The walk is what these bound; see\n     // DateConfig above for why no other date offset needs a ceiling.\n     maxOffsetYears: 100,\n     minOffsetYears: -100,\n     defaultFormat: 'YYYY-MM-DD',\n     inputOrder: 'auto',\n   },\n   performance: {\n     // Preserves the effective cache size the hardcoded (now-removed)\n     // BYTECODE_CACHE_MAX_ENTRIES constant had, so wiring this field up\n     // doesn't silently shrink the default cache for existing consumers.\n     defaultCacheSize: 2000,\n     // Raised from the 10,000 this field was declared with, which was never\n     // enforced and turned out to be under what this engine already supports:\n     // its paging design is tested against a 20,000-line document\n     // (`engine/PageManager.ts` and its spec) and its throughput benchmark\n     // parses a 50,000-line one. Twice the largest of those, and the same\n     // number `ConfigManager.validate()` already refuses to go above.\n     //\n     // Measured under a 256MB heap: setting a 100,000-line document costs\n     // 64MB, evaluating every line of a 20,000-line one costs 106MB, and\n     // 200,000 lines aborts the process before a single expression is looked\n     // at. A host with a small heap should lower this; the ceiling is here to\n     // stop the size that cannot work anywhere.\n     maxDocumentLines: 100000,\n   },\n    validation: {\n      maxExpressionLength: 2000,\n      maxComplexity: 500,\n      maxNestingDepth: 50,\n      autoBalanceParens: false,\n    },\n    vm: {\n      maxStackDepth: 200,\n      maxInstructions: 50000,\n      // Two orders of magnitude above anything a person types by hand (the\n      // longest range in the test suite is 1000 elements) and small enough\n      // that expanding it is measured in milliseconds rather than in whether\n      // the host survives.\n      maxCollectionSize: 100000,\n      // Twenty times the single-collection ceiling above, so an expression may\n      // legitimately handle a number of large collections, and two hundred\n      // times below the allocation that took the process down.\n      maxAllocatedElements: 2000000,\n      // Six hundred times the largest call count any test or example makes\n      // (five levels of composition is sixteen calls), and small enough that\n      // the calls it does allow cost single-digit megabytes rather than the\n      // heap. A document that needs more than ten thousand calls on one line\n      // is doing something a calculator was not built for.\n      maxFunctionCalls: 10000,\n      // A hundred bisection steps resolve an input to one part in 2^100, far\n      // finer than any document needs and a firm stop for an untrusted one. A\n      // continuous, monotonic relationship converges in tens of steps, well\n      // under this; hitting it means the target is unreachable or the\n      // relationship is not the smooth one goal seek assumes.\n      maxGoalSeekIterations: 100,\n    },\n    worker: {\n      maxConcurrentWorkers: 4,\n      idleTimeoutMs: 30000,\n      maxRetries: 3,\n      baseBackoffMs: 1000,\n    },\n    diagnostic: {\n      enabled: false,\n      vmTraceEnabled: false,\n    },\n    backgroundRefresh: {\n      enabled: false,\n    },\n    network: {\n      // On, because it is what every existing consumer gets today. A host that\n      // must not make outbound requests turns it off; see NetworkConfig.\n      enabled: true,\n    },\n  };\n\n/**\n * Merge a partial config override onto a base `EngineConfig`, section by\n * section, `{ ...base.section, ...override.section }` for each of the 8\n * top-level sections, not a single top-level spread.\n *\n * A shallow `{ ...base, ...override }` at the TOP level replaces an entire\n * section wholesale the moment a caller overrides even one field in it\n * (e.g. `{ performance: { defaultCacheSize: 500 } }` would silently drop\n * every other `performance.*` field back to `undefined`, not to its\n * default). This function exists specifically so every config consumer\n * shares one correct merge instead of each hand-rolling (and risking) its\n * own. `ConfigManager` and `ExpressionEngine` both call this rather than\n * either duplicating the section list or instantiating a whole\n * `ConfigManager` just to reuse its private merge logic.\n */\nexport function mergeEngineConfig(\n  base: EngineConfig,\n  override: EngineConfigOverride\n): EngineConfig {\n  return {\n    date: { ...base.date, ...override.date },\n    performance: { ...base.performance, ...override.performance },\n    validation: { ...base.validation, ...override.validation },\n    vm: { ...base.vm, ...override.vm },\n    worker: { ...base.worker, ...override.worker },\n    diagnostic: { ...base.diagnostic, ...override.diagnostic },\n    backgroundRefresh: { ...base.backgroundRefresh, ...override.backgroundRefresh },\n    network: { ...base.network, ...override.network },\n  };\n}\n\n/**\n * Configuration manager for engine settings\n *\n * @example\n * ```typescript\n * const configManager = new ConfigManager();\n * configManager.set('performance.defaultCacheSize', 2000);\n * const cacheSize = configManager.get('performance.defaultCacheSize');\n * ```\n */\nexport class ConfigManager {\n  private config: EngineConfig;\n\n  constructor(config: Partial<EngineConfig> = {}) {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, config);\n  }\n\n  /**\n   * Get configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @returns Configuration value\n   */\n  get<T>(path: string): T {\n    const keys = path.split('.');\n    let current: unknown = this.config;\n\n    for (const key of keys) {\n      if (current && typeof current === 'object' && key in current) {\n        current = (current as Record<string, unknown>)[key];\n      } else {\n        throw ErrorFactory.config(\n          \"CONFIG_PATH_NOT_FOUND\",\n          `Configuration path not found: ${path}`,\n          { path }\n        );\n      }\n    }\n\n    return current as T;\n  }\n\n  /**\n   * Set configuration value by path\n   * \n   * @param path - Dot-notation path to config value\n   * @param value - New value\n   */\n  set<T>(path: string, value: T): void {\n    const keys = path.split('.');\n    if (keys.length < 2) {\n      throw ErrorFactory.config(\n        \"INVALID_CONFIG_PATH\",\n        `Invalid path: ${path}. Must be in format 'section.property'`,\n        { path }\n      );\n    }\n    \n    const section = keys[0];\n    const property = keys[1];\n    \n    if (!(section in this.config)) {\n      throw ErrorFactory.config(\n        \"CONFIG_SECTION_NOT_FOUND\",\n        `Configuration section not found: ${section}`,\n        { section, path }\n      );\n    }\n    \n    const sectionConfig = this.config[section as keyof EngineConfig];\n    if (sectionConfig && typeof sectionConfig === 'object') {\n      (sectionConfig as unknown as Record<string, unknown>)[property] = value;\n    } else {\n      throw ErrorFactory.config(\n        \"CONFIG_PROPERTY_NOT_FOUND\",\n        `Configuration property not found: ${path}`,\n        { path }\n      );\n    }\n  }\n\n  /**\n   * Get complete configuration.\n   *\n   * A detached copy, section objects included. A top-level spread would hand\n   * the caller this manager's own section objects, so `getConfig().vm.x = 1`\n   * would be an undeclared back door into {@link set}, bypassing its path\n   * validation and reaching every later {@link get}.\n   */\n  getConfig(): EngineConfig {\n    return mergeEngineConfig(this.config, {});\n  }\n\n  /**\n   * Update multiple configuration values\n   */\n  update(config: Partial<EngineConfig>): void {\n    this.config = mergeEngineConfig(this.config, config);\n  }\n\n  /**\n   * Reset to default configuration.\n   *\n   * Goes through {@link mergeEngineConfig} for the same reason the constructor\n   * does. A top-level `{ ...DEFAULT_CONFIG }` copies the six section\n   * references, not the sections, so after a reset this manager's\n   * `performance` object WAS `DEFAULT_CONFIG.performance` and the next\n   * `set('performance.x', ...)` wrote into the module constant. That constant\n   * is what every `ExpressionEngine` is built from, so one manager's reset\n   * could change the cache size, instruction ceiling or allocation budget of\n   * every engine constructed later in the process.\n   */\n  reset(): void {\n    this.config = mergeEngineConfig(DEFAULT_CONFIG, {});\n  }\n\n  /**\n   * Validate configuration values\n   */\n  validate(): ValidationResult {\n    const errors: string[] = [];\n\n    // Validate performance config\n    if (this.config.performance.maxDocumentLines > 100000) {\n      errors.push('maxDocumentLines cannot exceed 100,000');\n    }\n\n    // Validate date config\n    if (this.config.date.maxOffsetYears > 1000) {\n      errors.push('maxOffsetYears cannot exceed 1000');\n    }\n\n    return {\n      valid: errors.length === 0,\n      error: errors.join('; '),\n      warnings: []\n    };\n  }\n}\n\n/**\n * Result type for {@link ConfigManager.validate}.\n */\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n"]}

package/dist/chunk-WFOQRPA6.js

@@ -1,2 +0,0 @@
-import {c as c$2}from'./chunk-JP4JMQOG.js';import {b,a as a$2,e,d}from'./chunk-RENO2AWO.js';import {c,a}from'./chunk-IJMNVBIS.js';import {a as a$1}from'./chunk-LHLW7JLS.js';import {c as c$1}from'./chunk-BDF4VCQX.js';var D=/^\d{1,3}(\.\d{3}){2,}$/,T=/^\d*\.\d*$/,n=class n{constructor(e,t=50,r="en",p){this.tokens=[];this.current=0;this.depth=0;this.currentExpression="";this.infixMinBindingPower=0;this.registry=e,this.maxDepth=t,this.localeCode=r;let a=a$1(r).display;this.decimalSeparator=a.decimalSeparator,this.thousandsSeparator=a.thousandsSeparator,this.pluginFunctionIndex=p;}getLocaleCode(){return this.localeCode}setDiagnosticPipeline(e,t){this.diagnosticPipeline=e,this.currentExpression=t??"";}load(e,t){if(t===false){this.tokens=e,this.current=0,this.depth=0;return}let r=c(a.LPAREN),p=c(a.RPAREN),a$1=0;for(let l=0;l<e.length;l++)e[l].typeId===r?a$1++:e[l].typeId===p&&a$1--;this.tokens=a$1===0?e:this.balanceParens(e,a$1),this.current=0,this.depth=0;}balanceParens(e,t){let r=e.slice();if(t>0){let p=c(a.RPAREN);for(let a$1=0;a$1<t;a$1++){let l=e[e.length-1];r.push({type:a.RPAREN,typeId:p,value:")",text:")",offset:l?l.offset+l.text.length:0,lineBreaks:0,line:l?l.line:1,col:l?l.col+l.text.length:1});}}else if(t<0){let p=c(a.LPAREN);for(let a$1=0;a$1<-t;a$1++)r.unshift({type:a.LPAREN,typeId:p,value:"(",text:"(",offset:0,lineBreaks:0,line:1,col:1});}return r}parseExpression(e=0,t){if(t&&(this.builder=t),this.depth++,this.depth>this.maxDepth)throw this.depth--,c$1.parsing("NESTING_DEPTH_EXCEEDED",`Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,{maxDepth:this.maxDepth,currentDepth:this.depth});let r=this.consume();if(!r)throw this.depth--,c$1.parsing("UNEXPECTED_END","Unexpected end of expression");this.parsePrefix(r);let p=this.tokens,a=p.length,l=n.BP_TABLE,o=this.registry,c=this.builder,d=this.current;for(;d<a;){let h=p[d];if(!h)break;let I=l[h.typeId];if(I>0){if(I<=e)break;if(this.diagnosticPipeline){let m=o.getInfix(h.typeId);m&&this.fireParseletMatched(m,h,false,I);}this.current=++d;let f=h.typeId;if(f===n.PERCENT_ID)c.emitOpcode(10),c.emitNumber(100),c.emitOpcode(23),c.emitOpcode(74);else if(!(f===n.CARET_ID&&this.tryEmitMatrixCaretOp(c))){let m=f===n.CARET_ID?I-1:I+1;this.parseExpression(m,c),c.emitOpcode(n.INFIX_OPCODE[f]);}}else {let f=o.getInfix(h.typeId);if(!f||f.bindingPower<=e)break;this.current=++d,this.diagnosticPipeline&&this.fireParseletMatched(f,h,false,f.bindingPower),this.infixMinBindingPower=e,f.parse(this,r,h,c);}d=this.current;}this.current=d,this.depth--;}parsePrefix(e$1){let t=this.builder,r=e$1.typeId;if(this.diagnosticPipeline){let a=this.registry.getPrefix(r);a&&this.fireParseletMatched(a,e$1,true);}switch(r){case n.NUMBER_ID:{let a,l=null,o=e$1.value;if(this.decimalSeparator==="."){let c=0,d=o.length>0;for(let h=0;h<o.length;h++){let I=o.charCodeAt(h);if(!(I>=48&&I<=57)){if(I===46&&c===0){c=1;continue}d=false;break}}if(d){if(c===1){t.emitOpcode(16),t.emitString(o);return}t.emitOpcode(10),t.emitNumber(+o);return}}if(o.startsWith("0x")||o.startsWith("0X")){if(a=parseInt(o,16),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid hex literal: "${o}"`,{raw:o})}else if(o.startsWith("0b")||o.startsWith("0B")){if(a=parseInt(o.slice(2),2),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid binary literal: "${o}"`,{raw:o})}else if(o.startsWith("0o")||o.startsWith("0O")){if(a=parseInt(o.slice(2),8),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid octal literal: "${o}"`,{raw:o})}else if(D.test(o))a=parseFloat(o.split(".").join(""));else {let c=this.decimalSeparator,d=this.thousandsSeparator,h=o;d&&h.indexOf(d)!==-1&&(h=h.split(d).join("")),c&&c!=="."&&(h=h.replace(c,".")),a=parseFloat(h),T.test(h)&&(l=h);}if(l!==null){t.emitOpcode(16),t.emitString(l);return}t.emitOpcode(10),t.emitNumber(a);return}case n.BIGINT_ID:{t.emitOpcode(11),t.emitString(e(e$1.value,this.localeCode));return}case n.STRING_ID:{t.emitOpcode(13),t.emitString(e$1.value);return}case n.IDENT_ID:{if(this.peek()?.typeId===n.LPAREN_ID){this.parseUserFunctionDefOrCall(e$1,t);return}t.emitOpcode(60),t.emitString(e$1.value);return}case n.LPAREN_ID:{this.parseExpression(0,t);let a$1=1;for(;this.match(a.COMMA);)this.parseExpression(0,t),a$1++;this.consume(a.RPAREN),a$1>1&&(t.emitOpcode(152),t.emitIndex(1),t.emitIndex(a$1));return}case n.MINUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(26);return}case n.PLUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(27);return}case n.KEYWORD_ID:}let p=this.registry.getPrefix(r);if(!p)throw c$1.parsing("NO_PREFIX_PARSELET",`No prefix parselet found for token: ${e$1.type} ("${e$1.value}")`,{tokenType:e$1.type,tokenValue:e$1.value});p.parse(this,e$1,t);}tryEmitMatrixCaretOp(e){for(let t of n.CARET_SUFFIX_RULES)if(t.matches(this))return t.emit(this,e),true;return  false}findMatchingRParen(e){let t=0;for(let r=e;r<this.tokens.length;r++){let p=this.tokens[r];if(p.typeId===n.LPAREN_ID)t++;else if(p.typeId===n.RPAREN_ID&&(t--,t===0))return r}return null}parseUserFunctionDefOrCall(e,t){let r=this.findMatchingRParen(this.current);if(r===null){t.emitOpcode(60),t.emitString(e.value);return}this.tokens[r+1]?.type===a.EQUALS?this.parseUserFunctionDefinition(e,t):this.parseUserFunctionCall(e,t);}consumeParamName(){let e=this.peek();if(e?.type===a.IDENT||e?.type===a.UNIT)return this.consume(),e.value;throw c$1.parsing("USER_FUNCTION_INVALID_PARAM_NAME",`Expected a parameter name but got "${e?.type??"end of input"}"${e?` ("${e.value}")`:""}`,{actualType:e?.type})}parseUserFunctionDefinition(e,t){this.consume(a.LPAREN);let r=[];if(this.peek()?.type!==a.RPAREN)for(r.push(this.consumeParamName());this.match(a.COMMA);)r.push(this.consumeParamName());if(this.consume(a.RPAREN),this.consume(a.EQUALS),r.length===0)throw c$1.parsing("USER_FUNCTION_NO_PARAMS",`"${e.value}()" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,{name:e.value});let p=new d(this.pluginFunctionIndex);this.parseExpression(a$2.Lowest,p),this.setBuilder(t);let a$1=p.build();if(a$1.hasAsync)throw c$1.parsing("FUNCTION_BODY_MUST_BE_SYNCHRONOUS",`"${e.value}(...)"'s body calls an async operation (weather, stocks, currency, ...) \u2014 user-defined function bodies must be synchronous`,{name:e.value});let l=t.emitUserFunctionBody(e.value,r,a$1);t.emitOpcode(150),t.emitIndex(l),t.emitOpcode(13),t.emitString(`${e.value}(${r.join(", ")}) defined`);}parseUserFunctionCall(e,t){this.consume(a.LPAREN);let r=0;if(this.peek()?.type!==a.RPAREN)for(this.parseExpression(a$2.Lowest,t),r++;this.match(a.COMMA);)this.parseExpression(a$2.Lowest,t),r++;this.consume(a.RPAREN),t.emitOpcode(151),t.emitString(e.value),t.emitByte(r);}consume(e){let t=this.tokens[this.current];if(!t)throw c$1.parsing("UNEXPECTED_END_OF_INPUT","Unexpected end of input");if(e!==void 0){let r=c(e);if(t.typeId!==r)throw c$1.parsing("UNEXPECTED_TOKEN_TYPE",`Expected token type "${e}" but got "${t.type}" ("${t.value}")`,{expectedType:e,actualType:t.type,actualValue:t.value})}return this.current++,t}match(e){let t=this.peek();return t&&t.typeId===c(e)?(this.advance(),true):false}peek(){return this.tokens[this.current]}peekAt(e){return this.tokens[this.current+e]}previous(){return this.current>0?this.tokens[this.current-1]:void 0}advance(){this.current++;}setBuilder(e){this.builder=e;}fireParseletMatched(e,t,r,p){let a=this.diagnosticPipeline,l={type:c$2.ParseletMatched,elapsedNs:0,expression:this.currentExpression,tokenType:t.type,tokenValue:t.value,parseletCategory:e.category,parseletType:e.constructor?.name??"unknown",isPrefix:r,bindingPower:p,tokenOffset:t.offset||0};a.fireParseletMatched(l);}};n.BP_TABLE=b(),n.NUMBER_ID=c(a.NUMBER),n.BIGINT_ID=c(a.BIGINT),n.STRING_ID=c(a.STRING),n.IDENT_ID=c(a.IDENT),n.LPAREN_ID=c(a.LPAREN),n.RPAREN_ID=c(a.RPAREN),n.MINUS_ID=c(a.MINUS),n.PLUS_ID=c(a.PLUS),n.KEYWORD_ID=c(a.KEYWORD),n.STAR_ID=c(a.STAR),n.SLASH_ID=c(a.SLASH),n.MOD_ID=c(a.MOD),n.CARET_ID=c(a.CARET),n.LSHIFT_ID=c(a.LSHIFT),n.RSHIFT_ID=c(a.RSHIFT),n.URSHIFT_ID=c(a.URSHIFT),n.BIT_AND_ID=c(a.BIT_AND),n.BIT_OR_ID=c(a.BIT_OR),n.BIT_XOR_ID=c(a.BIT_XOR),n.PERCENT_ID=c(a.PERCENT),n.OF_ID=c(a.OF),n.INFIX_OPCODE={[c(a.PLUS)]:20,[c(a.MINUS)]:21,[c(a.STAR)]:22,[c(a.SLASH)]:23,[c(a.MOD)]:24,[c(a.CARET)]:25,[c(a.LSHIFT)]:30,[c(a.RSHIFT)]:31,[c(a.URSHIFT)]:32,[c(a.BIT_AND)]:33,[c(a.BIT_OR)]:34,[c(a.BIT_XOR)]:35,[c(a.OF)]:22},n.CARET_SUFFIX_RULES=[{name:"transpose (^T)",matches:e=>{let t=e.peek();return t?.type===a.IDENT&&t.value==="T"},emit:(e,t)=>{e.advance(),t.emitOpcode(51),t.emitIndex(63),t.emitIndex(1);}},{name:"inverse (^-1)",matches:e=>{if(e.peek()?.typeId!==n.MINUS_ID)return  false;let r=e.peekAt(1);return r?.type===a.NUMBER&&r.value==="1"},emit:(e,t)=>{e.advance(),e.advance(),t.emitOpcode(51),t.emitIndex(65),t.emitIndex(1);}}];var v=n;var y=class{constructor(){this.prefixParselets=new Map;this.infixParselets=new Map;this.prefixById=new Map;this.infixById=new Map;}registerPrefix(e,t){let r=this.prefixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Prefix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.prefixParselets.set(e,t),this.prefixById.set(c(e),t);}registerInfix(e,t){let r=this.infixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Infix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.infixParselets.set(e,t),this.infixById.set(c(e),t);}getAllPrefix(){let e=[];for(let[t,r]of this.prefixParselets)e.push({tokenType:t,bindingPower:r.bindingPower??a$2.Prefix,category:r.category});return e}getAllInfix(){let e=[];for(let[t,r]of this.infixParselets){let p=r.bindingPower??0;e.push({tokenType:t,leftBindingPower:p,rightBindingPower:p+1,category:r.category});}return e}get prefixCount(){return this.prefixParselets.size}get infixCount(){return this.infixParselets.size}getPrefix(e){return typeof e=="number"?this.prefixById.get(e):this.prefixParselets.get(e)}getInfix(e){return typeof e=="number"?this.infixById.get(e):this.infixParselets.get(e)}hasPrefix(e){return this.prefixParselets.has(e)}hasInfix(e){return this.infixParselets.has(e)}clear(){this.prefixParselets.clear(),this.infixParselets.clear(),this.prefixById.clear(),this.infixById.clear();}},H=new y;export{v as a,y as b,H as c};//# sourceMappingURL=chunk-WFOQRPA6.js.map
-//# sourceMappingURL=chunk-WFOQRPA6.js.map