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

package/dist/chunk-XVWCOTR6.js

@@ -0,0 +1,1324 @@
+import { registerAllTokenTypes, tokenTypeId } from './chunk-RIN643A3.js';
+import { getLocale } from './chunk-GOLDJNMZ.js';
+import { knownUnits } from './chunk-LIPPNDBE.js';
+import { ErrorFactory } from './chunk-6RDSQURE.js';
+
+// src/lexer/ExpressionLexer.ts
+registerAllTokenTypes();
+function buildCharClassTable() {
+  const table = new Uint8Array(128);
+  for (let i = 48; i <= 57; i++) table[i] = 2 /* DIGIT */;
+  for (let i = 65; i <= 90; i++) table[i] = 3 /* ALPHA */;
+  for (let i = 97; i <= 122; i++) table[i] = 3 /* ALPHA */;
+  table[95] = 3 /* ALPHA */;
+  table[46] = 4 /* DOT */;
+  table[32] = 1 /* WHITESPACE */;
+  table[9] = 1 /* WHITESPACE */;
+  table[10] = 1 /* WHITESPACE */;
+  table[13] = 1 /* WHITESPACE */;
+  table[33] = 5 /* OPERATOR */;
+  table[37] = 5 /* OPERATOR */;
+  table[38] = 5 /* OPERATOR */;
+  table[40] = 5 /* OPERATOR */;
+  table[41] = 5 /* OPERATOR */;
+  table[42] = 5 /* OPERATOR */;
+  table[43] = 5 /* OPERATOR */;
+  table[44] = 5 /* OPERATOR */;
+  table[45] = 5 /* OPERATOR */;
+  table[47] = 5 /* OPERATOR */;
+  table[58] = 5 /* OPERATOR */;
+  table[59] = 5 /* OPERATOR */;
+  table[60] = 5 /* OPERATOR */;
+  table[61] = 5 /* OPERATOR */;
+  table[62] = 5 /* OPERATOR */;
+  table[63] = 5 /* OPERATOR */;
+  table[91] = 5 /* OPERATOR */;
+  table[93] = 5 /* OPERATOR */;
+  table[94] = 5 /* OPERATOR */;
+  table[123] = 5 /* OPERATOR */;
+  table[124] = 5 /* OPERATOR */;
+  table[125] = 5 /* OPERATOR */;
+  table[126] = 5 /* OPERATOR */;
+  table[64] = 5 /* OPERATOR */;
+  table[34] = 6 /* QUOTE */;
+  table[35] = 7 /* HASH */;
+  table[36] = 8 /* DOLLAR */;
+  table[96] = 11 /* BACKTICK */;
+  return table;
+}
+var LexerToken = class {
+  constructor(type, typeId, value, text, offset, lineBreaks, line, col) {
+    this.type = type;
+    this.typeId = typeId;
+    this.value = value;
+    this.text = text;
+    this.offset = offset;
+    this.lineBreaks = lineBreaks;
+    this.line = line;
+    this.col = col;
+  }
+};
+var TWO_CHAR_OPS = {
+  61: { 61: "EQUALITY", 62: "THEREFORE" },
+  // ==, => (opposite char order from >='s GTE below — no collision)
+  33: { 61: "NEQ" },
+  // !=
+  62: { 61: "GTE" },
+  // >=
+  60: { 61: "LTE" },
+  // <=
+  38: { 38: "LOGICAL_AND" },
+  // &&
+  124: { 124: "LOGICAL_OR" }
+  // ||
+  // Note: ** is NOT a single token, the existing moo lexer emits two
+  // separate STAR tokens, and the parser consumes them that way.
+  // 42: { 42: 'EXPONENT' },  // **, disabled for moo compatibility
+};
+var OP_MAP = {
+  43: "PLUS",
+  // +
+  45: "MINUS",
+  // -
+  42: "STAR",
+  // *
+  47: "SLASH",
+  // /
+  94: "CARET",
+  // ^
+  37: "PERCENT",
+  // %
+  40: "LPAREN",
+  // (
+  41: "RPAREN",
+  // )
+  91: "LBRACKET",
+  // [
+  93: "RBRACKET",
+  // ]
+  123: "LBRACE",
+  // {
+  125: "RBRACE",
+  // }
+  44: "COMMA",
+  // ,
+  58: "COLON",
+  // :
+  59: "SEMICOLON",
+  // ;
+  61: "EQUALS",
+  // =
+  63: "QUESTION",
+  // ?
+  33: "BANG",
+  // !
+  38: "BIT_AND",
+  // &
+  124: "BIT_OR",
+  // |
+  60: "LT",
+  // <
+  62: "GT",
+  // >
+  126: "BIT_NOT",
+  // ~
+  // "@", activates the token type name already dormant-reserved for this
+  // exact purpose (see Token.ts's OVER/RATE_AT doc comment and
+  // normalizer/TokenNormalizer.ts's NON_WORD_NAMES, both of which already
+  // anticipated "AT" as a future "@" symbol token before this addition).
+  // Backs the time package's video-timecode literal's alternate fps
+  // separator (`01:02:03:04 @ 30fps`, equivalent to `... at 30fps`). See
+  // packages/time/parselets/VideoTimecodeParselet.ts.
+  64: "AT"
+  // @
+};
+var EXPRESSION_INDICATOR_CODES = (() => {
+  const set = /* @__PURE__ */ new Set();
+  for (let i = 48; i <= 57; i++) set.add(i);
+  const opCodes = [43, 45, 42, 47, 94, 37, 40, 41, 91, 93, 123, 125, 61, 60, 62, 33, 38, 124, 126, 59, 63];
+  for (const c of opCodes) set.add(c);
+  set.add(36);
+  set.add(163);
+  set.add(8364);
+  set.add(165);
+  set.add(8381);
+  set.add(8361);
+  set.add(96);
+  set.add(46);
+  set.add(35);
+  return set;
+})();
+var _ExpressionLexer = class _ExpressionLexer {
+  constructor(localeCode = "en", lookup) {
+    /**
+     * Configured TokenLookup from TokenClassRegistry. When set, replaces
+     * the internal keyword map and unit set with registry-built equivalents.
+     * Enables data-driven keyword/unit registration across locale keywords,
+     * provider keywords, and plugins.
+     *
+     * Set at construction time via the constructor parameter. Plugin-registered
+     * keywords/units (via registerVocabulary()) are checked alongside
+     * the configuredLookup, neither source is bypassed.
+     */
+    this.configuredLookup = null;
+    // Instance state
+    this.input = "";
+    this.pos = 0;
+    this.len = 0;
+    // Line / column tracking (1-indexed)
+    this.line = 1;
+    this.lineStartPos = 0;
+    // Plugin-extensible keyword map (merged with locale keywordMap)
+    this.pluginKeywordMap = /* @__PURE__ */ new Map();
+    // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)
+    this.pluginOperators = /* @__PURE__ */ new Map();
+    // Plugin-extensible units (merged with knownUnits)
+    this.pluginUnits = /* @__PURE__ */ new Set();
+    // Fast-path guards: skip plugin lookups entirely when no plugins registered
+    this.hasPluginOps = false;
+    /**
+     * Inline solve spans collected during the most recent tokenization pass.
+     * Populated by [Symbol.iterator]() and consumed by scanDocument().
+     */
+    this._inlineSolveSpans = [];
+    // Plugin-extensible raw-line patterns. See LexerVocabulary.rawLinePatterns.
+    this.pluginRawLinePatterns = [];
+    /**
+     * If a `rawLinePatterns` rule matches the FULL text most recently passed
+     * to {@link reset}, this holds the single synthetic token that
+     * {@link tokenizeAll} should return instead of running the
+     * character-by-character scanner. Cleared (re-evaluated) on every
+     * {@link reset} call. `null` when no plugin registered any raw-line
+     * patterns, or none matched, the overwhelmingly common case, checked
+     * with a `length === 0` guard before ever touching this field so a
+     * plugin-free lexer pays zero cost for the feature.
+     */
+    this.pendingRawLineToken = null;
+    this.localeCode = localeCode;
+    this.locale = getLocale(localeCode);
+    this.configuredLookup = lookup ?? null;
+    this.keywordMap = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(this.locale.keywordMap)) {
+      this.keywordMap.set(k.toLowerCase(), v);
+    }
+    this.mergedKeywords = new Map(this.keywordMap);
+    this.mergedUnits = new Set(knownUnits);
+  }
+  /**
+   * Test `text` against every registered `rawLinePatterns` rule, in
+   * registration order. Returns a synthetic token for the first rule
+   * whose `pattern` matches AND whose capture group 1 is non-empty after
+   * trimming; returns `null` if no rule matches (the normal
+   * character-by-character scanner should run instead).
+   */
+  matchRawLine(text) {
+    for (const rule of this.pluginRawLinePatterns) {
+      const m = rule.pattern.exec(text);
+      if (m && typeof m[1] === "string") {
+        const value = m[1].trim();
+        if (value.length > 0) {
+          return new LexerToken(rule.tokenType, tokenTypeId(rule.tokenType), value, value, 0, 0, this.line, 1);
+        }
+      }
+    }
+    return null;
+  }
+  /** Rebuild merged keyword and unit collections after plugin registration. */
+  rebuildMergedCollections() {
+    this.mergedKeywords = new Map([...this.keywordMap, ...this.pluginKeywordMap]);
+    this.mergedUnits = /* @__PURE__ */ new Set([...knownUnits, ...this.pluginUnits]);
+  }
+  /**
+   * Register a plugin to extend the lexer with custom tokens.
+   *
+   * All registrations are additive, built-in patterns still work.
+   * Keywords, operators, and units from the plugin are merged
+   * with existing ones. Calling multiple times adds more entries.
+   *
+   * Note: multi-word phrases are now handled by the TokenNormalizer
+   * (see `IEnginePackage.normalizerRules`), not the lexer.
+   *
+   * Built-in tokens CANNOT be overridden. Throws a EngineError if the
+   * plugin attempts to register a keyword, operator, or unit
+   * that conflicts with a built-in one.
+   */
+  registerVocabulary(plugin) {
+    if (plugin.keywords) {
+      for (const [keyword, tokenType] of Object.entries(plugin.keywords)) {
+        const lower = keyword.toLowerCase();
+        if (this.keywordMap.has(lower)) {
+          throw ErrorFactory.config(
+            "PLUGIN_KEYWORD_COLLISION",
+            `Plugin keyword "${keyword}" conflicts with built-in keyword (type: ${this.keywordMap.get(lower)}). Built-in keywords cannot be overridden.`,
+            { keyword, builtinType: this.keywordMap.get(lower) }
+          );
+        }
+        this.pluginKeywordMap.set(lower, tokenType);
+      }
+      this.rebuildMergedCollections();
+    }
+    if (plugin.operators) {
+      this.hasPluginOps = true;
+      for (const [chars, tokenType] of Object.entries(plugin.operators)) {
+        if (chars.length === 2) {
+          const first = chars.charCodeAt(0);
+          const second = chars.charCodeAt(1);
+          const builtInSecondMap = TWO_CHAR_OPS[first];
+          if (builtInSecondMap && builtInSecondMap[second] !== void 0) {
+            throw ErrorFactory.config(
+              "PLUGIN_OPERATOR_COLLISION",
+              `Plugin operator "${chars}" conflicts with built-in operator (type: ${builtInSecondMap[second]}). Built-in operators cannot be overridden.`,
+              { operator: chars, builtinType: builtInSecondMap[second] }
+            );
+          }
+          if (first === 60 && second === 60) {
+            throw ErrorFactory.config(
+              "PLUGIN_OPERATOR_COLLISION",
+              `Plugin operator "${chars}" conflicts with built-in operator (type: LSHIFT). Built-in operators cannot be overridden.`,
+              { operator: chars, builtinType: "LSHIFT" }
+            );
+          }
+          if (first === 62 && second === 62) {
+            throw ErrorFactory.config(
+              "PLUGIN_OPERATOR_COLLISION",
+              `Plugin operator "${chars}" conflicts with built-in operator (type: RSHIFT). Built-in operators cannot be overridden.`,
+              { operator: chars, builtinType: "RSHIFT" }
+            );
+          }
+          if (first === 47 && second === 47) {
+            throw ErrorFactory.config(
+              "PLUGIN_OPERATOR_COLLISION",
+              `Plugin operator "${chars}" conflicts with built-in comment sequence. Comment sequences cannot be overridden.`,
+              { operator: chars, builtinType: "COMMENT" }
+            );
+          }
+          let inner = this.pluginOperators.get(first);
+          if (!inner) {
+            inner = /* @__PURE__ */ new Map();
+            this.pluginOperators.set(first, inner);
+          }
+          inner.set(second, tokenType);
+        }
+      }
+    }
+    if (plugin.units) {
+      for (const unit of plugin.units) {
+        if (knownUnits.has(unit)) {
+          throw ErrorFactory.config(
+            "PLUGIN_UNIT_COLLISION",
+            `Plugin unit "${unit}" conflicts with a built-in unit. Built-in units cannot be overridden.`,
+            { unit }
+          );
+        }
+        this.pluginUnits.add(unit);
+      }
+      this.rebuildMergedCollections();
+    }
+    if (plugin.rawLinePatterns) {
+      this.pluginRawLinePatterns.push(...plugin.rawLinePatterns);
+    }
+  }
+  /**
+   * Unregister a plugin, removing its custom tokens from the lexer.
+   *
+   * This is the inverse of registerVocabulary(). All keywords, operators,
+   * and units registered by the plugin are removed. After
+   * unregistration, those tokens will revert to their default behavior
+   * (e.g., keywords become IDENT, operators become ERROR).
+   *
+   * Calling unregisterVocabulary with a plugin that was never registered
+   * is safe, it simply has no effect.
+   */
+  unregisterVocabulary(plugin) {
+    if (plugin.keywords) {
+      for (const keyword of Object.keys(plugin.keywords)) {
+        this.pluginKeywordMap.delete(keyword.toLowerCase());
+      }
+      this.rebuildMergedCollections();
+    }
+    if (plugin.operators) {
+      for (const chars of Object.keys(plugin.operators)) {
+        if (chars.length === 2) {
+          const first = chars.charCodeAt(0);
+          const second = chars.charCodeAt(1);
+          const inner = this.pluginOperators.get(first);
+          if (inner) {
+            inner.delete(second);
+            if (inner.size === 0) {
+              this.pluginOperators.delete(first);
+            }
+          }
+        }
+      }
+      this.hasPluginOps = this.pluginOperators.size > 0;
+    }
+    if (plugin.units) {
+      for (const unit of plugin.units) {
+        this.pluginUnits.delete(unit);
+      }
+      this.rebuildMergedCollections();
+    }
+    if (plugin.rawLinePatterns) {
+      const toRemove = new Set(plugin.rawLinePatterns);
+      this.pluginRawLinePatterns = this.pluginRawLinePatterns.filter((r) => !toRemove.has(r));
+    }
+  }
+  reset(input) {
+    this.input = input;
+    this.pos = 0;
+    this.len = input.length;
+    this.line = 1;
+    this.lineStartPos = 0;
+    this.pendingRawLineToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(input) : null;
+  }
+  /**
+   * Scan a full document text in a single pass, classifying each line and
+   * tokenizing non-skipped lines.
+   *
+   * Replaces the separate classifyLine() + findInlineSolves() + per-line
+   * reset() + tokenizeAll() pattern with a single character-by-character
+   * walk through the entire document. Key benefits:
+   *
+   * - **Single reset()**: `this.pos`, `this.len`, `this.line`, and
+   *   `this.lineStartPos` are set once for the whole document, not per-line.
+   * - **Single classification**: classifyLine() runs once per line inline;
+   *   skipped lines are jumped over without tokenization.
+   * - **Shared tokenization**: Non-skipped lines are tokenized using the
+   *   existing state machine, yielding Token[] without per-line reset().
+   * - **Inline solve detection**: findInlineSolves() is called only for
+   *   lines that classifyLine() marks as having inline solves.
+   *
+   * Tokenization is scoped to each line by temporarily restricting
+   * `this.len` to the line end position, so the [Symbol.iterator]
+   * generator naturally stops at the line boundary. After tokenization,
+   * `this.len` is restored and `this.pos` advances past the newline.
+   *
+   * @param text The full document text (with newlines).
+   * @returns Array of ScanLineResult, one per line, in document order.
+   */
+  scanDocument(text) {
+    this.input = text;
+    this.pos = 0;
+    this.len = text.length;
+    this.line = 1;
+    this.lineStartPos = 0;
+    const results = [];
+    const input = this.input;
+    const docLen = this.len;
+    while (this.pos < docLen) {
+      const lineStart = this.pos;
+      let lineEnd = this.pos;
+      while (lineEnd < docLen) {
+        const cc = input.charCodeAt(lineEnd);
+        if (cc === 10 || cc === 13) break;
+        lineEnd++;
+      }
+      const lineNumber = this.line;
+      const classification = this.classifyFromPositions(lineStart, lineEnd);
+      const lineText = input.slice(lineStart, lineEnd);
+      let tokens = [];
+      if (!classification.skip) {
+        const rawToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(lineText) : null;
+        if (rawToken) {
+          tokens = [rawToken];
+        } else {
+          const savedLen = this.len;
+          this.len = lineEnd;
+          tokens = Array.from(this);
+          this.len = savedLen;
+        }
+      }
+      let inlineSolves = [];
+      if (classification.hasInlineSolve) {
+        if (!classification.skip && tokens.length > 0) {
+          const charSpans = this.findInlineSolves(lineText);
+          inlineSolves = this._inlineSolveSpans.map((span, i) => ({
+            start: charSpans[i]?.start ?? 0,
+            end: charSpans[i]?.end ?? 0,
+            expression: charSpans[i]?.expression ?? "",
+            columnNumber: charSpans[i]?.columnNumber ?? span.columnNumber,
+            startTokenIndex: span.startTokenIndex,
+            endTokenIndex: span.endTokenIndex
+          }));
+        } else {
+          inlineSolves = this.findInlineSolves(lineText);
+        }
+      }
+      results.push({
+        text: lineText,
+        lineNumber,
+        startOffset: lineStart,
+        endOffset: lineEnd,
+        classification,
+        tokens,
+        inlineSolves
+      });
+      this.pos = lineEnd;
+      if (this.pos < docLen) {
+        const nlChar = input.charCodeAt(this.pos);
+        if (nlChar === 13) {
+          this.pos++;
+          if (this.pos < docLen && input.charCodeAt(this.pos) === 10) {
+            this.pos++;
+          }
+        } else if (nlChar === 10) {
+          this.pos++;
+        }
+      }
+      this.line++;
+      this.lineStartPos = this.pos;
+    }
+    return results;
+  }
+  /**
+   * Tokenize an expression string into an array of Tokens.
+   *
+   * Delegates to the lazy [Symbol.iterator]() generator and collects all
+   * yielded tokens via Array.from(). For memory-sensitive use cases, prefer
+   * iterating the lexer directly with for...of to avoid array allocation.
+   *
+   * Optimizations:
+   *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers
+   *  - Direct character-code dispatch (c0 cached pattern)
+   *  - Mathematical digit parsing (integer math, not slice+parseFloat)
+   *  - Inline operator tokenizer with two-char peek-ahead
+   *  - Whitespace eliminated in-lexer (never emitted)
+   *  - 0-char and 1-char fast paths
+   */
+  tokenizeAll() {
+    if (this.pendingRawLineToken) {
+      this._inlineSolveSpans = [];
+      return [this.pendingRawLineToken];
+    }
+    return Array.from(this);
+  }
+  // ── Lazy iterator ─────────────────────────────────────────────────────
+  /**
+   * Lazy token-by-token generator. Yields each token without allocating an
+   * intermediate Token[] array. Supports for...of and spread usage.
+   *
+   * Usage:
+   *   for (const t of lexer) { ... }  // lazy, no array allocation
+   *   const tokens = [...lexer];       // materializes via spread
+   *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()
+   *
+   * IMPORTANT: This generator captures `this.len` ONCE at creation time
+   * (const len = this.len). `scanDocument()` relies on this behavior to
+   * scope tokenization to a single line by temporarily restricting
+   * `this.len` to the line end position before creating the iterator.
+   * Do NOT refactor to re-read `this.len` mid-loop without also updating
+   * `scanDocument()`.
+   */
+  *[Symbol.iterator]() {
+    const len = this.len;
+    if (len === 0) {
+      this._inlineSolveSpans = [];
+      return;
+    }
+    let tokenIndex = 0;
+    let openSpan = null;
+    const collectedSpans = [];
+    if (len === 1) {
+      const c0 = this.input.charCodeAt(0);
+      const cc = _ExpressionLexer.CHAR_CLASS[c0] ?? 0 /* SKIP */;
+      switch (cc) {
+        case 2 /* DIGIT */:
+        case 4 /* DOT */:
+          yield new LexerToken("NUMBER", tokenTypeId("NUMBER"), this.input, this.input, 0, 0, 1, 1);
+          tokenIndex++;
+          break;
+        case 3 /* ALPHA */: {
+          const input2 = this.input;
+          const identLower = input2.toLowerCase();
+          if (this.mergedUnits.has(input2)) {
+            yield new LexerToken("UNIT", tokenTypeId("UNIT"), input2, input2, 0, 0, 1, 1);
+          } else {
+            const kwType = this.mergedKeywords.get(identLower);
+            if (kwType) {
+              yield new LexerToken(kwType, tokenTypeId(kwType), input2, input2, 0, 0, 1, 1);
+            } else {
+              yield new LexerToken("IDENT", tokenTypeId("IDENT"), input2, input2, 0, 0, 1, 1);
+            }
+          }
+          tokenIndex++;
+          break;
+        }
+        case 5 /* OPERATOR */: {
+          const opType = OP_MAP[c0];
+          if (opType) {
+            yield new LexerToken(opType, tokenTypeId(opType), this.input, this.input, 0, 0, 1, 1);
+            tokenIndex++;
+          }
+          break;
+        }
+        case 6 /* QUOTE */:
+          this.pos = 0;
+          yield this.tokenizeString();
+          tokenIndex++;
+          break;
+        case 7 /* HASH */:
+          this.pos = 0;
+          yield this.tokenizeComment();
+          tokenIndex++;
+          break;
+        case 8 /* DOLLAR */:
+          yield new LexerToken("DOLLAR", tokenTypeId("DOLLAR"), "$", "$", 0, 0, 1, 1);
+          tokenIndex++;
+          break;
+        case 11 /* BACKTICK */:
+          yield new LexerToken("BACKTICK_OPEN", tokenTypeId("BACKTICK_OPEN"), "`", "`", 0, 0, 1, 1);
+          tokenIndex++;
+          break;
+        default: {
+          if (c0 === 215) {
+            yield new LexerToken("STAR", tokenTypeId("STAR"), "\xD7", "\xD7", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 247) {
+            yield new LexerToken("SLASH", tokenTypeId("SLASH"), "\xF7", "\xF7", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8800) {
+            yield new LexerToken("NEQ", tokenTypeId("NEQ"), "\u2260", "\u2260", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 163) {
+            yield new LexerToken("POUND", tokenTypeId("POUND"), "\xA3", "\xA3", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8364) {
+            yield new LexerToken("EURO", tokenTypeId("EURO"), "\u20AC", "\u20AC", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 165) {
+            yield new LexerToken("YEN", tokenTypeId("YEN"), "\xA5", "\xA5", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8381) {
+            yield new LexerToken("RUBLE", tokenTypeId("RUBLE"), "\u20BD", "\u20BD", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8361) {
+            yield new LexerToken("WON", tokenTypeId("WON"), "\u20A9", "\u20A9", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8377) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B9", "\u20B9", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8378) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20BA", "\u20BA", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8372) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B4", "\u20B4", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8362) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20AA", "\u20AA", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8363) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20AB", "\u20AB", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8358) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20A6", "\u20A6", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 === 8369) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B1", "\u20B1", 0, 0, 1, 1);
+            tokenIndex++;
+          } else if (c0 >= 128) {
+            yield new LexerToken("IDENT", tokenTypeId("IDENT"), this.input, this.input, 0, 0, 1, 1);
+            tokenIndex++;
+          }
+          break;
+        }
+      }
+      this._inlineSolveSpans = collectedSpans;
+      return;
+    }
+    const input = this.input;
+    while (this.pos < len) {
+      const c0 = input.charCodeAt(this.pos);
+      const cc = _ExpressionLexer.CHAR_CLASS[c0] ?? 0 /* SKIP */;
+      if (openSpan && c0 === 92 && this.pos + 1 < len && input.charCodeAt(this.pos + 1) === 96) {
+        this.pos += 2;
+        continue;
+      }
+      switch (cc) {
+        // ── Whitespace, skip entirely, track newlines ────────────────
+        case 1 /* WHITESPACE */:
+          this.pos++;
+          if (c0 === 10) {
+            this.line++;
+            this.lineStartPos = this.pos;
+          } else if (c0 === 13) {
+            this.line++;
+            if (this.pos < len && input.charCodeAt(this.pos) === 10) {
+              this.pos++;
+            }
+            this.lineStartPos = this.pos;
+          }
+          break;
+        // ── Digit, inline number tokenizer ───────────────────────────
+        case 2 /* DIGIT */:
+          yield this.tokenizeNumber();
+          tokenIndex++;
+          break;
+        // ── Alpha / underscore, identifier or keyword ────────────────
+        case 3 /* ALPHA */: {
+          const token = this.tokenizeIdentifier();
+          if (token.type === "INLINE_SOLVE_START") {
+            openSpan = { startTokenIndex: tokenIndex, startColumn: token.col };
+          }
+          yield token;
+          tokenIndex++;
+          break;
+        }
+        // ── Dot, could be decimal (.5) or DOT token ─────────────────
+        case 4 /* DOT */:
+          if (this.pos + 1 < len) {
+            const nextCc = _ExpressionLexer.CHAR_CLASS[input.charCodeAt(this.pos + 1)] ?? 0 /* SKIP */;
+            if (nextCc === 2 /* DIGIT */) {
+              yield this.tokenizeNumber();
+            } else {
+              const col = this.pos - this.lineStartPos + 1;
+              yield new LexerToken("DOT", tokenTypeId("DOT"), ".", ".", this.pos, 0, this.line, col);
+              this.pos++;
+            }
+          } else {
+            const col = this.pos - this.lineStartPos + 1;
+            yield new LexerToken("DOT", tokenTypeId("DOT"), ".", ".", this.pos, 0, this.line, col);
+            this.pos++;
+          }
+          tokenIndex++;
+          break;
+        // ── Operator / punctuation ────────────────────────────────────
+        case 5 /* OPERATOR */:
+          yield this.tokenizeOperator();
+          tokenIndex++;
+          break;
+        // ── String literal ────────────────────────────────────────────
+        case 6 /* QUOTE */:
+          yield this.tokenizeString();
+          tokenIndex++;
+          break;
+        // ── Comment (# or //) ─────────────────────────────────────────
+        case 7 /* HASH */:
+          yield this.tokenizeComment();
+          tokenIndex++;
+          break;
+        // ── Dollar sign $ ─────────────────────────────────────────────
+        case 8 /* DOLLAR */: {
+          const col = this.pos - this.lineStartPos + 1;
+          yield new LexerToken("DOLLAR", tokenTypeId("DOLLAR"), "$", "$", this.pos, 0, this.line, col);
+          this.pos++;
+          tokenIndex++;
+          break;
+        }
+        // ── Backtick ` ───────────────────────────────────────────────
+        case 11 /* BACKTICK */: {
+          const col = this.pos - this.lineStartPos + 1;
+          yield new LexerToken("BACKTICK_OPEN", tokenTypeId("BACKTICK_OPEN"), "`", "`", this.pos, 0, this.line, col);
+          this.pos++;
+          if (openSpan) {
+            const span = openSpan;
+            collectedSpans.push({
+              start: 0,
+              end: 0,
+              expression: "",
+              columnNumber: span.startColumn,
+              startTokenIndex: span.startTokenIndex,
+              endTokenIndex: tokenIndex
+            });
+            openSpan = null;
+          }
+          tokenIndex++;
+          break;
+        }
+        // ── Non-ASCII characters ─────────────────────────────────────
+        default: {
+          const col = this.pos - this.lineStartPos + 1;
+          if (c0 === 215) {
+            yield new LexerToken("STAR", tokenTypeId("STAR"), "\xD7", "\xD7", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 247) {
+            yield new LexerToken("SLASH", tokenTypeId("SLASH"), "\xF7", "\xF7", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8800) {
+            yield new LexerToken("NEQ", tokenTypeId("NEQ"), "\u2260", "\u2260", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 163) {
+            yield new LexerToken("POUND", tokenTypeId("POUND"), "\xA3", "\xA3", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8364) {
+            yield new LexerToken("EURO", tokenTypeId("EURO"), "\u20AC", "\u20AC", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 165) {
+            yield new LexerToken("YEN", tokenTypeId("YEN"), "\xA5", "\xA5", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8381) {
+            yield new LexerToken("RUBLE", tokenTypeId("RUBLE"), "\u20BD", "\u20BD", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8361) {
+            yield new LexerToken("WON", tokenTypeId("WON"), "\u20A9", "\u20A9", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8377) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B9", "\u20B9", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8378) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20BA", "\u20BA", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8372) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B4", "\u20B4", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8362) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20AA", "\u20AA", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8363) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20AB", "\u20AB", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8358) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20A6", "\u20A6", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 === 8369) {
+            yield new LexerToken("CURRENCY_SYMBOL", tokenTypeId("CURRENCY_SYMBOL"), "\u20B1", "\u20B1", this.pos, 0, this.line, col);
+            this.pos++;
+            tokenIndex++;
+          } else if (c0 >= 128) {
+            yield this.tokenizeIdentifier();
+            tokenIndex++;
+          } else {
+            this.pos++;
+          }
+          break;
+        }
+      }
+    }
+    this._inlineSolveSpans = collectedSpans;
+  }
+  // ── Inline number tokenizer ────────────────────────────────────────────
+  /**
+   * Character-by-character number parsing.
+   *
+   * Supports: integers, floats, scientific notation (1.5e10, 1.5e-10),
+   * hex (0xFF), binary (0b1010), octal (0o17), BigInt suffix (123n),
+   * thousands separators (1,234 or 1.234.567).
+   *
+   * Returns a LexerToken and advances `this.pos` past the number.
+   */
+  tokenizeNumber() {
+    const input = this.input;
+    const len = this.len;
+    let pos = this.pos;
+    const start = pos;
+    const startCol = pos - this.lineStartPos + 1;
+    let cc;
+    if (input.charCodeAt(pos) === 48 && pos + 1 < len) {
+      const next = input.charCodeAt(pos + 1);
+      if (next === 120 || next === 88) {
+        pos += 2;
+        while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 57 || cc >= 65 && cc <= 70 || cc >= 97 && cc <= 102)) {
+          pos++;
+        }
+        const text2 = input.slice(start, pos);
+        this.pos = pos;
+        return new LexerToken("NUMBER", tokenTypeId("NUMBER"), text2, text2, start, 0, this.line, startCol);
+      }
+      if (next === 98 || next === 66) {
+        pos += 2;
+        while (pos < len && (cc = input.charCodeAt(pos), cc === 48 || cc === 49)) {
+          pos++;
+        }
+        const text2 = input.slice(start, pos);
+        this.pos = pos;
+        return new LexerToken("NUMBER", tokenTypeId("NUMBER"), text2, text2, start, 0, this.line, startCol);
+      }
+      if (next === 111 || next === 79) {
+        pos += 2;
+        while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 55)) {
+          pos++;
+        }
+        const text2 = input.slice(start, pos);
+        this.pos = pos;
+        return new LexerToken("NUMBER", tokenTypeId("NUMBER"), text2, text2, start, 0, this.line, startCol);
+      }
+    }
+    let hasIntPart = false;
+    while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 57)) {
+      hasIntPart = true;
+      pos++;
+    }
+    while (hasIntPart && pos < len && (input.charCodeAt(pos) === 44 || input.charCodeAt(pos) === 46)) {
+      if (pos + 4 <= len) {
+        const d1 = input.charCodeAt(pos + 1);
+        const d2 = input.charCodeAt(pos + 2);
+        const d3 = input.charCodeAt(pos + 3);
+        const d4 = pos + 4 < len ? input.charCodeAt(pos + 4) : -1;
+        const isGroupOfExactlyThree = !(d4 >= 48 && d4 <= 57);
+        if (d1 >= 48 && d1 <= 57 && d2 >= 48 && d2 <= 57 && d3 >= 48 && d3 <= 57 && isGroupOfExactlyThree) {
+          pos += 4;
+          hasIntPart = true;
+          continue;
+        }
+      }
+      break;
+    }
+    let hasDecimal = false;
+    if (pos < len && input.charCodeAt(pos) === 46) {
+      if (pos + 1 < len) {
+        const nextCc = input.charCodeAt(pos + 1);
+        if (nextCc >= 48 && nextCc <= 57) {
+          hasDecimal = true;
+          pos++;
+          while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 57)) {
+            pos++;
+          }
+        }
+      }
+    }
+    let hasExponent = false;
+    if (pos < len) {
+      const ec = input.charCodeAt(pos);
+      if (ec === 101 || ec === 69) {
+        if (pos + 1 < len) {
+          const next = input.charCodeAt(pos + 1);
+          if (next >= 48 && next <= 57 || next === 43 || next === 45) {
+            hasExponent = true;
+            pos++;
+            if (next === 43 || next === 45) pos++;
+            while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 57)) {
+              pos++;
+            }
+          }
+        }
+      }
+    }
+    if (pos < len && input.charCodeAt(pos) === 110) {
+      if (hasIntPart && !hasDecimal && !hasExponent) {
+        pos++;
+        const text2 = input.slice(start, pos);
+        this.pos = pos;
+        return new LexerToken("BIGINT", tokenTypeId("BIGINT"), text2, text2, start, 0, this.line, startCol);
+      }
+    }
+    const text = input.slice(start, pos);
+    this.pos = pos;
+    return new LexerToken("NUMBER", tokenTypeId("NUMBER"), text, text, start, 0, this.line, startCol);
+  }
+  // ── Inline identifier / keyword tokenizer ──────────────────────────────
+  /**
+   * Reads [a-zA-Z_][a-zA-Z0-9_]* and resolves to:
+   *   - A unit type (via knownUnits, case-sensitive)
+   *   - A keyword type (via locale keywordMap, case-insensitive)
+   *   - IDENT if none of the above
+   *
+   * Multi-word phrases (e.g., "to the power of") are handled by the
+   * TokenNormalizer post-lexer pass, not the lexer.
+   */
+  tokenizeIdentifier() {
+    const input = this.input;
+    const len = this.len;
+    let pos = this.pos;
+    const start = pos;
+    const startCol = pos - this.lineStartPos + 1;
+    let cc;
+    while (pos < len && (cc = input.charCodeAt(pos), cc >= 48 && cc <= 57 || // 0-9
+    cc >= 65 && cc <= 90 || // A-Z
+    cc >= 97 && cc <= 122 || // a-z
+    cc === 95 || // _
+    cc >= 128)) {
+      pos++;
+    }
+    const identText = input.slice(start, pos);
+    const identLower = identText.toLowerCase();
+    if (identLower === "s" && pos < len && input.charCodeAt(pos) === 96) {
+      pos++;
+      this.pos = pos;
+      const fullText = input.slice(start, pos);
+      return new LexerToken("INLINE_SOLVE_START", tokenTypeId("INLINE_SOLVE_START"), fullText, fullText, start, 0, this.line, startCol);
+    }
+    const isKnownUnit = this.mergedUnits.has(identText);
+    if (isKnownUnit) {
+      if (!this.isFollowedByLParen(pos)) {
+        this.pos = pos;
+        return new LexerToken("UNIT", tokenTypeId("UNIT"), identText, identText, start, 0, this.line, startCol);
+      }
+    }
+    const localeKwType = this.mergedKeywords.get(identLower);
+    if (localeKwType) {
+      this.pos = pos;
+      return new LexerToken(localeKwType, tokenTypeId(localeKwType), identText, identText, start, 0, this.line, startCol);
+    }
+    this.pos = pos;
+    return new LexerToken("IDENT", tokenTypeId("IDENT"), identText, identText, start, 0, this.line, startCol);
+  }
+  /**
+   * Peek past in-expression whitespace (space, tab) from `pos` to check
+   * if the next significant character is '('.
+   */
+  isFollowedByLParen(pos) {
+    const len = this.len;
+    let lookPos = pos;
+    while (lookPos < len) {
+      const cc = this.input.charCodeAt(lookPos);
+      if (cc === 40) return true;
+      if (cc !== 32 && cc !== 9) break;
+      lookPos++;
+    }
+    return false;
+  }
+  // ── Inline operator tokenizer ─────────────────────────────────────────
+  /**
+   * Reads an operator/punctuation token.
+   * Handles two-char operators (==, !=, >=, <=, **) and the special
+   * cases << (LSHIFT) and >> (RSHIFT).
+   */
+  tokenizeOperator() {
+    const input = this.input;
+    const pos = this.pos;
+    const col = pos - this.lineStartPos + 1;
+    const c0 = input.charCodeAt(pos);
+    const len = this.len;
+    if (pos + 1 < len) {
+      const c1 = input.charCodeAt(pos + 1);
+      const secondMap = TWO_CHAR_OPS[c0];
+      if (secondMap) {
+        const twoCharType = secondMap[c1];
+        if (twoCharType) {
+          const text2 = input.slice(pos, pos + 2);
+          this.pos = pos + 2;
+          return new LexerToken(twoCharType, tokenTypeId(twoCharType), text2, text2, pos, 0, this.line, col);
+        }
+      }
+      if (c0 === 47 && c1 === 47) {
+        let commentPos = pos + 2;
+        while (commentPos < len) {
+          const cc = input.charCodeAt(commentPos);
+          if (cc === 10 || cc === 13) break;
+          commentPos++;
+        }
+        const text2 = input.slice(pos, commentPos);
+        this.pos = commentPos;
+        return new LexerToken("COMMENT", tokenTypeId("COMMENT"), text2, text2, pos, 0, this.line, col);
+      }
+      if (c0 === 60 && c1 === 60) {
+        this.pos = pos + 2;
+        return new LexerToken("LSHIFT", tokenTypeId("LSHIFT"), "<<", "<<", pos, 0, this.line, col);
+      }
+      if (c0 === 62 && c1 === 62) {
+        if (input.charCodeAt(pos + 2) === 62) {
+          this.pos = pos + 3;
+          return new LexerToken("URSHIFT", tokenTypeId("URSHIFT"), ">>>", ">>>", pos, 0, this.line, col);
+        }
+        this.pos = pos + 2;
+        return new LexerToken("RSHIFT", tokenTypeId("RSHIFT"), ">>", ">>", pos, 0, this.line, col);
+      }
+      if (this.hasPluginOps) {
+        const pluginInner = this.pluginOperators.get(c0);
+        if (pluginInner) {
+          const pluginType = pluginInner.get(c1);
+          if (pluginType) {
+            const text2 = input.slice(pos, pos + 2);
+            this.pos = pos + 2;
+            return new LexerToken(pluginType, tokenTypeId(pluginType), text2, text2, pos, 0, this.line, col);
+          }
+        }
+      }
+    }
+    this.pos = pos + 1;
+    const opType = OP_MAP[c0];
+    const text = input.charAt(pos);
+    return new LexerToken(opType || "ERROR", tokenTypeId(opType || "ERROR"), text, text, pos, 0, this.line, col);
+  }
+  // ── String literal tokenizer ──────────────────────────────────────────
+  /**
+   * Reads a double-quoted string literal. Supports backslash escapes.
+   */
+  tokenizeString() {
+    const input = this.input;
+    const len = this.len;
+    const start = this.pos;
+    const startCol = start - this.lineStartPos + 1;
+    let pos = start + 1;
+    let lineBreaks = 0;
+    while (pos < len) {
+      const c0 = input.charCodeAt(pos);
+      if (c0 === 34) {
+        pos++;
+        const text2 = input.slice(start, pos);
+        this.pos = pos;
+        return new LexerToken("STRING", tokenTypeId("STRING"), text2, text2, start, lineBreaks, this.line, startCol);
+      }
+      if (c0 === 92 && pos + 1 < len) {
+        pos += 2;
+        continue;
+      }
+      if (c0 === 10) {
+        this.line++;
+        this.lineStartPos = pos + 1;
+        lineBreaks++;
+      }
+      pos++;
+    }
+    const text = input.slice(start, pos);
+    this.pos = pos;
+    return new LexerToken("STRING", tokenTypeId("STRING"), text, text, start, lineBreaks, this.line, startCol);
+  }
+  // ── Markdown line scanner (Phase B) ───────────────────────────────────
+  /**
+   * L1 expression gating: quickly determine if a line contains any
+   * characters that indicate an expression (digits, operators, currency,
+   * backticks, parentheses, etc.).
+   *
+   * Pure prose lines (e.g., "The quick brown fox jumps over the lazy dog")
+   * return false and can be skipped without full tokenization (L2).
+   *
+   * This is a fast character-by-character scan that stops at the first
+   * expression indicator. Called once per line in classifyFromPositions().
+   */
+  static hasExpressionIndicators(input, start, end) {
+    const indicatorCodes = EXPRESSION_INDICATOR_CODES;
+    for (let i = start; i < end; i++) {
+      const cc = input.charCodeAt(i);
+      if (indicatorCodes.has(cc)) return true;
+      if (cc >= 128) {
+        if (cc === 215 || cc === 247 || cc === 8800 || cc === 163 || cc === 8364 || cc === 165 || cc === 8381 || cc === 8361) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Classify a line by its character positions within this.input.
+   * Reads directly from this.input using start/end boundaries.
+   * DOES NOT modify this.pos, purely a read-only classifier.
+   */
+  classifyFromPositions(start, end) {
+    const len = end;
+    if (start >= len) {
+      return { type: "empty", skip: true, hasInlineSolve: false };
+    }
+    const input = this.input;
+    let pos = start;
+    while (pos < len) {
+      const cc = input.charCodeAt(pos);
+      if (cc !== 32 && cc !== 9) break;
+      pos++;
+    }
+    if (pos >= len) {
+      return { type: "empty", skip: true, hasInlineSolve: false };
+    }
+    const c0 = input.charCodeAt(pos);
+    let hasInline;
+    if (c0 === 35) {
+      let hashCount = 1;
+      while (pos + hashCount < len && input.charCodeAt(pos + hashCount) === 35) {
+        hashCount++;
+      }
+      if (hashCount <= 6 && pos + hashCount < len && input.charCodeAt(pos + hashCount) === 32) {
+        return { type: "heading", skip: true, hasInlineSolve: false };
+      }
+      return { type: "heading", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 62) {
+      if (pos + 1 < len && input.charCodeAt(pos + 1) === 32) {
+        return { type: "blockquote", skip: true, hasInlineSolve: false };
+      }
+    }
+    if (c0 === 96 && pos + 2 < len && input.charCodeAt(pos + 1) === 96 && input.charCodeAt(pos + 2) === 96) {
+      return { type: "code_fence", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 126 && pos + 2 < len && input.charCodeAt(pos + 1) === 126 && input.charCodeAt(pos + 2) === 126) {
+      return { type: "code_fence", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 36 && pos + 1 < len && input.charCodeAt(pos + 1) === 36) {
+      return { type: "math_fence", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 45 || c0 === 42 || c0 === 95) {
+      let count = 1;
+      while (pos + count < len && input.charCodeAt(pos + count) === c0) {
+        count++;
+      }
+      if (count >= 3) {
+        let trailPos = pos + count;
+        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {
+          trailPos++;
+        }
+        if (trailPos >= len) {
+          return { type: "hr", skip: true, hasInlineSolve: false };
+        }
+      }
+    }
+    if ((c0 === 45 || c0 === 42 || c0 === 43) && pos + 1 < len && input.charCodeAt(pos + 1) === 32) {
+      if (hasInline === void 0) {
+        const idx = input.indexOf("s`", pos);
+        hasInline = idx !== -1 && idx < len;
+      }
+      return { type: "list", skip: false, hasInlineSolve: hasInline };
+    }
+    if (c0 >= 48 && c0 <= 57) {
+      let digitPos = pos;
+      while (digitPos < len && input.charCodeAt(digitPos) >= 48 && input.charCodeAt(digitPos) <= 57) {
+        digitPos++;
+      }
+      if (digitPos < len && input.charCodeAt(digitPos) === 46) {
+        if (digitPos + 1 < len && input.charCodeAt(digitPos + 1) === 32) {
+          if (hasInline === void 0) {
+            const idx = input.indexOf("s`", pos);
+            hasInline = idx !== -1 && idx < len;
+          }
+          return { type: "list", skip: false, hasInlineSolve: hasInline };
+        }
+      }
+    }
+    if (c0 === 124) {
+      let tPos = pos + 1;
+      while (tPos < len) {
+        const tc = input.charCodeAt(tPos);
+        if (tc !== 45 && tc !== 58 && tc !== 124 && tc !== 32 && tc !== 9 && tc !== 13) break;
+        tPos++;
+      }
+      if (tPos >= len) {
+        return { type: "table_separator", skip: true, hasInlineSolve: false };
+      }
+    }
+    if (c0 === 91 && pos + 1 < len && input.charCodeAt(pos + 1) === 91) {
+      const closePos = input.indexOf("]]", pos + 2);
+      if (closePos !== -1 && closePos < len) {
+        let trailPos = closePos + 2;
+        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {
+          trailPos++;
+        }
+        if (trailPos >= len) {
+          return { type: "wikilink", skip: true, hasInlineSolve: false };
+        }
+      }
+    }
+    if (c0 === 33 && pos + 2 < len && input.charCodeAt(pos + 1) === 91 && input.charCodeAt(pos + 2) === 91) {
+      const closePos = input.indexOf("]]", pos + 3);
+      if (closePos !== -1 && closePos < len) {
+        let trailPos = closePos + 2;
+        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {
+          trailPos++;
+        }
+        if (trailPos >= len) {
+          return { type: "wikilink", skip: true, hasInlineSolve: false };
+        }
+      }
+    }
+    if (c0 === 47 && pos + 1 < len && input.charCodeAt(pos + 1) === 47) {
+      return { type: "comment", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 62) {
+      let trail = pos + 1;
+      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;
+      if (trail >= len) return { type: "blockquote", skip: true, hasInlineSolve: false };
+    }
+    if (c0 === 45 || c0 === 42 || c0 === 43) {
+      let trail = pos + 1;
+      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;
+      if (trail >= len) return { type: "list", skip: false, hasInlineSolve: false };
+    }
+    if (hasInline === void 0) {
+      const idx = input.indexOf("s`", pos);
+      hasInline = idx !== -1 && idx < len;
+    }
+    return { type: "expression", skip: false, hasInlineSolve: hasInline };
+  }
+  /**
+   * Classify a single line of markdown text.
+   */
+  classifyLine(lineText) {
+    const savedInput = this.input;
+    const savedLen = this.len;
+    const savedPos = this.pos;
+    this.input = lineText;
+    this.len = lineText.length;
+    this.pos = 0;
+    const result = this.classifyFromPositions(0, lineText.length);
+    this.input = savedInput;
+    this.len = savedLen;
+    this.pos = savedPos;
+    return result;
+  }
+  /**
+   * Every keyword this lexer currently recognizes, locale keywords
+   * (`pi`, `sqrt`, `convert`, ...) merged with any plugin-contributed ones
+   * from `registerVocabulary()` (e.g. a package's custom keywords), mapped to
+   * the token type they lex to. A snapshot copy, not a live reference
+   * mutating the return value has no effect on the lexer.
+   */
+  getKeywords() {
+    return Object.fromEntries(this.mergedKeywords);
+  }
+  /**
+   * Find all inline solve markers in a line with precise coordinate mapping.
+   */
+  findInlineSolves(lineText) {
+    const results = [];
+    const len = lineText.length;
+    let pos = 0;
+    while (pos < len) {
+      const sPos = lineText.indexOf("s`", pos);
+      if (sPos === -1) break;
+      const exprStart = sPos + 2;
+      let exprEnd = exprStart;
+      while (exprEnd < len) {
+        const cc = lineText.charCodeAt(exprEnd);
+        if (cc === 92 && exprEnd + 1 < len) {
+          exprEnd += 2;
+          continue;
+        }
+        if (cc === 96) break;
+        exprEnd++;
+      }
+      if (exprEnd >= len) {
+        exprEnd = len;
+      }
+      const expression = lineText.slice(exprStart, exprEnd);
+      const end = exprEnd < len ? exprEnd + 1 : exprEnd;
+      results.push({
+        start: sPos,
+        end,
+        expression,
+        columnNumber: sPos + 1
+      });
+      pos = end;
+    }
+    return results;
+  }
+  // ── Comment tokenizer ─────────────────────────────────────────────────
+  /**
+   * Reads a comment: # to end of line, or // to end of line.
+   */
+  tokenizeComment() {
+    const input = this.input;
+    const len = this.len;
+    const start = this.pos;
+    const startCol = start - this.lineStartPos + 1;
+    let pos = this.pos;
+    if (pos + 1 < len && input.charCodeAt(pos + 1) === 47) {
+      pos += 2;
+    } else {
+      pos++;
+    }
+    while (pos < len) {
+      const c0 = input.charCodeAt(pos);
+      if (c0 === 10 || c0 === 13) break;
+      pos++;
+    }
+    const text = input.slice(start, pos);
+    this.pos = pos;
+    return new LexerToken("COMMENT", tokenTypeId("COMMENT"), text, text, start, 0, this.line, startCol);
+  }
+};
+_ExpressionLexer.CHAR_CLASS = buildCharClassTable();
+var ExpressionLexer = _ExpressionLexer;
+
+export { ExpressionLexer, LexerToken };
+//# sourceMappingURL=chunk-XVWCOTR6.js.map
+//# sourceMappingURL=chunk-XVWCOTR6.js.map