solve-engine 1.2.0 → 2.0.0

package/dist/chunk-ORM7CHYZ.js

@@ -1,1531 +0,0 @@
-import { registerAllTokenTypes, tokenTypeId } from './chunk-NAWZATKT.js';
-import { getLocale } from './chunk-XBTEO4OB.js';
-import { knownUnits } from './chunk-SBUFNJVE.js';
-import { ErrorFactory } from './chunk-N7OA4WPJ.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;
-}
-function isUnicodeSpace(cc) {
-  return cc === 133 || // NEL, next line
-  cc === 160 || // no-break space
-  cc === 5760 || // ogham space mark
-  cc >= 8192 && cc <= 8202 || // en quad through hair space, incl. figure/thin space
-  cc === 8203 || // zero-width space
-  cc === 8232 || // line separator
-  cc === 8233 || // paragraph separator
-  cc === 8239 || // narrow no-break space
-  cc === 8287 || // medium mathematical space
-  cc === 12288 || // ideographic space
-  cc === 65279;
-}
-var LexerToken = class {
-  constructor(type, typeId, value, text, offset, lineBreaks, line, col, sourceEnd) {
-    this.type = type;
-    this.typeId = typeId;
-    this.value = value;
-    this.text = text;
-    this.offset = offset;
-    this.lineBreaks = lineBreaks;
-    this.line = line;
-    this.col = col;
-    this.sourceEnd = sourceEnd;
-  }
-};
-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" },
-  // ||
-  43: { 61: "PLUS_EQUALS" },
-  // +=  (compound assignment, running totals)
-  45: { 61: "MINUS_EQUALS" }
-  // -=  (neither + nor - had a two-char op before)
-  // 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;
-    // Open-bracket context stack for the current line, one entry per unclosed
-    // `(`/`[`, `true` when a comma inside it is a separator rather than a
-    // thousands group. A `[` (vector/matrix) and a CALL `(` (`rgb(255,255,255)`,
-    // preceded by an identifier) are separator contexts; a bare GROUPING `(`
-    // (`(1,000)`, preceded by an operator or the line start) is not, so a
-    // parenthesised thousands number still reads as one scalar. The number scanner
-    // consults the innermost entry. Tracked here because the flat token stream
-    // carries no nesting otherwise; reset per line, so an unbalanced bracket
-    // cannot bleed the decision into the next.
-    this.groupingStack = [];
-    // 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;
-          if (classification.contentOffset !== void 0) this.pos = classification.contentOffset;
-          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 (isUnicodeSpace(c0)) ; else 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 === 177) {
-            yield new LexerToken("PLUS_MINUS", tokenTypeId("PLUS_MINUS"), "\xB1", "\xB1", 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;
-    this.groupingStack.length = 0;
-    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;
-            this.groupingStack.length = 0;
-          } else if (c0 === 13) {
-            this.line++;
-            if (this.pos < len && input.charCodeAt(this.pos) === 10) {
-              this.pos++;
-            }
-            this.lineStartPos = this.pos;
-            this.groupingStack.length = 0;
-          }
-          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 (isUnicodeSpace(c0)) {
-            this.pos++;
-            if (c0 === 8232 || c0 === 8233 || c0 === 133) {
-              this.line++;
-              this.lineStartPos = this.pos;
-            }
-          } else 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 === 177) {
-            yield new LexerToken("PLUS_MINUS", tokenTypeId("PLUS_MINUS"), "\xB1", "\xB1", 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 (input.charCodeAt(pos) === 44 && this.groupingStack.length > 0 && this.groupingStack[this.groupingStack.length - 1]) {
-        break;
-      }
-      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 && !isUnicodeSpace(cc))) {
-      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 ─────────────────────────────────────────
-  /**
-   * Whether the `(` at `parenPos` opens a function call rather than a bare
-   * grouping, deciding whether a comma inside it is a separator or a thousands
-   * group (see {@link groupingStack}).
-   *
-   * It is a call when the nearest non-whitespace character before it belongs to
-   * the value the call applies to: a closing `)`/`]` (a call on a result), or an
-   * IDENTIFIER (`rgb(`, `vec2(`). A run of digits alone is a number, not an
-   * identifier, so `2(1,000)` is implicit multiplication over the grouping
-   * `(1,000)`, not a call, while `vec2(` and `atan2(` (identifiers that end in a
-   * digit) are calls. A `(` after an operator, a comma, or the line start is a
-   * grouping.
-   */
-  precededByCallTarget(parenPos) {
-    const input = this.input;
-    const start = this.lineStartPos;
-    let i = parenPos - 1;
-    while (i >= start && (input.charCodeAt(i) === 32 || input.charCodeAt(i) === 9)) i--;
-    if (i < start) return false;
-    const c = input.charCodeAt(i);
-    const isWord = (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 95;
-    const isAlpha = (ch) => ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 95;
-    if (!isWord(c)) return false;
-    const wordEnd = i + 1;
-    let hasAlpha = false;
-    while (i >= start) {
-      const ch = input.charCodeAt(i);
-      if (!isWord(ch)) break;
-      if (isAlpha(ch)) hasAlpha = true;
-      i--;
-    }
-    if (!hasAlpha) return false;
-    const word = input.slice(i + 1, wordEnd).toLowerCase();
-    const keywordType = this.mergedKeywords.get(word);
-    return keywordType === void 0 || keywordType === "FUNC";
-  }
-  /**
-   * 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;
-    if (c0 === 91) {
-      this.groupingStack.push(true);
-    } else if (c0 === 40) {
-      this.groupingStack.push(this.precededByCallTarget(pos));
-    } else if (c0 === 41 || c0 === 93) {
-      if (this.groupingStack.length > 0) this.groupingStack.pop();
-    }
-    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.
-   *
-   * `text` is the raw source slice, quotes included, because that is what
-   * `offset` + `text.length` has to span for a host to underline the literal.
-   * `value` is the PAYLOAD, quotes excluded, because that is what
-   * `PUSH_STRING` puts into the Value.
-   *
-   * The two used to be the same string. `"abc"` carried the five characters
-   * `"abc"` as its value, which was invisible on screen (the formatter prints
-   * the payload raw and the retained quotes landed where a display would have
-   * put them back) and not invisible anywhere else: `parseFloat('"5"')` is NaN
-   * whatever the digits say, so `"5" + 5` answered 5.
-   *
-   * An unterminated literal is an error rather than a string that happens to
-   * reach the end of the line. It used to return what it had, so `"abc` and
-   * `"abc"` were indistinguishable by payload once the quotes were stripped,
-   * which is the other half of why they are stripped here rather than later.
-   */
-  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 text = input.slice(start, pos);
-        const value = input.slice(start + 1, pos - 1);
-        this.pos = pos;
-        return new LexerToken("STRING", tokenTypeId("STRING"), value, text, 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++;
-    }
-    this.pos = pos;
-    throw ErrorFactory.parsing(
-      "UNTERMINATED_STRING",
-      `Unterminated string literal: ${input.slice(start, pos)}`,
-      { literal: input.slice(start, pos), offset: start }
-    );
-  }
-  // ── 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.
-   */
-  /**
-   * Advance past the whitespace after a list marker, and past a task-item
-   * checkbox if one follows.
-   *
-   * The checkbox is included because it is markup by the same argument the
-   * marker is, and because leaving it stopped the line dead: `- [ ] 100 + 20`
-   * lexed `[ ]` as a matrix literal and reported that a matrix cannot be
-   * empty, which tells a user writing a to-do list nothing they can act on.
-   *
-   * @param from - Offset just past the marker character.
-   * @param end - Line end, never read past.
-   * @returns Offset of the first evaluable character.
-   */
-  skipMarkerGap(from, end) {
-    const input = this.input;
-    let pos = from;
-    while (pos < end && (input.charCodeAt(pos) === 32 || input.charCodeAt(pos) === 9)) pos++;
-    if (pos + 2 < end && input.charCodeAt(pos) === 91 && input.charCodeAt(pos + 2) === 93) {
-      let after = pos + 3;
-      while (after < end && (input.charCodeAt(after) === 32 || input.charCodeAt(after) === 9)) after++;
-      if (after > pos + 3) return after;
-    }
-    return pos;
-  }
-  /**
-   * The end offset (exclusive) of a `#hex` colour literal starting at `hashPos`,
-   * or -1 if the run there is not one. A colour is `#` followed by EXACTLY 3, 4,
-   * 6 or 8 hex digits (the CSS forms `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa`) and
-   * then a boundary, not a longer word or number. This is the one predicate that
-   * carves colours out of the two things `#` otherwise means, a markdown heading
-   * at line start and a comment mid-line, and it is pure character logic so line
-   * classification stays vocabulary-independent. Examples: `#f00`, `#ff0000`,
-   * `#deadbeef` match; `# Heading` (space), `#tag`/`#todo` (non-hex letter),
-   * `#12345` (length 5), `#ff0000zz` (trailing word) do not.
-   */
-  matchHexColourEnd(hashPos, end) {
-    const input = this.input;
-    let p = hashPos + 1;
-    let n = 0;
-    while (p < end) {
-      const c = input.charCodeAt(p);
-      const isHex = c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
-      if (!isHex) break;
-      n++;
-      p++;
-    }
-    if (n !== 3 && n !== 4 && n !== 6 && n !== 8) return -1;
-    if (p < end) {
-      const c = input.charCodeAt(p);
-      const isWord = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
-      if (isWord) return -1;
-    }
-    return p;
-  }
-  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) {
-      if (this.matchHexColourEnd(pos, len) !== -1) {
-        if (hasInline === void 0) {
-          const idx = input.indexOf("s`", pos);
-          hasInline = idx !== -1 && idx < len;
-        }
-        return { type: "expression", skip: false, hasInlineSolve: hasInline };
-      }
-      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, contentOffset: this.skipMarkerGap(pos + 1, len) };
-    }
-    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, contentOffset: this.skipMarkerGap(digitPos + 1, len) };
-        }
-      }
-    }
-    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;
-    }
-    if (!hasInline) {
-      let onlySkippable = true;
-      for (let i = pos; i < len; i++) {
-        const code = input.charCodeAt(i);
-        if (code >= 128 || _ExpressionLexer.CHAR_CLASS[code] > 1 /* WHITESPACE */) {
-          onlySkippable = false;
-          break;
-        }
-      }
-      if (onlySkippable) {
-        return { type: "empty", skip: true, hasInlineSolve: false };
-      }
-    }
-    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;
-    if (input.charCodeAt(start) === 35) {
-      const hexEnd = this.matchHexColourEnd(start, len);
-      if (hexEnd !== -1) {
-        const text2 = input.slice(start, hexEnd);
-        this.pos = hexEnd;
-        return new LexerToken("HEX_COLOUR", tokenTypeId("HEX_COLOUR"), text2, text2, start, 0, this.line, startCol);
-      }
-      const first = input.charCodeAt(start + 1);
-      const isLetter = first >= 65 && first <= 90 || first >= 97 && first <= 122;
-      if (isLetter) {
-        let tagEnd = start + 2;
-        while (tagEnd < len) {
-          const c = input.charCodeAt(tagEnd);
-          const isTagChar = c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 45;
-          if (!isTagChar) break;
-          tagEnd++;
-        }
-        const name = input.slice(start + 1, tagEnd);
-        this.pos = tagEnd;
-        return new LexerToken("TAG", tokenTypeId("TAG"), name, name, start, 0, this.line, startCol);
-      }
-    }
-    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-ORM7CHYZ.js.map
-//# sourceMappingURL=chunk-ORM7CHYZ.js.map