solve-engine 1.2.0 → 2.1.0

package/dist/chunk-G7TBEQRQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/ExpressionLexer.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"],"mappings":"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","file":"chunk-G7TBEQRQ.js","sourcesContent":["import { Token, tokenTypeId, registerAllTokenTypes } from '@solve-js/lexer/Token';\nimport { knownUnits } from '@solve-js/lexer/units';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { ErrorFactory } from '@solve-js/errors/UnifiedErrorFramework';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\n\n// Bootstrap all token types at module load\nregisterAllTokenTypes();\n\n// ── Markdown line classification (Phase B) ──────────────────────────────\n\n/** What a line is, structurally, before anything tries to evaluate it. */\nexport type MarkdownLineType =\n  | 'expression'\n  | 'prose'\n  | 'heading'\n  | 'blockquote'\n  | 'list'\n  | 'code_fence'\n  | 'math_fence'\n  | 'table'\n  | 'table_separator'\n  | 'hr'\n  | 'wikilink'\n  | 'comment'\n  | 'empty';\n\n/**\n * What a line is and whether it holds anything to evaluate.\n *\n * Produced by a character-level scan that never consults the keyword, unit or\n * operator tables, so any lexer gives the same answer for the same line. See\n * `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n */\nexport interface LineClassification {\n  /** The type of this markdown line */\n  type: MarkdownLineType;\n  /** Whether this line should be skipped (no expression evaluation) */\n  skip: boolean;\n  /** Whether the line contains inline solve markers (`s`...``) */\n  hasInlineSolve: boolean;\n  /**\n   * 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  private mergedUnits: Set<string>;\n\n  // Plugin-extensible keyword map (merged with locale keywordMap)\n  private pluginKeywordMap: Map<string, string> = new Map();\n\n  // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)\n  private pluginOperators: Map<number, Map<number, string>> = new Map();\n\n  // Plugin-extensible units (merged with knownUnits)\n  private pluginUnits: Set<string> = new Set();\t// Fast-path guards: skip plugin lookups entirely when no plugins registered\n\tprivate hasPluginOps = false;\n\n  // Locale for function-identifier lookups\n  private localeCode: string;\n  private locale: ILocale;\n\n  /**\n   * Inline solve spans collected during the most recent tokenization pass.\n   * Populated by [Symbol.iterator]() and consumed by scanDocument().\n   */\n  _inlineSolveSpans: InlineSolveSpan[] = [];\n\n  // Plugin-extensible raw-line patterns. See LexerVocabulary.rawLinePatterns.\n  private pluginRawLinePatterns: Array<{ pattern: RegExp; tokenType: string }> = [];\n\n  /**\n   * If a `rawLinePatterns` rule matches the FULL text most recently passed\n   * to {@link reset}, this holds the single synthetic token that\n   * {@link tokenizeAll} should return instead of running the\n   * character-by-character scanner. Cleared (re-evaluated) on every\n   * {@link reset} call. `null` when no plugin registered any raw-line\n   * patterns, or none matched, the overwhelmingly common case, checked\n   * with a `length === 0` guard before ever touching this field so a\n   * plugin-free lexer pays zero cost for the feature.\n   */\n  private pendingRawLineToken: Token | null = null;\n\n  /**\n   * Test `text` against every registered `rawLinePatterns` rule, in\n   * registration order. Returns a synthetic token for the first rule\n   * whose `pattern` matches AND whose capture group 1 is non-empty after\n   * trimming; returns `null` if no rule matches (the normal\n   * character-by-character scanner should run instead).\n   */\n  private matchRawLine(text: string): Token | null {\n    for (const rule of this.pluginRawLinePatterns) {\n      const m = rule.pattern.exec(text);\n      if (m && typeof m[1] === 'string') {\n        const value = m[1].trim();\n        if (value.length > 0) {\n          return new LexerToken(rule.tokenType, tokenTypeId(rule.tokenType), value, value, 0, 0, this.line, 1);\n        }\n      }\n    }\n    return null;\n  }\n\n  /** Rebuild merged keyword and unit collections after plugin registration. */\n  private rebuildMergedCollections(): void {\n    this.mergedKeywords = new Map([...this.keywordMap, ...this.pluginKeywordMap]);\n    this.mergedUnits = new Set([...knownUnits, ...this.pluginUnits]);\n  }\n\n  constructor(localeCode = 'en', lookup?: TokenLookup) {\n    this.localeCode = localeCode;\n    this.locale = getLocale(localeCode);\n    this.configuredLookup = lookup ?? null;\n    this.keywordMap = new Map<string, string>();\n    for (const [k, v] of Object.entries(this.locale.keywordMap)) {\n      this.keywordMap.set(k.toLowerCase(), v);\n    }\n    this.mergedKeywords = new Map(this.keywordMap);\n    this.mergedUnits = new Set(knownUnits);\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   *\n   * All registrations are additive, built-in patterns still work.\n   * Keywords, operators, and units from the plugin are merged\n   * with existing ones. Calling multiple times adds more entries.\n   *\n   * Note: multi-word phrases are now handled by the TokenNormalizer\n   * (see `IEnginePackage.normalizerRules`), not the lexer.\n   *\n   * Built-in tokens CANNOT be overridden. Throws a EngineError if the\n   * plugin attempts to register a keyword, operator, or unit\n   * that conflicts with a built-in one.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const [keyword, tokenType] of Object.entries(plugin.keywords)) {\n        const lower = keyword.toLowerCase();\n        // Guard: prevent overriding built-in locale keywords\n        if (this.keywordMap.has(lower)) {\n          throw ErrorFactory.config(\n            'PLUGIN_KEYWORD_COLLISION',\n            `Plugin keyword \"${keyword}\" conflicts with built-in keyword ` +\n            `(type: ${this.keywordMap.get(lower)}). Built-in keywords cannot be overridden.`,\n            { keyword, builtinType: this.keywordMap.get(lower) }\n          );\n        }\n        this.pluginKeywordMap.set(lower, tokenType);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      this.hasPluginOps = true;\n      for (const [chars, tokenType] of Object.entries(plugin.operators)) {\n        // Only support 2-char operators for the fast path\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n\n          // Guard: prevent overriding built-in two-char operators (==, !=, >=, <=)\n          const builtInSecondMap = TWO_CHAR_OPS[first];\n          if (builtInSecondMap && builtInSecondMap[second] !== undefined) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: ${builtInSecondMap[second]}). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: builtInSecondMap[second] }\n            );\n          }\n          // Guard: prevent overriding LSHIFT (<<) and RSHIFT (>>)\n          if (first === 60 && second === 60) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: LSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'LSHIFT' }\n            );\n          }\n          if (first === 62 && second === 62) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: RSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'RSHIFT' }\n            );\n          }\n          // Guard: prevent overriding comment sequences (//)\n          if (first === 47 && second === 47) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in comment sequence. ` +\n              `Comment sequences cannot be overridden.`,\n              { operator: chars, builtinType: 'COMMENT' }\n            );\n          }\n\n          let inner = this.pluginOperators.get(first);\n          if (!inner) {\n            inner = new Map();\n            this.pluginOperators.set(first, inner);\n          }\n          inner.set(second, tokenType);\n        }\n      }\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        // Guard: prevent overriding built-in units\n        if (knownUnits.has(unit)) {\n          throw ErrorFactory.config(\n            'PLUGIN_UNIT_COLLISION',\n            `Plugin unit \"${unit}\" conflicts with a built-in unit. ` +\n            `Built-in units cannot be overridden.`,\n            { unit }\n          );\n        }\n        this.pluginUnits.add(unit);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      this.pluginRawLinePatterns.push(...plugin.rawLinePatterns);\n    }\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   *\n   * This is the inverse of registerVocabulary(). All keywords, operators,\n   * and units registered by the plugin are removed. After\n   * unregistration, those tokens will revert to their default behavior\n   * (e.g., keywords become IDENT, operators become ERROR).\n   *\n   * Calling unregisterVocabulary with a plugin that was never registered\n   * is safe, it simply has no effect.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const keyword of Object.keys(plugin.keywords)) {\n        this.pluginKeywordMap.delete(keyword.toLowerCase());\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      for (const chars of Object.keys(plugin.operators)) {\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n          const inner = this.pluginOperators.get(first);\n          if (inner) {\n            inner.delete(second);\n            if (inner.size === 0) {\n              this.pluginOperators.delete(first);\n            }\n          }\n        }\n      }\n      this.hasPluginOps = this.pluginOperators.size > 0;\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        this.pluginUnits.delete(unit);\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      const toRemove = new Set(plugin.rawLinePatterns);\n      this.pluginRawLinePatterns = this.pluginRawLinePatterns.filter((r) => !toRemove.has(r));\n    }\n  }\n\n  reset(input: string): void {\n    this.input = input;\n    this.pos = 0;\n    this.len = input.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n    this.pendingRawLineToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(input) : null;\n  }\n\n  /**\n   * Scan a full document text in a single pass, classifying each line and\n   * tokenizing non-skipped lines.\n   *\n   * Replaces the separate classifyLine() + findInlineSolves() + per-line\n   * reset() + tokenizeAll() pattern with a single character-by-character\n   * walk through the entire document. Key benefits:\n   *\n   * - **Single reset()**: `this.pos`, `this.len`, `this.line`, and\n   *   `this.lineStartPos` are set once for the whole document, not per-line.\n   * - **Single classification**: classifyLine() runs once per line inline;\n   *   skipped lines are jumped over without tokenization.\n   * - **Shared tokenization**: Non-skipped lines are tokenized using the\n   *   existing state machine, yielding Token[] without per-line reset().\n   * - **Inline solve detection**: findInlineSolves() is called only for\n   *   lines that classifyLine() marks as having inline solves.\n   *\n   * Tokenization is scoped to each line by temporarily restricting\n   * `this.len` to the line end position, so the [Symbol.iterator]\n   * generator naturally stops at the line boundary. After tokenization,\n   * `this.len` is restored and `this.pos` advances past the newline.\n   *\n   * @param text The full document text (with newlines).\n   * @returns Array of ScanLineResult, one per line, in document order.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    this.input = text;\n    this.pos = 0;\n    this.len = text.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n\n    const results: ScanLineResult[] = [];\n    const input = this.input;\n    const docLen = this.len;\n\n    while (this.pos < docLen) {\n      const lineStart = this.pos;\n\n      // ── Find end of current line (newline boundary) ───────────────\n      let lineEnd = this.pos;\n      while (lineEnd < docLen) {\n        const cc = input.charCodeAt(lineEnd);\n        if (cc === 10 || cc === 13) break;  // \\n or \\r\n        lineEnd++;\n      }\n\n      const lineNumber = this.line;\n\n      // ── Classify the line ─────────────────────────────────────────\n      // Uses classifyFromPositions() to read from this.input directly\n      // avoids allocating a substring and keeps classification reads\n      // within the same memory region as tokenization.\n      const classification = this.classifyFromPositions(lineStart, lineEnd);\n\n      // ── Slice line text for ScanLineResult.text ────────────────\n      // Hoisted above tokenization (rather than after, as originally) so the\n      // raw-line-pattern check below can test the exact substring a plugin\n      // registered via `LexerVocabulary.rawLinePatterns`. See reset()/\n      // tokenizeAll() for the single-expression-string equivalent of this\n      // same check.\n      const lineText = input.slice(lineStart, lineEnd);\n\n      // ── Tokenize non-skipped lines ────────────────────────────────\n      let tokens: Token[] = [];\n      if (!classification.skip) {\n        const rawToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(lineText) : null;\n        if (rawToken) {\n          tokens = [rawToken];\n        } else {\n          // Scope tokenization to just this line by temporarily restricting len.\n          // The [Symbol.iterator]() generator captures `this.len` at call time,\n          // so creating the iterator AFTER setting this.len = lineEnd ensures\n          // tokenization stops at the line boundary. After tokenization,\n          // this.pos will be at lineEnd (the newline position).\n          const savedLen = this.len;\n          this.len = lineEnd;\n          // 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}"]}

package/dist/chunk-GK2OHWRF.cjs

@@ -0,0 +1,5 @@
+'use strict';var chunkFDE5HWDI_cjs=require('./chunk-FDE5HWDI.cjs'),chunkZCNBT44X_cjs=require('./chunk-ZCNBT44X.cjs'),chunkTTFO4YDP_cjs=require('./chunk-TTFO4YDP.cjs'),chunkSYYE3QAX_cjs=require('./chunk-SYYE3QAX.cjs'),chunkAXMQG5TS_cjs=require('./chunk-AXMQG5TS.cjs'),chunkHLBYHXQD_cjs=require('./chunk-HLBYHXQD.cjs'),chunk7BXPCWKM_cjs=require('./chunk-7BXPCWKM.cjs'),chunk4QVBSG6B_cjs=require('./chunk-4QVBSG6B.cjs'),chunkVAGS5JS7_cjs=require('./chunk-VAGS5JS7.cjs'),chunkUURM7P3P_cjs=require('./chunk-UURM7P3P.cjs'),chunkZLRJ7TDP_cjs=require('./chunk-ZLRJ7TDP.cjs'),chunkJAK3RAFA_cjs=require('./chunk-JAK3RAFA.cjs'),chunkN7N7MPMK_cjs=require('./chunk-N7N7MPMK.cjs'),chunkPS272DZJ_cjs=require('./chunk-PS272DZJ.cjs'),chunkEVI6OHQH_cjs=require('./chunk-EVI6OHQH.cjs'),chunk32GC2FHC_cjs=require('./chunk-32GC2FHC.cjs'),chunkY7O4D3BJ_cjs=require('./chunk-Y7O4D3BJ.cjs'),chunk2LFLR3VZ_cjs=require('./chunk-2LFLR3VZ.cjs'),chunk5IJD5L3O_cjs=require('./chunk-5IJD5L3O.cjs'),chunkMSYX32PF_cjs=require('./chunk-MSYX32PF.cjs'),chunkSOMGSIO4_cjs=require('./chunk-SOMGSIO4.cjs');function xt(n,e,t,r,i){let s=t[e],o=r[e];if(!s||!o)return;let a=new Set(Object.keys(s));for(let l of Object.keys(o))a.has(l)&&i.push({kind:n,severity:"warning",detail:`Both "${t.name}" and "${r.name}" register a ${e==="prefixParselets"?"prefix":"infix"} parselet for token type "${l}" \u2014 the later-registered one silently wins.`,packages:[t.name,r.name]});}function Ht(n,e){let t=[];if(xt("prefixParseletTokenType","prefixParselets",n,e,t),xt("infixParseletTokenType","infixParselets",n,e,t),n.phrases&&e.phrases)for(let[s,o]of Object.entries(e.phrases)){let a=n.phrases[s];a!==void 0&&a!==o&&t.push({kind:"phrase",severity:"warning",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") fuse the phrase "${s}" to DIFFERENT token types \u2014 PhraseTrie has no collision detection of its own, so the later-registered mapping silently wins with no other signal.`,packages:[n.name,e.name]});}if(n.asConverters&&e.asConverters)for(let s of Object.keys(e.asConverters)){let o=s.toLowerCase();Object.keys(n.asConverters).some(a=>a.toLowerCase()===o)&&t.push({kind:"converterName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register an "as ${s}" converter \u2014 the later-registered handler silently wins.`,packages:[n.name,e.name]});}if(n.pluginFunctions&&e.pluginFunctions){let s=new Set(Object.keys(n.pluginFunctions));for(let o of Object.keys(e.pluginFunctions))s.has(o)&&t.push({kind:"pluginFunctionName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register a plugin function named "${o}" \u2014 the later registration wins in the engine's name-to-index map. Give each package's functions package-unique names.`,packages:[n.name,e.name]});}if(n.normalizerRules&&e.normalizerRules){let s=new Set(n.normalizerRules.map(o=>o.name));for(let o of e.normalizerRules)s.has(o.name)&&t.push({kind:"normalizerRuleName",severity:"warning",detail:`Both "${n.name}" and "${e.name}" register a normalizer rule named "${o.name}" \u2014 the normalizer unregisters rules by name, so removing either package would drop both rules. Give each package's rules a package-unique name.`,packages:[n.name,e.name]});}let r=n.lexerVocabulary,i=e.lexerVocabulary;if(r?.keywords&&i?.keywords)for(let[s,o]of Object.entries(i.keywords)){let a=r.keywords[s];a!==void 0&&a!==o&&t.push({kind:"lexerKeyword",severity:"error",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") register the lexer keyword "${s}" for DIFFERENT token types \u2014 whichever package registers second wins, and the loser's grammar becomes silently unreachable for that word.`,packages:[n.name,e.name]});}if(r?.operators&&i?.operators)for(let[s,o]of Object.entries(i.operators)){let a=r.operators[s];a!==void 0&&a!==o&&t.push({kind:"lexerOperator",severity:"error",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") register the lexer operator "${s}" for DIFFERENT token types.`,packages:[n.name,e.name]});}if(n.asyncResolvers&&e.asyncResolvers){let s=new Set(n.asyncResolvers.map(o=>o.namespace));for(let o of e.asyncResolvers)s.has(o.namespace)&&t.push({kind:"asyncResolverNamespace",severity:"error",detail:`Both "${n.name}" and "${e.name}" register an async resolver under the namespace "${o.namespace}" \u2014 ResolverRegistry is keyed by namespace, so one resolver's cache/preflight state will silently clobber the other's.`,packages:[n.name,e.name]});}if(n.tokenCategories&&e.tokenCategories)for(let[s,o]of Object.entries(e.tokenCategories)){let a=n.tokenCategories[s];a!==void 0&&a!==o&&t.push({kind:"tokenCategory",severity:"info",detail:`Both "${n.name}" (-> "${a}") and "${e.name}" (-> "${o}") declare a highlight category for token type "${s}" \u2014 cosmetic only, but the later registration wins.`,packages:[n.name,e.name]});}return t}function kt(n,e){let t=[];for(let r of e)r===n||r.name===n.name||t.push(...Ht(r,n));return {compatible:!t.some(r=>r.severity==="error"),conflicts:t}}var Kt=/(\d+)\.(\d+)\.(\d+)/,jt=/^\d+$/;function Ct(n){let e=Kt.exec(n.trim());return e?[Number(e[1]),Number(e[2]),Number(e[3])]:null}function Gt(n,e){return n[0]-e[0]||n[1]-e[1]||n[2]-e[2]}function Te(n){let e=n.split(".");if(e.length===0||e.length>3)return null;let t=[0,0,0];for(let r=0;r<e.length;r++){if(!jt.test(e[r]))return null;t[r]=Number(e[r]);}return [t[0],t[1],t[2]]}function qt([n,e,t]){let r=n>0?[n+1,0,0]:e>0?[0,e+1,0]:[0,0,t+1];return [{op:">=",v:[n,e,t]},{op:"<",v:r}]}function Qt([n,e,t]){return [{op:">=",v:[n,e,t]},{op:"<",v:[n,e+1,0]}]}function Xt(n){if(n===""||n==="*"||n==="x"||n==="X")return [];if(n[0]==="^"){let i=Te(n.slice(1));return i&&qt(i)}if(n[0]==="~"){let i=Te(n.slice(1));return i&&Qt(i)}let e=/^(>=|<=|>|<|=)/.exec(n),t=e?e[1]:"=",r=Te(e?n.slice(e[1].length):n);return r&&[{op:t,v:r}]}function Tt(n){let e=[];for(let t of n.split("||")){let r=t.trim().split(/\s+/).filter(s=>s!==""),i=[];for(let s of r){let o=Xt(s);if(o===null)return null;i.push(...o);}e.push(i);}return e}function Nt(n){return Tt(n.trim())!==null}function Jt(n,e){let t=Gt(n,e.v);switch(e.op){case "<":return t<0;case "<=":return t<=0;case ">":return t>0;case ">=":return t>=0;case "=":return t===0}}function wt(n,e){let t=Tt(e.trim());return t===null?false:t.some(r=>r.every(i=>Jt(n,i)))}function Yt(n,e=chunkEVI6OHQH_cjs.a){if(!n.engineVersion)return {compatible:true};if(!Nt(n.engineVersion))return {compatible:false,reason:"invalid-range",declaredRange:n.engineVersion,engineVersion:e};let t=Ct(e);return t===null||!wt(t,n.engineVersion)?{compatible:false,reason:"range-not-satisfied",declaredRange:n.engineVersion,engineVersion:e}:{compatible:true}}function At(n,e=chunkEVI6OHQH_cjs.a){let t=Yt(n,e);if(!t.compatible)throw t.reason==="invalid-range"?chunkSOMGSIO4_cjs.c.config({code:"PACKAGE_ENGINE_VERSION_INVALID_RANGE",message:`Package "${n.name}" declares an invalid engineVersion range: "${t.declaredRange}" is not a valid semver range.`,expected:'a valid semver range string (e.g. "^0.1.0", ">=0.2.0 <1.0.0")',found:`"${t.declaredRange}"`,suggestion:`This is a range-syntax typo in "${n.name}"'s own descriptor, not a version mismatch with the running engine \u2014 check for a stray character.`,context:{packageName:n.name,declaredRange:t.declaredRange}}):chunkSOMGSIO4_cjs.c.config({code:"PACKAGE_ENGINE_VERSION_MISMATCH",message:`Package "${n.name}" declares engineVersion "${t.declaredRange}", which is not satisfied by the running engine version "${t.engineVersion}".`,expected:`an engine version satisfying "${t.declaredRange}"`,found:`engine version "${t.engineVersion}"`,suggestion:`Update "${n.name}" to a version built against solve-engine ${t.engineVersion}, or pin solve-engine to a version satisfying "${t.declaredRange}".`,context:{packageName:n.name,declaredRange:t.declaredRange,engineVersion:t.engineVersion}})}var G="solve-engine/snapshot",H=1;function F(n){return Number.isFinite(n)?n:Number.isNaN(n)?"NaN":n>0?"Infinity":"-Infinity"}function _(n){if(typeof n=="number")return n;if(n==="NaN")return NaN;if(n==="Infinity")return 1/0;if(n==="-Infinity")return  -1/0;throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_MALFORMED,message:`Snapshot holds an unrecognised number sentinel: ${JSON.stringify(n)}`,expected:'a JSON number, or one of "NaN", "Infinity", "-Infinity"',found:JSON.stringify(n)})}var D={SNAPSHOT_VERSION_MISMATCH:"SNAPSHOT_VERSION_MISMATCH",SNAPSHOT_MALFORMED:"SNAPSHOT_MALFORMED",SNAPSHOT_UNSUPPORTED_VALUE:"SNAPSHOT_UNSUPPORTED_VALUE"};function Rt(n){return {coef:n.coef.toString(),scale:n.scale}}function Pt(n){return {coef:BigInt(n.coef),scale:n.scale}}function Zt(n){return {n:n.n.toString(),d:n.d.toString()}}function en(n){return {n:BigInt(n.n),d:BigInt(n.d)}}function Lt(n){return chunkPS272DZJ_cjs.g[n]??String(n)}function Ne(n,e){throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_UNSUPPORTED_VALUE,message:`A ${Lt(n)} value (${e}) cannot be included in a snapshot yet.`,expected:"a concrete number, string, boolean, unit, range, matrix, bigint, or money value",found:`${Lt(n)} value`,suggestion:"Symbolic (algebra) values are deferred to a follow-up. Evaluate the document without the symbolic line, or re-derive it after restoring.",context:{valueType:n,location:e}})}function we(n,e){switch(n.type){case 0:{let t={t:0,v:F(n.value)};return n.exact!==void 0&&(t.exact=Rt(n.exact)),n.rational!==void 0&&(t.rational=Zt(n.rational)),t}case 1:{let t=n.value;return typeof t=="bigint"?{t:1,v:t.toString(),big:true,base:n.unit}:{t:1,v:F(t),base:n.unit}}case 2:return {t:2,v:n.value.toString()};case 3:return {t:3,v:n.value};case 4:return {t:4,v:F(n.value)};case 5:return {t:5,v:F(n.value)};case 6:{let t={t:6,v:F(n.value),unit:n.unit??""};return n.exact!==void 0&&(t.exact=Rt(n.exact)),t}case 7:{let t=n.value;t.hasSymbolic&&Ne(9,`${e} (symbolic matrix cell)`);let r=t.data.map(i=>tn(i,e));return {t:7,rows:t.rows,cols:t.cols,data:r}}case 8:{let t=n.value;return {t:8,min:F(t.min),max:F(t.max)}}case 10:return {t:10,v:n.value};case 13:return {t:13,code:n.value,message:n.unit??""};default:return Ne(n.type,e)}}function tn(n,e){return typeof n=="boolean"?n:typeof n=="number"?F(n):Ne(9,`${e} (symbolic matrix cell)`)}function Ae(n){switch(n.t){case 0:{let e=new chunkPS272DZJ_cjs.m(0,_(n.v));return n.exact!==void 0&&(e.exact=Pt(n.exact)),n.rational!==void 0&&(e.rational=en(n.rational)),e}case 1:{let e=n.big?BigInt(n.v):_(n.v);return new chunkPS272DZJ_cjs.m(1,e,n.base)}case 2:return new chunkPS272DZJ_cjs.m(2,BigInt(n.v));case 3:return new chunkPS272DZJ_cjs.m(3,n.v);case 4:return new chunkPS272DZJ_cjs.m(4,_(n.v));case 5:return new chunkPS272DZJ_cjs.m(5,_(n.v));case 6:{let e=new chunkPS272DZJ_cjs.m(6,_(n.v),n.unit);return n.exact!==void 0&&(e.exact=Pt(n.exact)),e}case 7:{let e=n.data.map(r=>typeof r=="boolean"?r:_(r)),t={rows:n.rows,cols:n.cols,data:e,hasSymbolic:false};return new chunkPS272DZJ_cjs.m(7,t)}case 8:return new chunkPS272DZJ_cjs.m(8,{min:_(n.min),max:_(n.max)});case 10:return new chunkPS272DZJ_cjs.m(10,n.v);case 13:return new chunkPS272DZJ_cjs.m(13,n.code,n.message);default:throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_MALFORMED,message:`Snapshot holds a value with an unknown type tag: ${JSON.stringify(n.t)}`,expected:"a known SerializedValue type tag",found:JSON.stringify(n.t)})}}function re(n){let e={opcodes:Array.from(n.opcodes),numbers:Array.from(n.numbers,F),strings:n.strings.slice(),hasAsync:n.hasAsync};return n.constants&&(e.constants=Array.from(n.constants.entries())),n.userFunctionBodies&&(e.userFunctionBodies=n.userFunctionBodies.map(Re)),n.anonymousBodies&&(e.anonymousBodies=n.anonymousBodies.map(t=>({params:t.params.slice(),program:re(t.program)}))),e}function ie(n){let e={opcodes:Uint8Array.from(n.opcodes),numbers:Float64Array.from(n.numbers,_),strings:n.strings.slice(),hasAsync:n.hasAsync};return n.constants&&(e.constants=new Map(n.constants)),n.userFunctionBodies&&(e.userFunctionBodies=n.userFunctionBodies.map(Pe)),n.anonymousBodies&&(e.anonymousBodies=n.anonymousBodies.map(t=>({params:t.params.slice(),program:ie(t.program)}))),e}function Re(n){return {name:n.name,params:n.params.slice(),program:re(n.program)}}function Pe(n){return {name:n.name,params:n.params.slice(),program:ie(n.program)}}function Ot(n){if(typeof n!="object"||n===null)throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_VERSION_MISMATCH,message:"fromJSON was given something that is not a snapshot object.",expected:`an object produced by ExpressionEngine.toJSON() with format "${G}"`,found:n===null?"null":typeof n});let e=n;if(e.format!==G)throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_VERSION_MISMATCH,message:`This object is not a solve-engine snapshot (its "format" is ${JSON.stringify(e.format)}).`,expected:`format "${G}"`,found:JSON.stringify(e.format)});if(e.version!==H)throw chunkSOMGSIO4_cjs.c.validation({code:D.SNAPSHOT_VERSION_MISMATCH,message:`This snapshot was written for format version ${e.version}, but this engine restores version ${H}.`,expected:`snapshot version ${H}`,found:`version ${e.version}`,suggestion:"Regenerate the snapshot with a matching engine version, or re-evaluate the document from source.",context:{snapshotVersion:e.version,readerVersion:H,engineVersion:e.engineVersion}})}var W=class{constructor(e,t,r,i){this.result=e;this.bytecode=t;this.readVariables=r;this.writeVariable=i;}},he=class n{constructor(){this.byLine=new Map;this.count=0;}static exprKey(e){return e??""}static displayKey(e,t){return t===""?`${e}`:`${e}:${t}`}get(e,t){return this.byLine.get(e)?.get(n.exprKey(t))}getEntryForLine(e){let t=this.byLine.get(e);if(t)for(let r of t.values())return r}set(e,t,r){let i=this.byLine.get(e);i||(i=new Map,this.byLine.set(e,i));let s=n.exprKey(r);i.size>0&&!i.has(s)&&(this.count-=i.size,i.clear()),i.has(s)||this.count++,i.set(s,t);}has(e,t){return this.byLine.get(e)?.has(n.exprKey(t))??false}remove(e,t){let r=this.byLine.get(e);r&&r.delete(n.exprKey(t))&&(this.count--,r.size===0&&this.byLine.delete(e));}removeAllForLine(e){let t=this.byLine.get(e);t&&(this.count-=t.size,this.byLine.delete(e));}clearLine(e){this.removeAllForLine(e);}get size(){return this.count}clear(){this.byLine.clear(),this.count=0;}forEach(e){for(let[t,r]of this.byLine)for(let[i,s]of r)e(n.displayKey(t,i),s);}snapshotEntries(){let e=[];for(let[t,r]of this.byLine)for(let[i,s]of r)e.push({line:t,expression:i,entry:s});return e}keys(){let e=[];for(let[t,r]of this.byLine)for(let i of r.keys())e.push(n.displayKey(t,i));return e}};function Le(n){let e=new Date(n),t=String(e.getMonth()+1).padStart(2,"0"),r=String(e.getDate()).padStart(2,"0");return `${e.getFullYear()}-${t}-${r}`}function nn(n){if(n instanceof Date)return Le(n.getTime());if(typeof n=="number")return Number.isFinite(n)?Le(n):null;let e=/^(\d{4})-(\d{2})-(\d{2})/.exec(n.trim());return e?`${e[1]}-${e[2]}-${e[3]}`:null}function It(n){if(n===void 0)return;if(typeof n=="function")return t=>n(new Date(t));let e=new Set;for(let t of n){let r=nn(t);r!==null&&e.add(r);}return t=>e.has(Le(t))}var U=class{static enable(){this.enabled=true;}static disable(){this.enabled=false;}static isEnabled(){return this.enabled}static track(e,t,r){if(!this.enabled)return {result:t(),alloc:null};let i=typeof process<"u"&&process.memoryUsage?process.memoryUsage():null,s=typeof process<"u"&&process.hrtime?process.hrtime():performance.now(),o=t(),a=typeof process<"u"&&process.hrtime?process.hrtime(s):void 0,l=typeof process<"u"&&process.memoryUsage?process.memoryUsage():null,c=a?a[0]*1e9+a[1]:(performance.now()-s)*1e6,u=i&&l?l.heapUsed-i.heapUsed:0,p={stage:e,allocCount:0,allocBytes:u,objectCounts:{},wallTimeNs:c,...r};return {result:o,alloc:p}}static generateReport(e,t){let r=[];r.push(t?`## ${t}`:"## Pipeline Allocation Report"),r.push(""),r.push(`**Runs:** ${e.length} | **Generated:** ${new Date().toISOString()}`),r.push("");let i=this.aggregate(e);if(i.length===0)return r.push("_No telemetry data._"),r.join(`
+`);r.push("### Per-Stage Breakdown"),r.push(""),r.push("| Stage | Count | Mean Wall (\xB5s) | Mean Alloc (bytes) | Min (\xB5s) | Max (\xB5s) | p50 (\xB5s) | p95 (\xB5s) | p99 (\xB5s) |"),r.push("|-------|:-----:|:--------------:|:------------------:|:--------:|:--------:|:--------:|:--------:|:--------:|");for(let l of i)r.push(`| ${l.stage} | ${l.count} | ${(l.meanWallTimeNs/1e3).toFixed(2)} | ${l.meanAllocBytes.toFixed(0)} | ${(l.minWallTimeNs/1e3).toFixed(2)} | ${(l.maxWallTimeNs/1e3).toFixed(2)} | ${(l.p50WallTimeNs/1e3).toFixed(2)} | ${(l.p95WallTimeNs/1e3).toFixed(2)} | ${(l.p99WallTimeNs/1e3).toFixed(2)} |`);let s=e.reduce((l,c)=>l+c.totalAllocBytes,0),o=e.reduce((l,c)=>l+c.totalWallTimeNs,0),a=e.filter(l=>l.fastPath).length;return r.push(""),r.push("### Totals"),r.push(""),r.push(`- **Total wall time:** ${(o/1e6).toFixed(2)} ms (${e.length} runs)`),r.push(`- **Total heap allocated:** ${s.toLocaleString()} bytes`),r.push(`- **Fast-path runs:** ${a}/${e.length} (${(a/e.length*100).toFixed(0)}%)`),r.push(`- **Mean per-run:** ${(o/e.length/1e3).toFixed(2)} \xB5s, ${(s/e.length).toFixed(0)} bytes`),r.join(`
+`)}static aggregate(e){let t=new Map;for(let i of e)for(let s of i.stages)t.has(s.stage)||t.set(s.stage,[]),t.get(s.stage).push(s);let r=[];for(let[i,s]of t){let o=s.map(c=>c.wallTimeNs).sort((c,u)=>c-u),a=s.map(c=>c.allocBytes),l=s.length;r.push({stage:i,count:l,meanAllocBytes:a.reduce((c,u)=>c+u,0)/l,meanWallTimeNs:o.reduce((c,u)=>c+u,0)/l,minWallTimeNs:o[0],maxWallTimeNs:o[o.length-1],p50WallTimeNs:Oe(o,50),p95WallTimeNs:Oe(o,95),p99WallTimeNs:Oe(o,99)});}return r.sort((i,s)=>i.stage.localeCompare(s.stage)),r}static createTelemetry(e,t,r=false){let i=t.reduce((o,a)=>o+a.allocBytes,0),s=t.reduce((o,a)=>o+a.wallTimeNs,0);return {expression:e,stages:t,totalAllocBytes:i,totalWallTimeNs:s,fastPath:r}}};U.enabled=false;function Oe(n,e){if(n.length===0)return 0;if(n.length===1)return n[0];let t=e/100*(n.length-1),r=Math.floor(t),i=Math.ceil(t);if(r===i)return n[r];let s=t-r;return n[r]*(1-s)+n[i]*s}function Ie(n,e){if(n.length>e.maxExpressionLength){let t=chunkSOMGSIO4_cjs.c.validation("EXPRESSION_TOO_LONG",`Expression exceeds max length of ${e.maxExpressionLength} characters (got ${n.length})`,{expressionLength:n.length,maxLength:e.maxExpressionLength});return {passed:false,error:{value:chunkPS272DZJ_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:t.message,engineError:t}}}return {passed:true}}function Ve(n,e){let t=0,r=0,i=0;for(let o of n)o.type==="FUNC"&&t++,(o.value==="("||o.type==="LPAREN")&&(r++,i=Math.max(i,r)),(o.value===")"||o.type==="RPAREN")&&r--;let s=n.length+t*5+i*10;if(s>e.maxComplexity){let o=chunkSOMGSIO4_cjs.c.validation("EXPRESSION_TOO_COMPLEX",`Expression complexity score ${s} exceeds maximum of ${e.maxComplexity}`,{complexity:s,maxComplexity:e.maxComplexity});return {passed:false,complexityScore:s,errorMessage:o.message,engineError:o}}return {passed:true,complexityScore:s}}function se(n){return n.type==="IDENT"||n.type==="UNIT"}function rn(n){return n.type==="NUMBER"||n.type==="TO"||n.type==="IN"||n.type==="RPAREN"}function Vt(n,e){let t=0;for(let r=e;r<n.length;r++)if(n[r].type==="LPAREN")t++;else if(n[r].type==="RPAREN"&&(t--,t===0))return r;return null}function sn(n){let e=new Set;for(let t=0;t<n.length;t++){if(!se(n[t])||t>0&&n[t-1].type==="COLON"||n[t+1]?.type!=="LPAREN")continue;let r=Vt(n,t+1);if(r!==null&&n[r+1]?.type==="EQUALS")for(let i=t+2;i<r;i++)se(n[i])&&e.add(n[i].value);}return e}function fe(n){let e=[],t=[],r=sn(n);for(let i=0;i<n.length;i++){let s=n[i];if(s.type==="GLOBAL"){if(i+2<n.length&&n[i+1].type==="COLON"&&se(n[i+2])){let o=chunkJAK3RAFA_cjs.K(n[i+2].value);e.push(o),i+3<n.length&&n[i+3].type==="EQUALS"&&t.push(o);}continue}if(s.type==="COLON"){if(i>0&&n[i-1].type==="GLOBAL")continue;if(i+1<n.length&&se(n[i+1])){let o=n[i+1].value;e.push(o),i+2<n.length&&n[i+2].type==="EQUALS"&&t.push(o);}}if(se(s)){if(i>0&&n[i-1].type==="COLON"||s.type==="UNIT"&&i>0&&rn(n[i-1])||r.has(s.value))continue;if(n[i+1]?.type==="LPAREN"){let a=Vt(n,i+1);if(a!==null&&n[a+1]?.type==="EQUALS"){e.push(s.value),t.push(s.value);continue}}e.push(s.value);let o=n[i+1]?.type;(o==="EQUALS"||o==="PLUS_EQUALS"||o==="MINUS_EQUALS")&&t.push(s.value);}}return {reads:e,writes:t}}function $n(n){return chunk32GC2FHC_cjs.c.classifyLine(n).skip}function Wn(n,e){return chunk32GC2FHC_cjs.c.findInlineSolves(n).map(r=>({start:r.start,end:r.end,expression:r.expression,lineNumber:e,columnNumber:r.columnNumber}))}function Bt(n){let e=n[n.length-1],t=e.length>1&&e.endsWith("s")?e.slice(0,-1):e;return [...n.slice(0,-1),t].join(" ")}var me=class{constructor(){this.byKey=new Map;this.longestName=0;}get isEmpty(){return this.byKey.size===0}get maxWordCount(){return this.longestName}define(e,t,r){let i=Bt(e);this.byKey.set(i,{displayName:e.join(" "),ratioText:t,baseUnit:r}),e.length>this.longestName&&(this.longestName=e.length);}match(e){let t=Math.min(e.length,this.longestName);for(let r=t;r>=1;r--){let i=this.byKey.get(Bt(e.slice(0,r)));if(i!==void 0)return {definition:i,wordCount:r}}return null}clear(){this.byKey.clear(),this.longestName=0;}};function Mt(n,e=82){return {name:"uom:user-unit",priority:e,match(t,r){if(n.isEmpty)return null;let i=t[r];if(i.type!=="NUMBER"&&i.type!=="RPAREN")return null;let s=[],o=n.maxWordCount;for(let g=r+1;g<t.length&&s.length<o&&t[g].type==="IDENT";g++)s.push(t[g].value);if(s.length===0)return null;let a=n.match(s);if(a===null||t[r+1+a.wordCount]?.type==="EQUALS")return null;let{ratioText:c,baseUnit:u}=a.definition,p=new chunk2LFLR3VZ_cjs.a("STAR",chunk5IJD5L3O_cjs.c("STAR"),"*","*",i.offset,0,i.line,i.col),f=new chunk2LFLR3VZ_cjs.a("NUMBER",chunk5IJD5L3O_cjs.c("NUMBER"),c,c,i.offset,0,i.line,i.col),m=new chunk2LFLR3VZ_cjs.a("UNIT",chunk5IJD5L3O_cjs.c("UNIT"),u,u,i.offset,0,i.line,i.col);return {consumed:1+a.wordCount,replacement:[i,p,f,m],ruleName:"uom:user-unit"}}}}var on=30,an=40,ln=50,cn=24;function un(n){switch(n){case chunk5IJD5L3O_cjs.a.PLUS:case chunk5IJD5L3O_cjs.a.MINUS:return on;case chunk5IJD5L3O_cjs.a.STAR:case chunk5IJD5L3O_cjs.a.SLASH:case chunk5IJD5L3O_cjs.a.MOD:case chunk5IJD5L3O_cjs.a.OF:return an;case chunk5IJD5L3O_cjs.a.CARET:return ln;case chunk5IJD5L3O_cjs.a.PCT_ON:case chunk5IJD5L3O_cjs.a.PCT_OFF:return cn;default:return 0}}function pn(n){switch(n){case chunk5IJD5L3O_cjs.a.PLUS:return "plus";case chunk5IJD5L3O_cjs.a.MINUS:return "minus";case chunk5IJD5L3O_cjs.a.STAR:return "times";case chunk5IJD5L3O_cjs.a.SLASH:return "divided by";case chunk5IJD5L3O_cjs.a.MOD:return "mod";case chunk5IJD5L3O_cjs.a.CARET:return "to the power of";case chunk5IJD5L3O_cjs.a.OF:return "of";case chunk5IJD5L3O_cjs.a.PCT_ON:return "plus";case chunk5IJD5L3O_cjs.a.PCT_OFF:return "less";default:return n.toLowerCase()}}function Dt(n){return n.sourceEnd??n.offset+n.value.length}var gn=new Set([chunk5IJD5L3O_cjs.a.NUMBER,chunk5IJD5L3O_cjs.a.BIGINT,chunk5IJD5L3O_cjs.a.IDENT,chunk5IJD5L3O_cjs.a.UNIT,chunk5IJD5L3O_cjs.a.PERCENT,chunk5IJD5L3O_cjs.a.PI,chunk5IJD5L3O_cjs.a.E,chunk5IJD5L3O_cjs.a.TRUE,chunk5IJD5L3O_cjs.a.FALSE,chunk5IJD5L3O_cjs.a.DOLLAR,chunk5IJD5L3O_cjs.a.POUND,chunk5IJD5L3O_cjs.a.EURO,chunk5IJD5L3O_cjs.a.YEN,chunk5IJD5L3O_cjs.a.RUBLE,chunk5IJD5L3O_cjs.a.WON,chunk5IJD5L3O_cjs.a.CURRENCY_SYMBOL]);function dn(n){return !gn.has(n)}var Be=class{constructor(e){this.tokens=e;this.pos=0;}peek(){return this.tokens[this.pos]}next(){return this.tokens[this.pos++]}parseAll(){let e=this.parseExpression(0);if(this.pos!==this.tokens.length)throw new Error("explain: unconsumed tokens");return e}parseExpression(e){let t=this.parseOperand();for(;;){let r=this.peek();if(!r)break;let i=un(r.type);if(i===0||i<=e)break;this.next();let s=r.type===chunk5IJD5L3O_cjs.a.CARET?i-1:i,o=this.parseExpression(s);t={kind:"binary",op:r.type,left:t,right:o,start:t.start,end:o.end};}return t}parseOperand(){let e=this.peek();if(!e)throw new Error("explain: expected an operand");if(e.type===chunk5IJD5L3O_cjs.a.LPAREN)return this.parseGroup();let t=e.offset,r=false;for(;this.peek()&&(this.peek().type===chunk5IJD5L3O_cjs.a.PLUS||this.peek().type===chunk5IJD5L3O_cjs.a.MINUS);)this.next(),r=true;if(r&&this.peek()&&this.peek().type===chunk5IJD5L3O_cjs.a.LPAREN){let s=this.parseGroup();return {kind:"wrap",child:s,start:t,end:s.end}}let i=-1;for(;this.peek()&&!dn(this.peek().type);)i=Dt(this.next());if(i===-1)throw new Error("explain: expected an operand");return {kind:"leaf",start:t,end:i}}parseGroup(){let e=this.next(),t=this.parseExpression(0),r=this.peek();if(!r||r.type!==chunk5IJD5L3O_cjs.a.RPAREN)throw new Error("explain: unbalanced parentheses");return this.next(),{kind:"wrap",child:t,start:e.offset,end:Dt(r)}}},Me=class{constructor(e,t,r){this.source=e;this.evaluate=t;this.steps=[];this.cache=new Map;this.resultPrefix=chunkMSYX32PF_cjs.a(r).display.resultPrefix;}build(e){return this.emit(e),{steps:this.steps,result:this.valueOf(e)}}emit(e){if(e.kind!=="leaf"){if(e.kind==="wrap"){this.emit(e.child);return}this.emit(e.left),this.emit(e.right),this.steps.push({description:this.describe(e),value:this.valueOf(e)});}}describe(e){let t=pn(e.op);return e.op===chunk5IJD5L3O_cjs.a.PCT_ON||e.op===chunk5IJD5L3O_cjs.a.PCT_OFF?`${this.operand(e.right)} ${t} ${this.operand(e.left)}`:`${this.operand(e.left)} ${t} ${this.operand(e.right)}`}operand(e){return e.kind==="leaf"?this.source.slice(e.start,e.end).trim():this.render(this.valueOf(e))}valueOf(e){let t=this.cache.get(e);if(t)return t;let r=this.evaluate(this.source.slice(e.start,e.end));return this.cache.set(e,r),r}render(e){let t=chunkHLBYHXQD_cjs.c(e,chunkHLBYHXQD_cjs.a);return t.startsWith(this.resultPrefix)?t.slice(this.resultPrefix.length):t}};function De(n){let{expression:e,tokens:t,evaluate:r,locale:i}=n,s=()=>({expression:e,steps:[],result:r(e)}),o;try{o=new Be(t).parseAll();}catch{return s()}try{let{steps:a,result:l}=new Me(e,r,i).build(o);return {expression:e,steps:a,result:l}}catch{return s()}}var oe=class oe{constructor(e={}){this.dag=new chunkSYYE3QAX_cjs.a;this.lineCache=new he;this.accumulatorNames=new Set;this.scopeManager=new chunkSYYE3QAX_cjs.b;this.resolverRegistry=new chunkZCNBT44X_cjs.a;this.packageContributions=new Map;this.registeredPackages=new Map;this.documentModel=null;this.goalSeekDepth=0;this.batchScanResults=null;this.batchParsedLines=null;this.packageCompletionItems=new Map;this.keystrokeSignal=null;this.userUnits=new me;this.bytecodeCache=new Map;this.pluginFunctionIndexByName=new Map;this.builderPool=[new chunk4QVBSG6B_cjs.d(this.pluginFunctionIndexByName),new chunk4QVBSG6B_cjs.d(this.pluginFunctionIndexByName),new chunk4QVBSG6B_cjs.d(this.pluginFunctionIndexByName),new chunk4QVBSG6B_cjs.d(this.pluginFunctionIndexByName)];this.builderPoolIndex=0;this.lastTelemetry=null;let{locale:t="en",diagnostics:r=false,config:i,packages:s}=e;this.localeCode=t,this.config=chunkEVI6OHQH_cjs.c(chunkEVI6OHQH_cjs.b,i??{}),this.lexer=new chunk32GC2FHC_cjs.b(t,chunk32GC2FHC_cjs.d(t)),this.registry=new chunkFDE5HWDI_cjs.b,this.context=chunkJAK3RAFA_cjs.x(),r?(this.diagnosticPipeline=new chunkAXMQG5TS_cjs.a,this.timelineCollector=new chunkAXMQG5TS_cjs.b,this.diagnosticPipeline.register(this.timelineCollector)):this.diagnosticPipeline=new chunkAXMQG5TS_cjs.a,this.normalizer=new chunkVAGS5JS7_cjs.c;for(let[a,l]of Object.entries(chunkVAGS5JS7_cjs.g))this.normalizer.addPhrase(a,l);this.normalizer.register(chunkVAGS5JS7_cjs.d(50,a=>this.normalizer.canStartPhrase(a))),this.normalizer.register(Mt(this.userUnits));let o=s??[];for(let a of o)try{this.registerPackage(a);}catch(l){let c=chunkSOMGSIO4_cjs.d(l);console.error(`[ExpressionEngine] Failed to register package "${a.name}" \u2014 skipping it and continuing construction with the remaining packages: ${c.format()}`);}this.parser=new chunkFDE5HWDI_cjs.a(this.registry,this.config.validation.maxNestingDepth,t,this.pluginFunctionIndexByName),this.vm=chunkSYYE3QAX_cjs.c(this.context.opRegistry,this.config.vm.maxStackDepth,this.config.vm.maxInstructions,void 0,this.config.vm.maxCollectionSize,this.config.vm.maxAllocatedElements,this.config.vm.maxFunctionCalls,this.config.date.maxOffsetYears,this.config.date.minOffsetYears,this.context,It(this.config.date.holidays)),this.queryClient=chunkZLRJ7TDP_cjs.c(),this.batcher=new ve(this.dag,this.lineCache,this.vm);}setDocumentModel(e){this.documentModel=e;}makeLineContext(e){let t=this.documentModel,r=t?null:this.batchScanResults,i=t?null:this.batchParsedLines;return {lineIndex:e,getLineResult:t?s=>t.getLineAt(s)?.result??void 0:i?s=>i[s-1]?.result??void 0:void 0,isLineBoundary:t?s=>{let o=t.getLineAt(s);return o?o.isEmpty||/^\s*#/.test(o.text):true}:r?s=>{let o=r[s-1];return o?o.classification.skip||/^\s*#/.test(o.text):true}:void 0,getLineReads:t?s=>{let o=t.getLineAt(s);if(!(!o||o.bytecodes.length===0))return o.reads}:void 0,evaluateLineWithBinding:t?(s,o,a,l)=>this.evaluateLineWithBinding(s,o,a,l):void 0,goalSeekMaxIterations:this.config.vm.maxGoalSeekIterations,getLineText:t?s=>t.getLineAt(s)?.text:r?s=>r[s-1]?.text:void 0}}evaluateLineWithBinding(e,t,r,i){let s=this.documentModel;if(!s)return chunkPS272DZJ_cjs.N("GOAL_SEEK_NO_DOCUMENT","Goal seek needs a document to solve against, which the single-expression entry point does not have.");if(this.goalSeekDepth>=oe.GOAL_SEEK_MAX_NESTING_DEPTH)return chunkPS272DZJ_cjs.N("GOAL_SEEK_NESTED","A goal-seek line cannot target another goal-seek line, since each already re-runs its target many times.");let o=s.getLineAt(e);if(!o||o.bytecodes.length===0)return chunkPS272DZJ_cjs.N("GOAL_SEEK_LINE_NOT_READY",`Line ${e} has no evaluated expression to solve (forward reference, out of range, or not an expression).`);if(o.isVariableDef)return chunkPS272DZJ_cjs.N("GOAL_SEEK_TARGET_IS_DEFINITION",`Line ${e} defines a variable, so re-running it would overwrite that variable. Target the line that uses ${t}, not the one that sets a value.`);let a=o.bytecodes[0];this.goalSeekDepth++;try{let l=new Map([[t,r]]),c=this.vm.getStack().length;this.vm.pushCallFrame(l);try{let u=chunkSYYE3QAX_cjs.d(a,this.vm,void 0,void 0,this.makeLineContext(e),i);return u.type==="pending"?chunkPS272DZJ_cjs.N("GOAL_SEEK_ASYNC_UNSUPPORTED",`Line ${e} depends on an async value (weather, stocks, currency, ...), which goal seek cannot re-run.`):u.type==="error"?chunkPS272DZJ_cjs.N(u.error.code??"GOAL_SEEK_TARGET_ERROR",u.error.message):u.value}finally{for(this.vm.popCallFrame();this.vm.getStack().length>c;)this.vm.pop();}}catch(l){return chunkPS272DZJ_cjs.N("GOAL_SEEK_TARGET_ERROR",chunkSOMGSIO4_cjs.d(l).message)}finally{this.goalSeekDepth--;}}cacheBytecode(e,t){let r=this.config.performance.defaultCacheSize;if(this.bytecodeCache.size>=r){let i=this.bytecodeCache.keys().next().value;i!==void 0&&this.bytecodeCache.delete(i);}this.bytecodeCache.set(e,t);}getEventStream(){return this.batcher.getEventStream()}getBatcher(){return this.batcher}registerPackage(e){At(e),this.packageContributions.has(e.name)&&(console.warn(`[ExpressionEngine] Package "${e.name}" is already registered. Unregistering the previous registration before re-registering.`),this.unregisterPackage(e.name));let t=kt(e,[...this.registeredPackages.values()]);for(let i of t.conflicts)(i.severity==="error"?console.error:console.warn)(`[ExpressionEngine] Package compatibility ${i.severity} (${i.kind}): ${i.detail}`);let r={pluginFunctionIndices:[],pluginFunctionNames:[],resolverNamespaces:[],tokenCategories:[],lexerVocabulary:e.lexerVocabulary,asConverterNames:[],normalizerRuleNames:[]};if(e.lexerVocabulary&&this.lexer.registerVocabulary(e.lexerVocabulary),e.prefixParselets)for(let[i,s]of Object.entries(e.prefixParselets))this.registry.registerPrefix(i,s);if(e.infixParselets)for(let[i,s]of Object.entries(e.infixParselets))this.registry.registerInfix(i,s);if(e.pluginFunctions)for(let[i,s]of Object.entries(e.pluginFunctions)){let o=chunkJAK3RAFA_cjs.F(`${e.name}:${i}`);this.context.pluginFunctions[o]=s,this.context.pluginFunctionOwners[o]=e.name,this.pluginFunctionIndexByName.set(i,o),r.pluginFunctionIndices.push(o),r.pluginFunctionNames.push(i);}if(e.asyncResolvers)for(let i of e.asyncResolvers)this.resolverRegistry.register(i),r.resolverNamespaces.push(i.namespace);if(e.phrases)for(let[i,s]of Object.entries(e.phrases))this.normalizer.addPhrase(i,s);if(e.normalizerRules)for(let i of e.normalizerRules)this.normalizer.register(i),r.normalizerRuleNames.push(i.name);if(e.tokenCategories)for(let[i,s]of Object.entries(e.tokenCategories))chunkY7O4D3BJ_cjs.b(i,s),r.tokenCategories.push(i);if(e.completionItems&&this.packageCompletionItems.set(e.name,e.completionItems),e.asConverters)for(let[i,s]of Object.entries(e.asConverters))chunkJAK3RAFA_cjs.H(i,s),r.asConverterNames.push(i);this.packageContributions.set(e.name,r),this.registeredPackages.set(e.name,e);}unregisterPackage(e){let t=this.packageContributions.get(e);if(!t)return  false;for(let r of t.pluginFunctionIndices)delete this.context.pluginFunctions[r],delete this.context.pluginFunctionOwners[r];for(let r of t.pluginFunctionNames)this.pluginFunctionIndexByName.delete(r);for(let r of t.resolverNamespaces)this.resolverRegistry.unregister(r);for(let r of t.tokenCategories)chunkY7O4D3BJ_cjs.c(r);t.lexerVocabulary&&this.lexer.unregisterVocabulary(t.lexerVocabulary);for(let r of t.asConverterNames)chunkJAK3RAFA_cjs.I(r);for(let r of t.normalizerRuleNames)this.normalizer.unregister(r);return this.packageCompletionItems.delete(e),this.packageContributions.delete(e),this.registeredPackages.delete(e),this.bytecodeCache.clear(),true}getConfig(){return {...this.config}}getDiagnosticPipeline(){return this.diagnosticPipeline}storeLineResult(e,t,r,i,s,o){this.lineCache.set(e,new W(t,r,i,s.length>0?s[0]:null),o);}executeAndStore(e,t,r,i,s,o,a,l){let c=this.vm.getStack().length,u=new AbortController,p=()=>u.abort();this.keystrokeSignal?.addEventListener("abort",p,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("executeAndStore"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("executeAndStore"),this.vm.activeSignal=u.signal,this.vm.abortCurrent=()=>{chunkTTFO4YDP_cjs.a.signalUnlinked("executeAndStore"),this.keystrokeSignal?.removeEventListener("abort",p),u.abort();},chunkZLRJ7TDP_cjs.a(this.queryClient);let f=chunkSYYE3QAX_cjs.d(e,this.vm,a,l,this.makeLineContext(t));for(;this.vm.getStack().length>c;)this.vm.pop();if(f.type==="pending"){this.resolveAsync(f),this.dag.registerLineDataSourceDependency(t,f.packageId||o,[f.queryKey]);let m=chunkPS272DZJ_cjs.M(f.queryKey);return this.storeLineResult(t,m,e,i,s,r),m}if(f.type==="error")throw this.keystrokeSignal?.removeEventListener("abort",p),f.error;return this.keystrokeSignal?.removeEventListener("abort",p),this.dag.registerLine(t,i,s),this.storeLineResult(t,f.value,e,i,s,r),f.value}executeRaw(e,t=-1){let r=this.vm.getStack().length,i=new AbortController,s=()=>i.abort();this.keystrokeSignal?.addEventListener("abort",s,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("executeRaw"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("executeRaw"),this.vm.activeSignal=i.signal,this.vm.abortCurrent=()=>{chunkTTFO4YDP_cjs.a.signalUnlinked("executeRaw"),this.keystrokeSignal?.removeEventListener("abort",s),i.abort();},chunkZLRJ7TDP_cjs.a(this.queryClient);let o=chunkSYYE3QAX_cjs.d(e,this.vm,void 0,void 0,this.makeLineContext(t));for(;this.vm.getStack().length>r;)this.vm.pop();return o.type!=="pending"&&this.keystrokeSignal?.removeEventListener("abort",s),o}async resolveAsync(e){let{queryKey:t,resolver:r,packageId:i,signal:s}=e,o=i||"_engine";try{if(await r,s.aborted){chunkTTFO4YDP_cjs.a.staleDataDiscarded(t,"signal aborted after resolve");return}this.batcher.add({queryKey:t,packageId:o,signal:s,isError:!1});}catch(a){if(s.aborted){chunkTTFO4YDP_cjs.a.staleDataDiscarded(t,"signal aborted after error");return}let l=a instanceof Error?a:new Error(String(a));this.batcher.add({queryKey:t,packageId:o,signal:s,isError:true,error:l});}}parseDocument(e,t={inputType:"markdown"}){let r=this.config.performance.maxDocumentLines;if(chunkUURM7P3P_cjs.b(e,r)>r)throw chunkSOMGSIO4_cjs.c.execution("DOCUMENT_TOO_LARGE",`This document has more than ${r.toLocaleString("en-US")} lines, which is the most the engine will process in one pass`,{maxLines:r});this.userUnits.isEmpty||this.bytecodeCache.clear(),this.userUnits.clear(),this.resetAccumulators();let i=this.lexer.scanDocument(e),s=this.processScanResults(i),o={lines:s,totalLines:s.length,errors:[]};for(let l of s){l.error&&o.errors.push(`Line ${l.lineNumber}: ${l.error}`);for(let c of l.inlineSolves)c.error&&o.errors.push(`Line ${l.lineNumber}: ${c.error}`);}if(t.includeDiagnostics??false){let l=this.diagnosticPipeline.collectReports();l.length>0&&(o.diagnostics=l[0].toJSON());}return o}evaluateLines(e){this.userUnits.isEmpty||this.bytecodeCache.clear(),this.userUnits.clear(),this.resetAccumulators();let t=e.join(`
+`),r=this.lexer.scanDocument(t);return this.processScanResults(r)}processScanResults(e){let t=[],r=this.batchScanResults,i=this.batchParsedLines;this.batchScanResults=e,this.batchParsedLines=t;try{for(let s of e){let o=s.text,a=s.lineNumber,l=s.startOffset,c=s.endOffset,u=s.classification.skip,p=s.inlineSolves.map(g=>({start:g.start,end:g.end,expression:g.expression,lineNumber:a,columnNumber:g.columnNumber})),f=p.length>0,m={lineNumber:a,text:o,startPosition:l,endPosition:c,isEmpty:u,hasInlineSolves:f,inlineSolves:p,expression:null,result:null,error:null};if(!u){let g=o.trim().startsWith(":");if(f&&!g)for(let R of p)try{R.result=this.evaluateLine(a,R.expression);}catch(O){let I=O instanceof Error?O.message:String(O);R.error=I;}else {let R=s.classification.contentOffset,I=(R===void 0?o:o.slice(R-l)).trim();if(I)try{let E=this.evaluateLineWithPreTokenized(a,I,s.tokens);m.expression=I,m.result=E[0];}catch(E){let X=E instanceof Error?E.message:String(E);m.error=X;}}}t.push(m);}}finally{this.batchScanResults=r,this.batchParsedLines=i;}return t}evaluateLineWithPreTokenized(e,t,r){let i=[],s=false;for(let o of r)(o.type==="LPAREN"||o.type==="RPAREN")&&(s=true),i.push(o);return [this.evaluateWithTokens(e,t,i,s)]}parseExpression(e,t,r,i=true){this.parser.setBuilder(e),this.parser.load(t,this.config.validation.autoBalanceParens?r:false),this.parser.parseExpression(0);let s=this.parser.peek();if(s){if(s.type==="EQUALS"&&!this.parser.peekAt(1))return;for(let o=i?t.length-1:0;o>=1;o--){if(t[o].type!=="COLON"||o+1>=t.length)continue;let a=true;for(let l=0;l<o;l++){let c=t[l].type;if(c!=="NUMBER"&&c!=="COLON"){a=false;break}}if(a){let l=t.slice(0,o+2).map(c=>c.value).join("");throw chunkSOMGSIO4_cjs.c.parsing("INVALID_TIME_LITERAL",`"${l}" is not a valid time`,{tokenType:t[o].type,tokenValue:l})}e.reset();try{this.parseExpression(e,t.slice(o+1),r,!1);return}catch{}}throw chunkSOMGSIO4_cjs.c.parsing("UNEXPECTED_TRAILING_TOKEN",`Unexpected token after expression: "${s.value}"`,{tokenType:s.type,tokenValue:s.value})}}compileAdHoc(e){let t=new chunk4QVBSG6B_cjs.d(this.pluginFunctionIndexByName);return this.parseExpression(t,e),t.build()}executeSymbolicTolerant(e,t=-1){let r=chunkSYYE3QAX_cjs.d(e,this.vm,void 0,void 0,this.makeLineContext(t),true);if(r.type==="error")throw r.error;if(r.type==="pending")throw chunkSOMGSIO4_cjs.c.execution("THEREFORE_ASYNC_UNSUPPORTED",`"=>" doesn't support expressions that call an async operation (weather/stocks/currency).`);return r.value}simplifySymbolically(e,t=-1){return this.executeSymbolicTolerant(this.compileAdHoc(e),t)}parseFactorChain(e){if(e.length===0||e.length%2===0)return null;let t=[];for(let r=0;r<e.length;r++)if(r%2===0){if(e[r].type!=="IDENT"&&e[r].type!=="UNIT")return null;t.push(e[r].value);}else if(e[r].type!=="STAR")return null;return t}solveEquation(e,t=-1){let r=[];for(let a of e.factorNames){let l=this.vm.getVar(a);if(l===void 0)return chunkPS272DZJ_cjs.N("EQUATION_FACTOR_UNDEFINED",`Cannot solve for "${e.variable}": "${a}" is not yet defined.`);if(l.type!==7)return chunkPS272DZJ_cjs.N("EQUATION_FACTOR_NOT_MATRIX",`Cannot solve for "${e.variable}": "${a}" must be a Matrix (got a different value type).`);r.push(l);}let i=r[0].value;for(let a=1;a<r.length;a++){let l=chunkN7N7MPMK_cjs._(i,r[a].value);if(l.type===13)return l;i=l.value;}let s=chunkN7N7MPMK_cjs.da(i);if(s.type===13)return s;let o=this.executeSymbolicTolerant(e.rhsProgram,t);return o.type!==7?chunkPS272DZJ_cjs.N("EQUATION_RHS_NOT_MATRIX",`Cannot solve for "${e.variable}": the right-hand side must be a Matrix.`):chunkN7N7MPMK_cjs._(s.value,o.value)}tryDefineUserUnit(e){if(e.length<5||e[0].type!=="NUMBER"||Number(e[0].value)!==1)return null;let t=1;e[t].type==="STAR"&&t++;let r=[];for(;t<e.length&&e[t].type==="IDENT";)r.push(e[t].value),t++;if(r.length===0||e[t]?.type!=="EQUALS"||(t++,e[t]?.type!=="NUMBER"))return null;let i=e[t];if(t++,e[t]?.type!=="UNIT")return null;let s=e[t];return t++,t!==e.length?null:(this.userUnits.define(r,i.value,s.value),this.bytecodeCache.clear(),chunkPS272DZJ_cjs.t(`${r.join(" ")} defined`))}tryCompoundAssignment(e,t=-1){if(e.length<2)return null;let r=e[0],i=e[1],s=r.type==="IDENT"||r.type==="UNIT",o=i.type==="PLUS_EQUALS"||i.type==="MINUS_EQUALS";if(!s||!o)return null;let a=e.slice(2);if(a.length===0)throw chunkSOMGSIO4_cjs.c.parsing("COMPOUND_ASSIGN_REQUIRES_EXPRESSION",`"${r.value} ${i.value}" needs an expression on the right, e.g. "${r.value} ${i.value} 10".`);let l=r.value;this.accumulatorNames.add(l),this.vm.getVar(l)===void 0&&this.vm.setVar(l,chunkPS272DZJ_cjs.n(0));let c=i.type==="PLUS_EQUALS"?{type:"PLUS",text:"+"}:{type:"MINUS",text:"-"},u=[chunkVAGS5JS7_cjs.b("IDENT",l,[r]),chunkVAGS5JS7_cjs.b(c.type,c.text,[i]),chunkVAGS5JS7_cjs.b("LPAREN","(",[i]),...a,chunkVAGS5JS7_cjs.b("RPAREN",")",[i])],p=chunkSYYE3QAX_cjs.d(this.compileAdHoc(u),this.vm,void 0,void 0,this.makeLineContext(t),false);if(p.type==="error")throw p.error;if(p.type==="pending")throw chunkSOMGSIO4_cjs.c.execution("COMPOUND_ASSIGN_ASYNC_UNSUPPORTED","A running total (+= / -=) cannot use an async operation (weather/stocks/currency) on its right-hand side.");return this.vm.setVar(l,p.value),p.value}resetAccumulators(){for(let e of this.accumulatorNames)this.vm.deleteVar(e);return this.accumulatorNames}trySymbolicGrammar(e,t=-1){if(e.length===0)return null;if(e[e.length-1].type==="THEREFORE"){let c=e.slice(0,-1);if(c.length===0)throw chunkSOMGSIO4_cjs.c.parsing("THEREFORE_REQUIRES_EXPRESSION",'"=>" needs an expression or variable name before it.');if(c.length===1&&(c[0].type==="IDENT"||c[0].type==="UNIT")){let u=c[0].value,p=this.vm.getEquation(u),f=this.vm.getScalarEquation(u);if(p){let m=this.solveEquation(p,t);if(!(m.type===13&&m.value==="EQUATION_FACTOR_NOT_MATRIX")||!f)return m}if(f)return this.solveScalarEquation(f,t)}return this.simplifySymbolically(c,t)}if(chunk7BXPCWKM_cjs.b(e))return this.simplifySymbolically(e,t);if(e[0].type==="COLON"||e[0].type==="GLOBAL"||e[0].type==="GOAL_SEEK")return null;let i=e.findIndex(c=>c.type==="EQUALS");if(i===-1)return null;let s=this.parseFactorChain(e.slice(0,i));if(s===null)return this.tryStoreScalarEquation(e,i);let o=e.slice(i+1);if(s.length===1){let c=this.simplifySymbolically(o,t);return this.vm.setVar(s[0],c),c}let a=s[s.length-1],l=s.slice(0,-1);return this.vm.defineEquation(a,l,this.compileAdHoc(o)),this.vm.defineScalarEquation(a,this.compileAdHoc(e.slice(0,i)),this.compileAdHoc(o)),chunkPS272DZJ_cjs.t(`${a} stored as an equation \u2014 solve with "${a} =>"`)}tryStoreScalarEquation(e,t){if(e[1]?.type==="LPAREN"||t===0||t===e.length-1)return null;let r=e.slice(0,t),i=e.slice(t+1);if(i.some(a=>a.type==="EQUALS"))return null;let s=this.equationUnknowns(r,i);if(s.length!==1)return null;let o=s[0];return this.vm.defineScalarEquation(o,this.compileAdHoc(r),this.compileAdHoc(i)),chunkPS272DZJ_cjs.t(`${o} stored as an equation \u2014 solve with "${o} =>"`)}equationUnknowns(e,t){let r=[];for(let i of [...e,...t])i.type!=="IDENT"&&i.type!=="UNIT"||this.vm.getVar(i.value)===void 0&&(this.vm.hasUserFunction(i.value)||r.includes(i.value)||r.push(i.value));return r}solveScalarEquation(e,t=-1){let r=this.executeSymbolicTolerant(e.lhsProgram,t),i=this.executeSymbolicTolerant(e.rhsProgram,t);return chunkJAK3RAFA_cjs.i(r,i,e.variable)}lexToTokens(e,t){let r=[],i=false;this.lexer.resetExpression(e);for(let s of this.lexer)s.type!=="COMMENT"&&((s.type==="LPAREN"||s.type==="RPAREN")&&(i=true),r.push(s),t?.(s));return {tokens:r,hasParens:i}}prepareExpression(e,t,r,i,s=-1){let o=Ie(e,this.config.validation);if(!o.passed)return {kind:"error",stage:"length",error:o.error.engineError};let a=t.filter(E=>E.type!=="COMMENT");if(a.length===0)return {kind:"empty"};let l=this.normalizer.normalize(a,i),c=Ve(l,this.config.validation);if(!c.passed)return {kind:"error",stage:"complexity",error:c.engineError,normalizedTokens:l};let u,p=null;try{if(u=this.tryDefineUserUnit(l),u===null){let E=this.tryCompoundAssignment(l,s);E!==null&&(u=E,p=fe(l));}u===null&&(u=this.trySymbolicGrammar(l,s));}catch(E){let{reads:X,writes:P}=fe(l);return {kind:"error",stage:"parse",error:chunkSOMGSIO4_cjs.d(E),reads:X,writes:P,normalizedTokens:l}}if(u!==null)return {kind:"symbolic-solve",normalizedTokens:l,value:u,reads:p?.reads,writes:p?.writes};let{reads:f,writes:m}=fe(l),g=this.bytecodeCache.get(e);if(g)return {kind:"ready",normalizedTokens:l,reads:f,writes:m,program:g,cached:true};let R=this.builderPool[this.builderPoolIndex++%this.builderPool.length];R.reset();let O,I=null;try{let E=U.track("parser",()=>(this.parseExpression(R,l,r),R.build()));O=E.result,I=E.alloc;}catch(E){return {kind:"error",stage:"parse",error:chunkSOMGSIO4_cjs.d(E),reads:f,writes:m,normalizedTokens:l}}return this.cacheBytecode(e,O),{kind:"ready",normalizedTokens:l,reads:f,writes:m,program:O,cached:false,parserAlloc:I}}preflightAsync(e,t,r,i,s,o){if(!(t.hasAsync||this.resolverRegistry.size>0))return {kind:"proceed"};let a=new AbortController,l=()=>a.abort();this.keystrokeSignal?.addEventListener("abort",l,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("preflightAsync"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("preflightAsync");let c=a.signal,u=this.resolverRegistry.preflightAll(e,t,"_engine",c,this.queryClient);if(u){this.resolveAsync({type:"pending",queryKey:u.queryKey,resolver:u.resolver,packageId:u.packageId||"_engine",signal:u.signal}),this.dag.registerLineDataSourceDependency(r,u.packageId||"_engine",[u.queryKey]);let p=chunkPS272DZJ_cjs.M(u.queryKey);return this.storeLineResult(r,p,t,s,o,i),{kind:"pending",value:p}}return this.keystrokeSignal?.removeEventListener("abort",l),{kind:"proceed"}}evaluateWithTokens(e,t,r,i){let s=this.prepareExpression(t,r,i,void 0,e);if(s.kind==="empty"){let p=chunkPS272DZJ_cjs.n(0);return this.lineCache.set(e,new W(p,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),t),p}if(s.kind==="error")throw s.error;if(s.kind==="symbolic-solve")return this.storeLineResult(e,s.value,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},s.reads??[],s.writes??[],t),s.value;let{normalizedTokens:o,reads:a,writes:l,program:c}=s,u=this.preflightAsync(o,c,e,t,a,l);return u.kind==="pending"?u.value:this.executeAndStore(c,e,t,a,l,"_engine")}evaluateLine(e,t){let r=this.evaluateLineWithDebug(e,t);if(r.error)throw r.engineError?r.engineError:chunkSOMGSIO4_cjs.c.execution("EVALUATION_ERROR",r.error,{lineNumber:e});return chunkPS272DZJ_cjs.l(r.value)}evaluateLineWithDebug(e,t,r="expression"){let i=t.match(/^s`([^`]*)`$/);if(i){let s=i[1];return {...this.evaluateExpressionWithDiagnostic(s,e,r),inlineSolve:{start:0,end:t.length,expression:s,lineNumber:e,columnNumber:1}}}return this.evaluateExpressionWithDiagnostic(t,e,r)}addDiagnosticStage(e,t,r,i,s,o,a,l,c){e.push({stage:t,label:r,icon:i,colorClass:s,stepNumber:o,elapsedNs:a,skipped:l,output:c});}evaluateExpressionWithDiagnostic(e,t,r="expression"){let i=this.diagnosticPipeline,s=i.hasCollectors,o=this.timelineCollector?.parseletMatchCount??0,a=U.isEnabled(),l=[],c=[],u=0,p=Ie(e,this.config.validation);if(!p.passed)return s&&this.addDiagnosticStage(c,"safety_length","Safety: Length","\u{1F6E1}\uFE0F","validate",2,u,false,{type:"safety_length",passed:false,expressionLength:e.length,maxLength:this.config.validation.maxExpressionLength,errorMessage:p.error.error}),{...p.error,debug:void 0,diagnostic:void 0};s&&(i.firePipelineStart({type:chunkAXMQG5TS_cjs.c.PipelineStart,elapsedNs:0,expression:e,inputType:r}),this.addDiagnosticStage(c,"pipeline_start","Pipeline Start","\u25B6","pipeline",1,u,false,{type:"pipeline_start",expression:e,inputType:r}),this.addDiagnosticStage(c,"safety_length","Safety: Length","\u{1F6E1}\uFE0F","validate",2,u,false,{type:"safety_length",passed:true,expressionLength:e.length,maxLength:this.config.validation.maxExpressionLength}));let f=s?h=>{i.fireTokenEmitted({type:chunkAXMQG5TS_cjs.c.TokenEmitted,elapsedNs:0,expression:e,token:{type:h.type,value:h.value,offset:h.offset||0,line:h.line||t,col:h.col||0}});}:void 0,m=U.track("lexer",()=>this.lexToTokens(e,f)),g=m.result.tokens,R=m.result.hasParens;if(a&&m.alloc&&l.push(m.alloc),s){let h={};for(let A of g)h[A.type]=(h[A.type]||0)+1;this.addDiagnosticStage(c,"lexer","Lexer","\u{1F524}","lexer",3,u,false,{type:"lexer",tokenCount:g.length,tokenTypes:h,hasParens:R,locale:this.localeCode,tokens:[...g]});let N=[];for(let A=0;A<g.length;A++){let ee=g[A];if(ee.type==="INLINE_SOLVE_START"){let V=-1;for(let z=A+1;z<g.length;z++)if(g[z].type==="BACKTICK_OPEN"){V=z;break}if(V>A){let $t=g.slice(A+1,V).map(Wt=>Wt.value).join("");N.push({startTokenIndex:A,endTokenIndex:V,expression:$t,columnNumber:ee.col||1}),A=V;}}}this.addDiagnosticStage(c,"line_classification","Line Classification","\u{1F4CB}","classify",3.5,u,false,{type:"line_classification",classification:"expression",skip:false,hasInlineSolve:N.length>0,inlineSolveSpans:N});}if(g.length===0){let h=chunkPS272DZJ_cjs.n(0);return this.lineCache.set(t,new W(h,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),e),s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:0,totalOpcodes:0}),{value:h,tokens:g,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},debug:void 0,diagnostic:void 0}}let O=0,I=[],E=new Map,X=s?h=>{O++,I.push(h),E.set(h.rule,(E.get(h.rule)||0)+1),i.fireTokenFused({type:chunkAXMQG5TS_cjs.c.TokenFused,elapsedNs:0,expression:e,ruleName:h.rule,sourceTokenCount:h.sourceTokens.length,fusedTokenType:h.fusedToken.type,fusedTokenValue:h.fusedToken.value});}:void 0;s&&this.normalizer.ruleCount>0&&i.fireNormalizerStart({type:chunkAXMQG5TS_cjs.c.NormalizerStart,elapsedNs:0,expression:e,inputTokenCount:g.length});let P=this.bytecodeCache.get(e);s&&!P&&this.parser.setDiagnosticPipeline(i,e);let y=this.prepareExpression(e,g,R,X,t);a&&y.kind==="ready"&&y.parserAlloc&&l.push(y.parserAlloc),s&&!P&&this.parser.setDiagnosticPipeline(void 0,"");let x=y.kind==="empty"?g:y.normalizedTokens??g;if(s&&(this.normalizer.ruleCount>0?(i.fireNormalizerEnd({type:chunkAXMQG5TS_cjs.c.NormalizerEnd,elapsedNs:0,expression:e,outputTokenCount:x.length,fusionsCount:O}),this.addDiagnosticStage(c,"normalizer","Normalizer","\u{1F504}","normalizer",4,u,false,{type:"normalizer",inputTokenCount:g.length,outputTokenCount:x.length,fusions:I,rulesApplied:[...E.entries()].map(([h,N])=>({rule:h,count:N})),tokens:[...x],phrases:this.normalizer.getPhrases()})):this.addDiagnosticStage(c,"normalizer","Normalizer","\u{1F504}","normalizer",4,u,true,{type:"normalizer",inputTokenCount:g.length,outputTokenCount:g.length,fusions:[],rulesApplied:[],tokens:[...g],phrases:this.normalizer.getPhrases()})),y.kind==="empty"||y.kind==="error"&&y.stage==="length"){if(s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:y.kind==="empty",totalTokens:g.length,totalOpcodes:0}),y.kind==="empty"){let h=chunkPS272DZJ_cjs.n(0);return this.lineCache.set(t,new W(h,{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},[],null),e),{value:h,tokens:g,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},debug:void 0,diagnostic:void 0}}return {value:chunkPS272DZJ_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:y.error.message,engineError:y.error,debug:void 0,diagnostic:void 0}}let J=Ve(x,this.config.validation);if(y.kind==="error"&&y.stage==="complexity")return s&&(this.addDiagnosticStage(c,"safety_complexity","Safety: Complexity","\u{1F6E1}\uFE0F","validate",5,u,false,{type:"safety_complexity",passed:false,complexityScore:J.complexityScore??0,maxComplexity:this.config.validation.maxComplexity,breakdown:{tokenCount:x.length,functionCalls:0,nestingDepth:0},errorMessage:J.errorMessage}),i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:g.length,totalOpcodes:0})),{value:chunkPS272DZJ_cjs.n(0),tokens:[],program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:J.errorMessage,engineError:J.engineError,debug:void 0,diagnostic:void 0};if(s&&this.addDiagnosticStage(c,"safety_complexity","Safety: Complexity","\u{1F6E1}\uFE0F","validate",5,u,false,{type:"safety_complexity",passed:true,complexityScore:J.complexityScore??x.length,maxComplexity:this.config.validation.maxComplexity,breakdown:{tokenCount:x.length,functionCalls:0,nestingDepth:0}}),y.kind==="symbolic-solve"){s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:g.length,totalOpcodes:0});let h={opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false};return this.storeLineResult(t,y.value,h,y.reads??[],y.writes??[],e),{value:y.value,tokens:x,program:h,debug:void 0,diagnostic:void 0}}let ae=y.reads??[],Y=y.writes??[];if(s&&(this.addDiagnosticStage(c,"readwrite","Read/Write","\u{1F4CB}","readwrite",6,u,false,{type:"readwrite",reads:ae,writes:Y,isAssignment:Y.length>0}),this.addDiagnosticStage(c,"cache_check","Cache Check","\u{1F4BE}","cache",7,u,false,{type:"cache_check",hit:!!P,cacheSize:this.bytecodeCache.size,cacheKey:e}),P?i.fireCacheHit({type:chunkAXMQG5TS_cjs.c.CacheHit,elapsedNs:0,expression:e,cache:"bytecode",key:e}):i.fireCacheMiss({type:chunkAXMQG5TS_cjs.c.CacheMiss,elapsedNs:0,expression:e,cache:"bytecode",key:e})),y.kind==="error"&&y.stage==="parse")return s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:g.length,totalOpcodes:0}),{value:chunkPS272DZJ_cjs.n(0),tokens:x,program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},error:y.error.message,engineError:y.error,debug:void 0,diagnostic:void 0};if(y.kind!=="ready")throw chunkSOMGSIO4_cjs.c.internal({code:"UNEXPECTED_ERROR",message:"Internal error: prepareExpression() returned an unexpected variant after all other cases were handled"});let v=y.program;s&&(this.addDiagnosticStage(c,"parser","Parser","\u{1F333}","parser",8,u,!!P,{type:"parser",parselets:[],uniqueParseletTypes:[],astDepth:0}),this.addDiagnosticStage(c,"compiler","Compiler","\u2699\uFE0F","compiler",9,u,!!P,{type:"compiler",opcodeCount:v.opcodes.length,numberConstants:v.numbers.length,stringConstants:v.strings.length,hasAsync:v.hasAsync,cached:!!P}),i.fireBytecodeBuilt({type:chunkAXMQG5TS_cjs.c.BytecodeBuilt,elapsedNs:0,expression:e,opcodesLength:v.opcodes.length,numbersLength:v.numbers.length,stringsLength:v.strings.length,isCached:!!P}));let Ft=v.hasAsync||this.resolverRegistry.size>0,Z=this.preflightAsync(x,v,t,e,ae,Y);if(s&&(Z.kind==="pending"?this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,false,{type:"async_preflight",path:"pending",pendingQueryKey:Z.value.value,resolverCount:this.resolverRegistry.size,skippedGuard:true}):Ft?this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,false,{type:"async_preflight",path:"sync",resolverCount:this.resolverRegistry.size,skippedGuard:false}):this.addDiagnosticStage(c,"async_preflight","Async Preflight","\u{1F52E}","async",10,u,true,{type:"async_preflight",path:"sync",resolverCount:0,skippedGuard:true})),Z.kind==="pending")return s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:g.length,totalOpcodes:v.opcodes.length}),{value:Z.value,tokens:x,program:v,debug:void 0,diagnostic:s?this.buildDiagnosticResult(c,Z.value,x,v,null):void 0};let zt=s&&this.config.diagnostic.vmTraceEnabled===true,C;try{let h=U.track("vm",()=>this.executeAndStore(v,t,e,ae,Y,"_engine",zt?i:void 0,e),{cacheHit:!!P});C=h.result,a&&h.alloc&&l.push(h.alloc);}catch(h){let N=chunkSOMGSIO4_cjs.d(h);return s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:false,totalTokens:g.length,totalOpcodes:v.opcodes.length}),{value:chunkPS272DZJ_cjs.n(0),tokens:x,program:v,error:N.message,engineError:N,debug:void 0,diagnostic:void 0}}let le=C.type===12;if(s){let h=le?"pending":String(C.value??""),N=le?"Pending":C.unit?"Uom":"Number";this.addDiagnosticStage(c,"vm_execute","VM Execute","\u26A1","vm",11,u,false,{type:"vm_execute",totalInstructions:v.opcodes.length,stackDepth:this.vm.getStack().length,resultType:N,resultValue:h,isPending:le});}if(le)return s&&i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:g.length,totalOpcodes:v.opcodes.length}),{value:C,tokens:x,program:v,debug:void 0,diagnostic:s?this.buildDiagnosticResult(c,C,x,v,null):void 0};if(a&&l.length>0&&(this.lastTelemetry=U.createTelemetry(e,l,!!P)),s&&(this.addDiagnosticStage(c,"dag_registration","DAG Registration","\u{1F517}","dag",12,u,false,{type:"dag_registration",readsRegistered:ae,writesRegistered:Y,dataSourcesRegistered:[]}),this.addDiagnosticStage(c,"linecache","Line Cache","\u{1F4E6}","cache",13,u,false,{type:"linecache",lineNumber:t,expression:e,stored:true}),this.addDiagnosticStage(c,"result","Result","\u2713","result",14,u,false,{type:"result",rawValue:String(C.value),formattedValue:String(C.value),valueType:C.type===0?"Number":"Value",unit:C.unit}),i.fireVmHalt({type:chunkAXMQG5TS_cjs.c.VmHalt,elapsedNs:0,expression:e,result:C?{type:C.type,value:C.value,unit:C.unit}:void 0}),this.addDiagnosticStage(c,"pipeline_end","Pipeline End","\u23F9","pipeline",15,u,false,{type:"pipeline_end",success:true,totalTokens:g.length,totalOpcodes:v.opcodes.length,cacheHit:!!P}),i.firePipelineEnd({type:chunkAXMQG5TS_cjs.c.PipelineEnd,elapsedNs:0,expression:e,success:true,totalTokens:g.length,totalOpcodes:v.opcodes.length})),s){let N=i.collectReports()[0]?.toJSON(),A=N;if(N){let ee=N.parselets.slice(o),V={};for(let z of ee)V[z.parseletCategory]=(V[z.parseletCategory]??0)+1;A={...N,parselets:ee,summary:{...N.summary,totalParselets:Object.keys(V).length,parseCategories:V}};}return {value:C,tokens:x,program:v,debug:A,diagnostic:this.buildDiagnosticResult(c,C,x,v,null)}}return {value:C,tokens:x,program:v}}buildDiagnosticResult(e,t,r,i,s){return {stages:e,value:t,tokens:r,program:i,error:s,dagSnapshot:this.dag.getSnapshot(),cacheSnapshot:this.getCacheSnapshot(),batcherMetrics:this.getBatcherMetrics(),checkpoints:this.getCheckpoints()}}reEvaluateLine(e,t){let r=this.lineCache.get(e,t);if(!r)return;let i=this.bytecodeCache.get(t);if(!i)return;if(r.bytecode.hasAsync||this.resolverRegistry.size>0){let a=new AbortController,l=()=>a.abort();this.keystrokeSignal?.addEventListener("abort",l,{once:true}),chunkTTFO4YDP_cjs.a.localControllerCreated("reEvaluateLine preflight"),this.keystrokeSignal&&chunkTTFO4YDP_cjs.a.signalLinked("reEvaluateLine preflight");let c=a.signal,u=this.resolverRegistry.preflightAll([],r.bytecode,"_engine",c,this.queryClient);if(u)return this.resolveAsync({type:"pending",queryKey:u.queryKey,resolver:u.resolver,packageId:u.packageId||"_engine",signal:u.signal}),chunkPS272DZJ_cjs.M(u.queryKey);this.keystrokeSignal?.removeEventListener("abort",l);}let s=this.executeRaw(i,e);if(s.type==="pending")return this.resolveAsync(s),chunkPS272DZJ_cjs.M(s.queryKey);if(s.type==="error")throw s.error;let o=s.value;return r.result=o,o}getDag(){return this.dag}getLineCache(){return this.lineCache}getBytecodeCache(){return this.bytecodeCache}getVM(){return this.vm}getContext(){return this.context}getScopeManager(){return this.scopeManager}getLexer(){return this.lexer}getNormalizer(){return this.normalizer}getPackageCompletionItems(){let e=[];for(let t of this.packageCompletionItems.values())e.push(...t);return e}getParseletRegistry(){return {prefix:this.registry.getAllPrefix(),infix:this.registry.getAllInfix()}}tokenizeForClassification(e){this.lexer.resetExpression(e);let r=Array.from(this.lexer).filter(i=>i.type!=="COMMENT");return r.length===0?[]:this.normalizer.normalize(r)}getParser(){return this.parser}isDiagnosticMode(){return this.diagnosticPipeline.hasCollectors}setKeystrokeSignal(e){e?chunkTTFO4YDP_cjs.a.keystrokeSignalSet(e.aborted):chunkTTFO4YDP_cjs.a.keystrokeSignalCleared(),this.keystrokeSignal=e;}getCacheSnapshot(){let e=[];for(let[o,a]of this.bytecodeCache)e.push({expression:o,opcodesLength:a.opcodes.length,numbersLength:a.numbers.length,stringsLength:a.strings.length,hasAsync:a.hasAsync});let t=[];for(let o of this.lineCache.keys()){let a=o.indexOf(":"),l=a>0?parseInt(o.slice(0,a),10)||0:parseInt(o,10)||0,c=a>0?o.slice(a+1):void 0,u=c!==void 0?this.lineCache.get(l,c):this.lineCache.getEntryForLine(l);u&&t.push({key:o,lineNumber:l,resultType:String(u.result?.type??""),resultValue:String(u.result?.value??""),reads:u.readVariables??[],writeVar:u.writeVariable??null});}let s=this.queryClient.getQueryCache().getAll().map(o=>{let a=o.state.status==="success"?"resolved":o.state.status==="error"?"error":"in_flight";return {packageId:o.queryKey[0]??"unknown",resolvedCount:o.state.status==="success"?1:0,inFlightCount:o.state.status!=="success"&&o.state.status!=="error"?1:0,errorCount:o.state.status==="error"?1:0,entries:[{key:o.queryKey.join(":"),status:a}]}});return {bytecode:e,lineCache:t,asyncCache:s}}getBatcherMetrics(){return {pendingCount:this.batcher.pendingCount,dedupCount:this.batcher.dedupCount,workerOffloadCount:this.batcher.workerOffloadCount,listenerCount:this.batcher.listenerCount}}getCheckpoints(){let t=this.vm.checkpointer;return t?t.getAllCheckpoints().map(i=>({lineNumber:i.lineNumber,variables:Object.keys(i.variables),variableCount:Object.keys(i.variables).length})):[]}getLastTelemetry(){return this.lastTelemetry}evaluateExpression(e){return this.evaluateLine(-1,e)}explainLine(e){let{tokens:t}=this.lexToTokens(e),r=t.filter(s=>s.type!=="COMMENT"),i=this.normalizer.normalize(r);return De({expression:e,tokens:i,evaluate:s=>this.evaluateIsolated(s),locale:this.localeCode})}evaluateIsolated(e){let{tokens:t,hasParens:r}=this.lexToTokens(e),i=this.prepareExpression(e,t,r,void 0,-1);if(i.kind==="empty")return chunkPS272DZJ_cjs.n(0);if(i.kind==="error")throw i.error;if(i.kind==="symbolic-solve")return i.value;let s=this.executeRaw(i.program,-1);if(s.type==="error")throw s.error;if(s.type==="pending")throw chunkSOMGSIO4_cjs.c.execution("EXPLAIN_ASYNC_UNSUPPORTED",`A derivation cannot be built for a line that resolves data asynchronously: "${e}"`,{expression:e});return s.value}compileExpression(e){let{tokens:t,hasParens:r}=this.lexToTokens(e),i=this.prepareExpression(e,t,r);if(i.kind==="empty")return {program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},tokens:[],reads:[],writes:[]};if(i.kind==="error")throw i.stage==="parse"&&(i.reads?.length||i.writes?.length)?new chunkSOMGSIO4_cjs.b(i.error.category,{code:i.error.code,message:i.error.message,expected:i.error.expected,found:i.error.found,suggestion:i.error.suggestion,recoverable:i.error.recoverable,span:i.error.span,cause:i.error.cause,context:{...i.error.context,reads:i.reads??[],writes:i.writes??[]}}):i.error;return i.kind==="symbolic-solve"?{program:{opcodes:new Uint8Array(0),numbers:new Float64Array(0),strings:[],hasAsync:false},tokens:i.normalizedTokens,reads:i.reads??[],writes:i.writes??[]}:{program:i.program,tokens:t,reads:i.reads,writes:i.writes}}tryCompileExpression(e){try{return this.tryCompileExpressionUnguarded(e)}catch{return  false}}tryCompileExpressionUnguarded(e){let{tokens:t,hasParens:r}=this.lexToTokens(e);return this.prepareExpression(e,t,r).kind!=="error"}executeCached(e,t=-1){if(e.opcodes.length===0)return chunkPS272DZJ_cjs.n(0);let r=this.executeRaw(e,t);if(r.type==="pending")return this.resolveAsync(r),chunkPS272DZJ_cjs.M(r.queryKey);if(r.type==="error")throw r.error;return r.value}evaluateNumber(e){let t=e.trim();if(/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(t)&&this.vm.getVar(t)===void 0)return NaN;try{let r=this.evaluateLine(-1,e);return r.isFault()?NaN:r.toNumber()}catch{return NaN}}clear(){this.batcher.clearAll(),this.queryClient.clear(),chunkZLRJ7TDP_cjs.b()===this.queryClient&&chunkZLRJ7TDP_cjs.a(null),this.dag.clear(),this.lineCache.clear(),this.scopeManager.clear(),this.bytecodeCache.clear(),this.vm.reset(),this.userUnits.clear(),this.accumulatorNames.clear(),this.lastTelemetry=null;}toJSON(){let e=this.dag.getSnapshot(),t=new Set;for(let c of Object.keys(e.dataSourceDeps)){let u=Number(c);Number.isNaN(u)||t.add(u);}let r=this.lineCache.snapshotEntries(),i=new Map;for(let{line:c,entry:u}of r){let p=t.has(c)||u.bytecode.hasAsync;p&&t.add(c);let f=u.writeVariable;if(f){let m=i.get(f);(!m||c>=m.line)&&i.set(f,{line:c,async:p});}}let s={};for(let[c,u]of this.vm.getVariableEntries())if(u.type!==12&&!i.get(c)?.async)try{s[c]=we(u,`variable "${c}"`);}catch(p){if(p instanceof chunkSOMGSIO4_cjs.b&&p.code===D.SNAPSHOT_UNSUPPORTED_VALUE)continue;throw p}let o=this.vm.getUserFunctionDefs().map(Re),a=[];for(let{line:c,expression:u,entry:p}of r){if(t.has(c)||p.result.type===12)continue;let f;try{f=we(p.result,`line ${c}`);}catch(m){if(m instanceof chunkSOMGSIO4_cjs.b&&m.code===D.SNAPSHOT_UNSUPPORTED_VALUE)continue;throw m}a.push({line:c,expression:u,result:f,bytecode:re(p.bytecode),reads:p.readVariables.slice(),writeVar:p.writeVariable});}let l=Array.from(this.bytecodeCache.entries()).map(([c,u])=>({expression:c,program:re(u)}));return {format:G,version:H,engineVersion:chunkEVI6OHQH_cjs.a,locale:this.localeCode,variables:s,userFunctions:o,lineCache:a,bytecodeCache:l}}static fromJSON(e,t={}){Ot(e);let r=t.locale??e.locale??"en",i=new oe({locale:r,diagnostics:t.diagnostics??false,config:t.config,packages:t.packages});return i.restoreSnapshot(e),i}restoreSnapshot(e){for(let[t,r]of Object.entries(e.variables))this.vm.setVar(t,Ae(r));for(let t of e.userFunctions){let r=Pe(t);this.vm.defineUserFunction(r.name,r.params,r.program);}for(let t of e.lineCache){let r=new W(Ae(t.result),ie(t.bytecode),t.reads.slice(),t.writeVar);this.lineCache.set(t.line,r,t.expression),this.dag.registerLine(t.line,t.reads,t.writeVar?[t.writeVar]:[]);}for(let{expression:t,program:r}of e.bytecodeCache)this.bytecodeCache.set(t,ie(r));}evaluateIncremental(e,t){let r=this.dag.getAffectedLinesInOrder(e);this.vm.setVar(e,chunkPS272DZJ_cjs.n(t));let i=new Map;for(let s of r){let o=this.lineCache.getEntryForLine(s);if(!o||o.bytecode.opcodes.length===0)continue;let a=this.executeRaw(o.bytecode,s);if(a.type==="pending"){this.resolveAsync(a);continue}if(a.type==="error"){let c=chunkPS272DZJ_cjs.N(a.error.code,a.error.message);i.set(s,c),o.result=c;continue}let l=a.value;i.set(s,l),o.result=l;}return i}};oe.GOAL_SEEK_MAX_NESTING_DEPTH=1;var ye=oe;var Ue=(()=>{throw new Error("engine.worker.ts was not processed by esbuild-plugin-inline-worker, so worker offload is unavailable")}),q=null;function hn(){return q||(q=new ye),q}var Q=null;function fn(){return Q||(Q=chunkSYYE3QAX_cjs.c(chunkJAK3RAFA_cjs.w,200,5e4)),Q}function mn(n){let e={lineId:n.lineId,expression:n.expression,compiledAgainstHash:n.textHash,strings:[],reads:[],writes:[],isVariableDef:false,error:null};try{let t=hn(),{program:r,reads:i,writes:s}=t.compileExpression(n.expression),o=s.length>0,a=r.opcodes,l=r.numbers,c=a.buffer.slice(a.byteOffset,a.byteOffset+a.byteLength),u=l.buffer.slice(l.byteOffset,l.byteOffset+l.byteLength);return {...e,opcodesBuffer:c,numbersBuffer:u,opcodesLength:a.length,numbersLength:l.length,strings:[...r.strings],reads:i,writes:s,isVariableDef:o}}catch(t){return {...e,opcodesBuffer:new ArrayBuffer(0),numbersBuffer:new ArrayBuffer(0),opcodesLength:0,numbersLength:0,error:t instanceof Error?t.message:String(t)}}}function yn(n){let e=[],t=[];for(let r of n.items){let i=mn(r);e.push(i),i.opcodesBuffer.byteLength>0&&t.push(i.opcodesBuffer),i.numbersBuffer.byteLength>0&&t.push(i.numbersBuffer);}self.postMessage({id:n.id,type:"COMPILE_RESULT",results:e},t);}function vn(n){let e=fn();e.reset();let t=new Uint8Array(n.opcodesBuffer,0,n.opcodesLength),r=new Float64Array(n.numbersBuffer,0,n.numbersLength),i={opcodes:t,numbers:r,strings:n.strings};try{let s=chunkSYYE3QAX_cjs.d(i,e);if(s.type==="pending")return {lineNumber:n.lineNumber,valueType:12,value:0,isPending:!0,queryKey:s.queryKey};if(s.type==="error")return {lineNumber:n.lineNumber,valueType:13,value:0,isPending:!1,unit:s.error.message};let o=s.value;return {lineNumber:n.lineNumber,valueType:o.type,value:typeof o.value=="number"?o.value:typeof o.value=="bigint"?Number(o.value):0,unit:o.unit,isPending:!1}}catch{return {lineNumber:n.lineNumber,valueType:13,value:0,isPending:false,unit:"Worker execution failed"}}}function bn(n){let e=[];for(let t of n.items)e.push(vn(t));self.postMessage({id:n.id,type:"EXECUTE_RESULT",results:e});}var En=typeof self<"u"&&typeof window>"u",Sn=n=>{if(n.origin&&self.location&&n.origin!==self.location.origin)return;let e=n.data;switch(e.type){case "COMPILE_BATCH":yn(e);break;case "EXECUTE_BATCH":bn(e);break;case "TERMINATE":{q&&(q.clear(),q=null),Q&&(Q.reset(),Q=null),self.postMessage({id:e.id,type:"COMPILE_RESULT",results:[]});break}default:self.postMessage({id:-1,type:"COMPILE_RESULT",results:[],error:`Unknown message type: ${e.type}`});}};En&&(self.onmessage=Sn);var xn=3e4,Ut=50,be=class{constructor(e){this.workers=[];this.nextWorker=0;this.nextId=1;this.pendingBatches=new Map;this.terminated=false;this._available=null;this.poolSize=Math.min(e??this.defaultPoolSize(),4);}defaultPoolSize(){return typeof navigator<"u"&&navigator.hardwareConcurrency?Math.min(navigator.hardwareConcurrency,4):2}isAvailable(){if(this.terminated)return  false;if(this._available!==null)return this._available;if(typeof Worker>"u")return this._available=false,false;try{return Ue().terminate(),this._available=!0,!0}catch{return this._available=false,false}}executeBatch(e,t){if(!this.isAvailable())return;if(e.length===0)return Promise.resolve([]);this.ensureWorkers();let r=[];for(let a of e){let l=t.get(a);if(!l||l.bytecode.opcodes.length===0)continue;let c=l.bytecode.opcodes,u=l.bytecode.numbers,p=c.buffer.slice(c.byteOffset,c.byteOffset+c.byteLength),f=u.buffer.slice(u.byteOffset,u.byteOffset+u.byteLength);r.push({lineNumber:a,opcodesBuffer:p,numbersBuffer:f,opcodesLength:c.length,numbersLength:u.length,strings:[...l.bytecode.strings]});}if(r.length===0)return Promise.resolve([]);let i=[];for(let a of r)a.opcodesBuffer.byteLength>0&&i.push(a.opcodesBuffer),a.numbersBuffer.byteLength>0&&i.push(a.numbersBuffer);let s=this.nextId++,o=this.getNextWorker();return new Promise(a=>{let l=setTimeout(()=>{this.pendingBatches.delete(s),a([]);},xn);this.pendingBatches.set(s,{id:s,lineNumbers:e,resolve:c=>{clearTimeout(l),a(c);}}),o.postMessage({type:"EXECUTE_BATCH",id:s,items:r},i);})}clear(){for(let[,e]of this.pendingBatches)e.resolve([]);this.pendingBatches.clear();for(let e of this.workers)e.terminate();this.workers=[],this.nextWorker=0;}destroy(){this.terminated=true,this.clear();}ensureWorkers(){if(!(this.workers.length>0))for(let e=0;e<this.poolSize;e++){let t=Ue();t.onmessage=r=>{this.handleWorkerMessage(r.data);},t.onerror=r=>{console.error(`[ExecutionPool] Worker ${e} error:`,r.message);for(let[i,s]of this.pendingBatches)s.resolve([]),this.pendingBatches.delete(i);},this.workers.push(t);}}getNextWorker(){let e=this.workers[this.nextWorker];return this.nextWorker=(this.nextWorker+1)%this.workers.length,e}handleWorkerMessage(e){if(e.type!=="EXECUTE_RESULT")return;let t=this.pendingBatches.get(e.id);t&&(this.pendingBatches.delete(e.id),t.resolve(e.results));}};function _t(n){switch(n.valueType){case 0:return chunkPS272DZJ_cjs.n(n.value);case 1:return chunkPS272DZJ_cjs.r(n.value);case 2:return chunkPS272DZJ_cjs.s(BigInt(n.value));case 3:return chunkPS272DZJ_cjs.t(String(n.value));case 4:return chunkPS272DZJ_cjs.K(n.value);case 5:return chunkPS272DZJ_cjs.L(n.value);case 6:return chunkPS272DZJ_cjs.u(n.value,n.unit??"");case 7:return chunkPS272DZJ_cjs.n(n.value);case 10:return chunkPS272DZJ_cjs.J(n.value!==0);case 12:return chunkPS272DZJ_cjs.M(n.queryKey??"");case 13:return chunkPS272DZJ_cjs.N("WORKER_EXECUTION_ERROR",n.unit??"Unknown worker error");default:return chunkPS272DZJ_cjs.n(n.value)}}var Ee=class Ee{constructor(e,t,r,i=Ee.DEFAULT_HIGH_WATER_MARK){this.pending=[];this.scheduled=false;this.cleared=false;this.executionPool=null;this.workerOffloadDispatchCount=0;this._streamController=null;this._testCaptures=null;this.onLineResult=null;this.warnedAboutMissingHook=false;this.dag=e,this.lineCache=t,this.vm=r,this.highWaterMark=i,this._eventStream=this.createEventStream();}warnIfUnwired(){this.onLineResult||this.warnedAboutMissingHook||(this.warnedAboutMissingHook=true,console.warn("[solve-engine] An async result resolved but AsyncResolutionBatcher.onLineResult is not set, so the value cannot reach your document and the line will keep showing as pending. Set it to mirror resolved values into your own state. This warning appears once per batcher."));}createEventStream(){return new ReadableStream({start:e=>{this._streamController=e;},cancel:()=>{this._streamController=null;}},new CountQueuingStrategy({highWaterMark:this.highWaterMark}))}add(e){this.cleared=false;for(let t of this.pending)if(t.packageId===e.packageId&&t.queryKey===e.queryKey)return;this.pending.push(e),this.scheduled||(this.scheduled=true,queueMicrotask(()=>{try{this.flush();}catch(t){let r=chunkSOMGSIO4_cjs.d(t);console.error(`[AsyncResolutionBatcher] flush() failed unexpectedly \u2014 this should never happen; please report: ${r.format()}`);}}));}getEventStream(){return this._eventStream}get pendingCount(){return this.pending.length}get dedupCount(){let e=new Set;for(let t of this.pending)e.add(`${t.packageId}:${t.queryKey}`);return Math.max(0,this.pending.length-e.size)}get listenerCount(){return this._eventStream.locked?1:0}get workerOffloadCount(){return this.workerOffloadDispatchCount}clearAll(){this.pending=[],this.scheduled=false,this.cleared=true,this._testCaptures=null,this.onLineResult=null;try{this._streamController?.close();}catch{}this._streamController=null,this._eventStream=this.createEventStream(),this.executionPool&&(this.executionPool.clear(),this.executionPool=null),this.workerOffloadDispatchCount=0;}flush(){if(this.scheduled=false,this.cleared||this.pending.length===0)return;let e=this.pending;this.pending=[];let t=new Map;for(let c of e){let u=`${c.packageId}:${c.queryKey}`;t.set(u,c);}let r=[],i=[];for(let c of t.values())c.isError?r.push(c):i.push(c);for(let c of r)c.signal.aborted||this.notifyListeners({type:"error",queryKey:c.queryKey,packageId:c.packageId,error:c.error??new Error("Unknown async resolution error")});let s=new Set,o=[],a=[...i,...r];for(let c of a){if(c.signal.aborted)continue;o.push(c.queryKey);let u=this.dag.getAffectedLinesByDataSource(c.packageId,[c.queryKey]);for(let p of u)s.add(p);}if(s.size===0){this.notifyListeners({type:"lines-updated",lineNumbers:[],affectedQueryKeys:o});return}let l=this.topologicalSort(Array.from(s));if(l.length>Ut){let c=new Map;for(let u of l)c.set(u,this.lineCache.getEntryForLine(u));this.reExecuteViaWorkerPool(l,c,o).catch(u=>{let p=chunkSOMGSIO4_cjs.d(u);console.error(`[AsyncResolutionBatcher] reExecuteViaWorkerPool() failed unexpectedly: ${p.format()}`);});return}this.reExecuteMainThread(l,o);}topologicalSort(e){if(e.length<=1)return e;let t=new Map,r=new Map,i=new Map;for(let a of e)t.set(a,0),r.set(a,[]);for(let a of e){let l=this.dag.getWrites(a);for(let c of l)i.set(c,a);}for(let a of e){let l=this.dag.getDependencies(a);for(let c of l){let u=i.get(c);u!==void 0&&u!==a&&(r.get(u).push(a),t.set(a,(t.get(a)??0)+1));}}let s=[];for(let[a,l]of t)l===0&&s.push(a);if(s.length===0&&e.length>0)return [...e].sort((a,l)=>a-l);let o=[];for(;s.length>0;){let a=s.shift();o.push(a);for(let l of r.get(a)??[]){let c=(t.get(l)??1)-1;t.set(l,c),c===0&&s.push(l);}}if(o.length<e.length){let a=e.filter(l=>!o.includes(l)).sort((l,c)=>l-c);o.push(...a);}return o}async reExecuteViaWorkerPool(e,t,r){this.executionPool||(this.executionPool=new be);let i=this.executionPool.executeBatch(e,t);if(!i){this.reExecuteMainThread(e,r,t);return}this.workerOffloadDispatchCount++;let s=await i;if(this.cleared)return;let o=[];for(let a of s){let l=t.get(a.lineNumber);if(!l||a.isPending)continue;let c=_t(a);l.result=c,this.warnIfUnwired(),this.onLineResult?.(a.lineNumber,c),o.push(a.lineNumber);}this.cleared||(o.length>0||r.length>0)&&this.notifyListeners({type:"lines-updated",lineNumbers:o,affectedQueryKeys:r});}reExecuteMainThread(e,t,r){let i=[];for(let s of e){let o=r?r.get(s):this.lineCache.getEntryForLine(s);if(!o||o.bytecode.opcodes.length===0)continue;let a=this.vm.getStack().length;try{let l=chunkSYYE3QAX_cjs.d(o.bytecode,this.vm);for(;this.vm.getStack().length>a;)this.vm.pop();if(l.type==="value")o.result=l.value,this.warnIfUnwired(),this.onLineResult?.(s,l.value),i.push(s);else if(l.type==="error"){let c=chunkPS272DZJ_cjs.N(l.error.code,l.error.message);o.result=c,this.warnIfUnwired(),this.warnIfUnwired(),this.onLineResult?.(s,c),i.push(s);}}catch(l){for(;this.vm.getStack().length>a;)this.vm.pop();let c=chunkSOMGSIO4_cjs.d(l),u=chunkPS272DZJ_cjs.N(c.code,c.message);o.result=u,this.warnIfUnwired(),this.onLineResult?.(s,u),i.push(s);}}return (i.length>0||t.length>0)&&this.notifyListeners({type:"lines-updated",lineNumbers:i,affectedQueryKeys:t}),i}notifyListeners(e){if(this._testCaptures&&this._testCaptures.push(e),this._streamController)try{this._streamController.enqueue(e);}catch{}}};Ee.DEFAULT_HIGH_WATER_MARK=64;var ve=Ee;exports.a=kt;exports.b=Yt;exports.c=At;exports.d=G;exports.e=H;exports.f=D;exports.g=Ue;exports.h=ve;exports.i=Ie;exports.j=Ve;exports.k=fe;exports.l=$n;exports.m=Wn;exports.n=ye;//# sourceMappingURL=chunk-GK2OHWRF.cjs.map
+//# sourceMappingURL=chunk-GK2OHWRF.cjs.map