solve-engine 1.1.1 → 1.2.0

package/dist/chunk-YJHY7CMN.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lexer/ExpressionLexer.ts"],"names":["registerAllTokenTypes","getLocale","knownUnits","tokenTypeId","ErrorFactory","input","text"],"mappings":"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","file":"chunk-YJHY7CMN.cjs","sourcesContent":["import { Token, tokenTypeId, registerAllTokenTypes } from '@solve-js/lexer/Token';\nimport { knownUnits } from '@solve-js/lexer/units';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { ErrorFactory } from '@solve-js/errors/UnifiedErrorFramework';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\n\n// Bootstrap all token types at module load\nregisterAllTokenTypes();\n\n// ── Markdown line classification (Phase B) ──────────────────────────────\n\n/** What a line is, structurally, before anything tries to evaluate it. */\nexport type MarkdownLineType =\n  | 'expression'\n  | 'prose'\n  | 'heading'\n  | 'blockquote'\n  | 'list'\n  | 'code_fence'\n  | 'math_fence'\n  | 'table'\n  | 'table_separator'\n  | 'hr'\n  | 'wikilink'\n  | 'comment'\n  | 'empty';\n\n/**\n * What a line is and whether it holds anything to evaluate.\n *\n * Produced by a character-level scan that never consults the keyword, unit or\n * operator tables, so any lexer gives the same answer for the same line. See\n * `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n */\nexport interface LineClassification {\n  /** The type of this markdown line */\n  type: MarkdownLineType;\n  /** Whether this line should be skipped (no expression evaluation) */\n  skip: boolean;\n  /** Whether the line contains inline solve markers (`s`...``) */\n  hasInlineSolve: boolean;\n  /**\n   * Offset of the first evaluable character, when structural markup precedes\n   * it. Absolute, in the same coordinates the classification was asked for,\n   * and absent when the whole line is evaluable.\n   *\n   * A list marker is markup, not arithmetic. `- 100 + 20` is a bullet holding\n   * `100 + 20`, but `-` is also a prefix operator, so without this the line\n   * evaluated as negative one hundred and answered -80: a wrong answer that\n   * looks like a right one. `*` and `+` in the same position could not even do\n   * that, one erroring and the other correct by luck, so the three markers\n   * disagreed with each other about the same document.\n   *\n   * Consumers must slice both the text and the token stream from here, or the\n   * two describe different lines.\n   */\n  contentOffset?: number;\n}\n\n/** Inline solve position with precise coordinates */\nexport interface InlineSolveSpan {\n  /** Character offset of the `s`` marker */\n  start: number;\n  /** Character offset past the closing `` ` `` */\n  end: number;\n  /** The expression text between the backticks */\n  expression: string;\n  /** 1-based column of the `s`` marker */\n  columnNumber: number;\n  /** Token index of INLINE_SOLVE_START in the line's token array (set during tokenization). */\n  startTokenIndex?: number;\n  /** Token index of closing BACKTICK_OPEN in the line's token array (set during tokenization). */\n  endTokenIndex?: number;\n}\n\n/**\n * Result from a single line processed by scanDocument().\n * Combines line classification, tokenized tokens, and inline solve spans\n * into a single structure, eliminating the need for separate classifyLine()\n * findInlineSolves(), and per-line Lexer.reset() calls.\n */\nexport interface ScanLineResult {\n  /** The raw line text (without trailing newline). */\n  text: string;\n  /** 1-based line number within the document. */\n  lineNumber: number;\n  /** Character offset of the line start within the document. */\n  startOffset: number;\n  /** Character offset of the line end (before newline). */\n  endOffset: number;\n  /** The line classification. */\n  classification: LineClassification;\n  /** Tokenized tokens (empty array if line is skipped). */\n  tokens: Token[];\n  /** Inline solve spans found in this line (empty if none). */\n  inlineSolves: InlineSolveSpan[];\n}\n\n// ── Character class constants ─────────────────────────────────────────────\n// Used as the result of the CHAR_CLASS lookup table. V8 compiles the\n// outer switch on these small integer constants into a jump table.\nconst enum CharClass {\n  SKIP       = 0,  // Invalid / control / unicode fallback\n  WHITESPACE = 1,  // space, tab, \\n, \\r\n  DIGIT      = 2,  // 0-9\n  ALPHA      = 3,  // a-z, A-Z, _\n  DOT        = 4,  // . (could be decimal point or DOT token)\n  OPERATOR   = 5,  // + - * / ^ % ( ) [ ] { } , : ; = ? & | ~ ! < >\n  QUOTE      = 6,  // \"\n  HASH       = 7,  // # (comment)\n  DOLLAR     = 8,  // $\n  POUND      = 9,  // £ (U+00A3)\n  EURO       = 10, // € (U+20AC)\n  BACKTICK   = 11, // `\n}\n\n// ── Static character class table (built once at module load) ──────────────\nfunction buildCharClassTable(): Uint8Array {\n  const table = new Uint8Array(128);\n\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) table[i] = CharClass.DIGIT;\n\n  // Uppercase A-Z\n  for (let i = 65; i <= 90; i++) table[i] = CharClass.ALPHA;\n\n  // Lowercase a-z\n  for (let i = 97; i <= 122; i++) table[i] = CharClass.ALPHA;\n\n  // Underscore\n  table[95] = CharClass.ALPHA;\n\n  // Dot\n  table[46] = CharClass.DOT;\n\n  // Whitespace\n  table[32] = CharClass.WHITESPACE;  // space\n  table[9]  = CharClass.WHITESPACE;  // tab\n  table[10] = CharClass.WHITESPACE;  // \\n\n  table[13] = CharClass.WHITESPACE;  // \\r\n\n  // Operators / punctuation\n  table[33] = CharClass.OPERATOR;  // !\n  table[37] = CharClass.OPERATOR;  // %\n  table[38] = CharClass.OPERATOR;  // &\n  table[40] = CharClass.OPERATOR;  // (\n  table[41] = CharClass.OPERATOR;  // )\n  table[42] = CharClass.OPERATOR;  // *\n  table[43] = CharClass.OPERATOR;  // +\n  table[44] = CharClass.OPERATOR;  // ,\n  table[45] = CharClass.OPERATOR;  // -\n  table[47] = CharClass.OPERATOR;  // /\n  table[58] = CharClass.OPERATOR;  // :\n  table[59] = CharClass.OPERATOR;  // ;\n  table[60] = CharClass.OPERATOR;  // <\n  table[61] = CharClass.OPERATOR;  // =\n  table[62] = CharClass.OPERATOR;  // >\n  table[63] = CharClass.OPERATOR;  // ?\n  table[91] = CharClass.OPERATOR;  // [\n  table[93] = CharClass.OPERATOR;  // ]\n  table[94] = CharClass.OPERATOR;  // ^\n  table[123] = CharClass.OPERATOR; // {\n  table[124] = CharClass.OPERATOR; // |\n  table[125] = CharClass.OPERATOR; // }\n  table[126] = CharClass.OPERATOR; // ~\n  // \"@\" was previously unclassified (defaulted to CharClass.SKIP, silently\n  // dropped before ever reaching OP_MAP). See OP_MAP's own \"@\" entry doc\n  // comment for why this is being activated now.\n  table[64] = CharClass.OPERATOR;  // @\n\n  // Other\n  table[34] = CharClass.QUOTE;    // \"\n  table[35] = CharClass.HASH;     // #\n  table[36] = CharClass.DOLLAR;   // $\n  table[96] = CharClass.BACKTICK; // `\n\n  return table;\n}\n\n/**\n * Whether a non-ASCII code point separates tokens rather than joining them.\n *\n * The CHAR_CLASS table above is 128 entries wide, so every code point past\n * ASCII falls through to one branch that reads it as part of an identifier.\n * That is right for `café`, `日本語` and emoji, and wrong for the dozen or so\n * code points that are whitespace without being ASCII whitespace. Without this,\n * a no-break space between two operands JOINED them: `1<NBSP>+<NBSP>1` lexed as\n * one identifier and reported \"Undefined variable: 1 + 1\", and a byte-order\n * mark at the head of a file did the same to its first line. Both arrive\n * constantly in pasted text, from a web page, a word processor, a spreadsheet\n * export, or a Windows editor that writes a BOM.\n *\n * The zero-width JOINERS are deliberately absent. U+200D is what holds a family\n * emoji together as one grapheme, and U+200C is its non-joining partner; both\n * bind their neighbours rather than separating them, so they stay identifier\n * characters. U+200B, the zero-width SPACE, is a separator despite being\n * invisible, which is exactly why it is worth handling: it is unreadable on\n * screen and would otherwise silently break the line it lands in.\n *\n * @param cc - A UTF-16 code unit, only meaningful for values >= 128.\n * @returns True when the character should be skipped like a space.\n */\nfunction isUnicodeSpace(cc: number): boolean {\n  return (\n    cc === 0x0085 ||                    // NEL, next line\n    cc === 0x00A0 ||                    // no-break space\n    cc === 0x1680 ||                    // ogham space mark\n    (cc >= 0x2000 && cc <= 0x200A) ||   // en quad through hair space, incl. figure/thin space\n    cc === 0x200B ||                    // zero-width space\n    cc === 0x2028 ||                    // line separator\n    cc === 0x2029 ||                    // paragraph separator\n    cc === 0x202F ||                    // narrow no-break space\n    cc === 0x205F ||                    // medium mathematical space\n    cc === 0x3000 ||                    // ideographic space\n    cc === 0xFEFF                       // byte-order mark / zero-width no-break space\n  );\n}\n\n// ── Monomorphic Token class ───────────────────────────────────────────────\n// V8 assigns a single stable HiddenClass because all properties are\n// initialized in the constructor and never added/removed afterwards.\n// This enables fast property access (inline cache hits) and allows\n// allocation in V8's nursery (cheap GC).\n// All 9 fields are always set, no optional fields, no different shapes.\n/**\n * A token, as the lexer produces it.\n *\n * A class rather than an object literal because tokens are created on every\n * keystroke and a shared hidden class keeps that path predictable for the\n * engine running it.\n */\nexport class LexerToken implements Token {\n  constructor(\n    public type: string,\n    public typeId: number,\n    public value: string,\n    public text: string,\n    public offset: number,\n    public lineBreaks: number,\n    public line: number,\n    public col: number,\n    /** See {@link Token.sourceEnd}. Set only on normalizer-fused tokens. */\n    public sourceEnd?: number,\n  ) {}\n}\n\n// ── Two-character operator lookup ─────────────────────────────────────────\n// Maps first-char → (second-char → token type). Used for operators like\n// ==, !=, >=, <=, **, <<, >>.\ninterface TwoCharOpMap {\n  [firstChar: number]: { [secondChar: number]: string };\n}\nconst TWO_CHAR_OPS: TwoCharOpMap = {\n  61: { 61: 'EQUALITY', 62: 'THEREFORE' },  // ==, => (opposite char order from >='s GTE below — no collision)\n  33: { 61: 'NEQ' },       // !=\n  62: { 61: 'GTE' },       // >=\n  60: { 61: 'LTE' },       // <=\n  38: { 38: 'LOGICAL_AND' }, // &&\n  124: { 124: 'LOGICAL_OR' }, // ||\n  43: { 61: 'PLUS_EQUALS' },  // +=  (compound assignment, running totals)\n  45: { 61: 'MINUS_EQUALS' }, // -=  (neither + nor - had a two-char op before)\n  // Note: ** is NOT a single token, the existing moo lexer emits two\n  // separate STAR tokens, and the parser consumes them that way.\n  // 42: { 42: 'EXPONENT' },  // **, disabled for moo compatibility\n};\n// Note: LSHIFT (<<) and RSHIFT (>>) are handled separately because\n// 60 is also used for LTE, so we check LTE first then LSHIFT.\n\n// ── Single-character operator lookup ──────────────────────────────────────\nconst OP_MAP: Record<number, string> = {\n  43: 'PLUS',     // +\n  45: 'MINUS',    // -\n  42: 'STAR',     // *\n  47: 'SLASH',    // /\n  94: 'CARET',    // ^\n  37: 'PERCENT',  // %\n  40: 'LPAREN',   // (\n  41: 'RPAREN',   // )\n  91: 'LBRACKET', // [\n  93: 'RBRACKET', // ]\n  123: 'LBRACE',  // {\n  125: 'RBRACE',  // }\n  44: 'COMMA',    // ,\n  58: 'COLON',    // :\n  59: 'SEMICOLON',// ;\n  61: 'EQUALS',   // =\n  63: 'QUESTION', // ?\n  33: 'BANG',     // !\n  38: 'BIT_AND',  // &\n  124: 'BIT_OR',  // |\n  60: 'LT',       // <\n  62: 'GT',       // >\n  126: 'BIT_NOT', // ~\n  // \"@\", activates the token type name already dormant-reserved for this\n  // exact purpose (see Token.ts's OVER/RATE_AT doc comment and\n  // normalizer/TokenNormalizer.ts's NON_WORD_NAMES, both of which already\n  // anticipated \"AT\" as a future \"@\" symbol token before this addition).\n  // Backs the time package's video-timecode literal's alternate fps\n  // separator (`01:02:03:04 @ 30fps`, equivalent to `... at 30fps`). See\n  // packages/time/parselets/VideoTimecodeParselet.ts.\n  64: 'AT',       // @\n};\n\n/**\n * Plugin interface for extending the ExpressionLexer with custom tokens.\n *\n * Plugins can register:\n * - `keywords`: Map identifier strings to custom token types (checked after locale keywords).\n * - `operators`: Map multi-character operator sequences to custom token types.\n * - `units`: Register additional unit identifiers (checked alongside built-in units).\n *\n * Multi-word phrase matching has been moved to the TokenNormalizer post-lexer\n * stage. To register phrase patterns, use `IEnginePackage.normalizerRules` instead.\n *\n * All registrations are additive, built-in patterns still work.\n */\nexport interface LexerVocabulary {\n  /**\n   * Keyword → tokenType mappings. Each key is a lowercase identifier that,\n   * when encountered, will emit the specified token type instead of IDENT.\n   * These are checked AFTER the locale's built-in keywordMap, so locale\n   * keywords take priority.\n   */\n  keywords?: Record<string, string>;\n\n  /**\n   * Multi-character operator → tokenType mappings. Each key is the exact\n   * character sequence (e.g., \"::\", \"->\", \"=>\") and the value is the token\n   * type to emit. Two-character operators take priority during matching.\n   * Built-in operators (==, !=, >=, <=, <<, >>) always take priority.\n   */\n  operators?: Record<string, string>;\n\n  /**\n   * Additional unit identifiers to recognize (e.g., \"gp\", \"osrs\", \"tile\").\n   * These are checked alongside the built-in `knownUnits` set.\n   */\n  units?: string[];\n\n  /**\n   * Whole-line patterns matched against the RAW line text, BEFORE any\n   * per-character tokenization begins.\n   *\n   * Every other extension point in this file (`keywords`/`operators`/\n   * `units`, plus `IEnginePackage.phrases`/`normalizerRules`) transforms\n   * a token STREAM -- they all assume the line is, at some granularity,\n   * valid Solve syntax. This hook exists for the one shape that isn't:\n   * a package whose grammar captures arbitrary free-form text terminated\n   * by a fixed marker (e.g. a natural-language query ending in `= ?`),\n   * where the text itself (\"distance to the moon\") would never tokenize\n   * or parse as a normal expression and must be captured verbatim\n   * instead -- see `packages/knowledge/` for the reference use.\n   *\n   * Each entry's `pattern` is tested (via `RegExp.exec`) against the\n   * full, untrimmed line text. If it matches AND capture group 1 is\n   * non-empty after trimming, the ENTIRE line becomes a single\n   * synthetic token of `tokenType` whose `value`/`text` is the trimmed\n   * capture group -- the character-by-character scanner never runs for\n   * that line. Patterns are tried in registration order; the first\n   * match wins. A package registering a rule here still needs a\n   * `prefixParselets` entry for `tokenType` to actually consume the\n   * resulting token.\n   *\n   * Because this bypasses tokenization entirely, a matching line can\n   * contain characters that would otherwise be lexer errors (unmatched\n   * quotes, stray symbols, ...) -- by design, since the whole point is\n   * to hand the package raw text the normal pipeline was never meant to\n   * parse.\n   */\n  rawLinePatterns?: Array<{ pattern: RegExp; tokenType: string }>;\n}\n\n// ── Expression gating (L1) ──────────────────────────────────────────────\n// Pre-computed Set of character codes that indicate an expression might\n// be present. Used by hasExpressionIndicators() to gate prose lines\n// before full tokenization.\n//\n// NOTE: Currently unused, L1 prose gating was removed from classifyFromPositions()\n// because it incorrectly skipped keyword-only lines (\"pi\"), single identifiers\n// (\"hello\"), and short alpha lines. Retained for future re-implementation with\n// keyword-awareness and proper test coverage.\nconst EXPRESSION_INDICATOR_CODES = (() => {\n  const set = new Set<number>();\n  // Digits 0-9\n  for (let i = 48; i <= 57; i++) set.add(i);\n  // Operators / punctuation\n  // Note: colon (58) is intentionally excluded, it's common in prose\n  // (e.g., \"Subject: Hello world\") and would cause false-positive\n  // expression classification. Variable assignment lines like\n  // \":myVar = 5\" are still caught by '=' and digit indicators.\n  const opCodes = [43, 45, 42, 47, 94, 37, 40, 41, 91, 93, 123, 125, 61, 60, 62, 33, 38, 124, 126, 59, 63];\n  for (const c of opCodes) set.add(c);\n  // Currency\n  set.add(36);   // $\n  set.add(0x00A3); // £\n  set.add(0x20AC); // €\n  set.add(0x00A5); // ¥\n  set.add(0x20BD); // ₽\n  set.add(0x20A9); // ₩\n  // Backtick (inline solve)\n  set.add(96);   // `\n  // Dot (could be decimal)\n  set.add(46);   // .\n  // Hash (comment, still an expression indicator)\n  set.add(35);   // #\n  return set;\n})();\n\n// ── ExpressionLexer ───────────────────────────────────────────────────────\n/**\n * Character-by-character tokenizer for expression text.\n *\n * Scans a raw line/expression string into a stream of typed tokens\n * (numbers, identifiers, operators, units, keywords, ...), handling\n * markdown-line classification (`classifyLine`), inline `` s`...` `` solve\n * spans, and package-contributed vocabulary (registered via\n * {@link registerVocabulary}/{@link unregisterVocabulary}, keywords\n * operators, and units a package wants recognized as their own token\n * types rather than falling through to generic identifiers).\n *\n * Most consumers should use the higher-level {@link Lexer} wrapper, which\n * adds streaming `next()`/`peek()` access over this class's scan results.\n */\nexport class ExpressionLexer {\n  private static readonly CHAR_CLASS = buildCharClassTable();\n  /**\n   * Configured TokenLookup from TokenClassRegistry. When set, replaces\n   * the internal keyword map and unit set with registry-built equivalents.\n   * Enables data-driven keyword/unit registration across locale keywords,\n   * provider keywords, and plugins.\n   *\n   * Set at construction time via the constructor parameter. Plugin-registered\n   * keywords/units (via registerVocabulary()) are checked alongside\n   * the configuredLookup, neither source is bypassed.\n   */\tprivate configuredLookup: TokenLookup | null = null;\n\n\t// Instance state\n  private input: string = '';\n  private pos: number = 0;\n  private len: number = 0;\n\n  // Line / column tracking (1-indexed)\n  private line: number = 1;\n  private lineStartPos: number = 0;\n\n  // Open-bracket context stack for the current line, one entry per unclosed\n  // `(`/`[`, `true` when a comma inside it is a separator rather than a\n  // thousands group. A `[` (vector/matrix) and a CALL `(` (`rgb(255,255,255)`,\n  // preceded by an identifier) are separator contexts; a bare GROUPING `(`\n  // (`(1,000)`, preceded by an operator or the line start) is not, so a\n  // parenthesised thousands number still reads as one scalar. The number scanner\n  // consults the innermost entry. Tracked here because the flat token stream\n  // carries no nesting otherwise; reset per line, so an unbalanced bracket\n  // cannot bleed the decision into the next.\n  private groupingStack: boolean[] = [];\n\n  // Keyword map: lowercase identifier → token type (locale keywords only)\n  private keywordMap: Map<string, string>;\n\n  // ── Merged lookup collections (keywordMap + pluginKeywordMap, knownUnits + pluginUnits)\n  private mergedKeywords: Map<string, string>;\n  private mergedUnits: Set<string>;\n\n  // Plugin-extensible keyword map (merged with locale keywordMap)\n  private pluginKeywordMap: Map<string, string> = new Map();\n\n  // Plugin-extensible two-char operators: firstChar → (secondChar → tokenType)\n  private pluginOperators: Map<number, Map<number, string>> = new Map();\n\n  // Plugin-extensible units (merged with knownUnits)\n  private pluginUnits: Set<string> = new Set();\t// Fast-path guards: skip plugin lookups entirely when no plugins registered\n\tprivate hasPluginOps = false;\n\n  // Locale for function-identifier lookups\n  private localeCode: string;\n  private locale: ILocale;\n\n  /**\n   * Inline solve spans collected during the most recent tokenization pass.\n   * Populated by [Symbol.iterator]() and consumed by scanDocument().\n   */\n  _inlineSolveSpans: InlineSolveSpan[] = [];\n\n  // Plugin-extensible raw-line patterns. See LexerVocabulary.rawLinePatterns.\n  private pluginRawLinePatterns: Array<{ pattern: RegExp; tokenType: string }> = [];\n\n  /**\n   * If a `rawLinePatterns` rule matches the FULL text most recently passed\n   * to {@link reset}, this holds the single synthetic token that\n   * {@link tokenizeAll} should return instead of running the\n   * character-by-character scanner. Cleared (re-evaluated) on every\n   * {@link reset} call. `null` when no plugin registered any raw-line\n   * patterns, or none matched, the overwhelmingly common case, checked\n   * with a `length === 0` guard before ever touching this field so a\n   * plugin-free lexer pays zero cost for the feature.\n   */\n  private pendingRawLineToken: Token | null = null;\n\n  /**\n   * Test `text` against every registered `rawLinePatterns` rule, in\n   * registration order. Returns a synthetic token for the first rule\n   * whose `pattern` matches AND whose capture group 1 is non-empty after\n   * trimming; returns `null` if no rule matches (the normal\n   * character-by-character scanner should run instead).\n   */\n  private matchRawLine(text: string): Token | null {\n    for (const rule of this.pluginRawLinePatterns) {\n      const m = rule.pattern.exec(text);\n      if (m && typeof m[1] === 'string') {\n        const value = m[1].trim();\n        if (value.length > 0) {\n          return new LexerToken(rule.tokenType, tokenTypeId(rule.tokenType), value, value, 0, 0, this.line, 1);\n        }\n      }\n    }\n    return null;\n  }\n\n  /** Rebuild merged keyword and unit collections after plugin registration. */\n  private rebuildMergedCollections(): void {\n    this.mergedKeywords = new Map([...this.keywordMap, ...this.pluginKeywordMap]);\n    this.mergedUnits = new Set([...knownUnits, ...this.pluginUnits]);\n  }\n\n  constructor(localeCode = 'en', lookup?: TokenLookup) {\n    this.localeCode = localeCode;\n    this.locale = getLocale(localeCode);\n    this.configuredLookup = lookup ?? null;\n    this.keywordMap = new Map<string, string>();\n    for (const [k, v] of Object.entries(this.locale.keywordMap)) {\n      this.keywordMap.set(k.toLowerCase(), v);\n    }\n    this.mergedKeywords = new Map(this.keywordMap);\n    this.mergedUnits = new Set(knownUnits);\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   *\n   * All registrations are additive, built-in patterns still work.\n   * Keywords, operators, and units from the plugin are merged\n   * with existing ones. Calling multiple times adds more entries.\n   *\n   * Note: multi-word phrases are now handled by the TokenNormalizer\n   * (see `IEnginePackage.normalizerRules`), not the lexer.\n   *\n   * Built-in tokens CANNOT be overridden. Throws a EngineError if the\n   * plugin attempts to register a keyword, operator, or unit\n   * that conflicts with a built-in one.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const [keyword, tokenType] of Object.entries(plugin.keywords)) {\n        const lower = keyword.toLowerCase();\n        // Guard: prevent overriding built-in locale keywords\n        if (this.keywordMap.has(lower)) {\n          throw ErrorFactory.config(\n            'PLUGIN_KEYWORD_COLLISION',\n            `Plugin keyword \"${keyword}\" conflicts with built-in keyword ` +\n            `(type: ${this.keywordMap.get(lower)}). Built-in keywords cannot be overridden.`,\n            { keyword, builtinType: this.keywordMap.get(lower) }\n          );\n        }\n        this.pluginKeywordMap.set(lower, tokenType);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      this.hasPluginOps = true;\n      for (const [chars, tokenType] of Object.entries(plugin.operators)) {\n        // Only support 2-char operators for the fast path\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n\n          // Guard: prevent overriding built-in two-char operators (==, !=, >=, <=)\n          const builtInSecondMap = TWO_CHAR_OPS[first];\n          if (builtInSecondMap && builtInSecondMap[second] !== undefined) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: ${builtInSecondMap[second]}). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: builtInSecondMap[second] }\n            );\n          }\n          // Guard: prevent overriding LSHIFT (<<) and RSHIFT (>>)\n          if (first === 60 && second === 60) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: LSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'LSHIFT' }\n            );\n          }\n          if (first === 62 && second === 62) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in operator ` +\n              `(type: RSHIFT). Built-in operators cannot be overridden.`,\n              { operator: chars, builtinType: 'RSHIFT' }\n            );\n          }\n          // Guard: prevent overriding comment sequences (//)\n          if (first === 47 && second === 47) {\n            throw ErrorFactory.config(\n              'PLUGIN_OPERATOR_COLLISION',\n              `Plugin operator \"${chars}\" conflicts with built-in comment sequence. ` +\n              `Comment sequences cannot be overridden.`,\n              { operator: chars, builtinType: 'COMMENT' }\n            );\n          }\n\n          let inner = this.pluginOperators.get(first);\n          if (!inner) {\n            inner = new Map();\n            this.pluginOperators.set(first, inner);\n          }\n          inner.set(second, tokenType);\n        }\n      }\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        // Guard: prevent overriding built-in units\n        if (knownUnits.has(unit)) {\n          throw ErrorFactory.config(\n            'PLUGIN_UNIT_COLLISION',\n            `Plugin unit \"${unit}\" conflicts with a built-in unit. ` +\n            `Built-in units cannot be overridden.`,\n            { unit }\n          );\n        }\n        this.pluginUnits.add(unit);\n      }\n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      this.pluginRawLinePatterns.push(...plugin.rawLinePatterns);\n    }\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   *\n   * This is the inverse of registerVocabulary(). All keywords, operators,\n   * and units registered by the plugin are removed. After\n   * unregistration, those tokens will revert to their default behavior\n   * (e.g., keywords become IDENT, operators become ERROR).\n   *\n   * Calling unregisterVocabulary with a plugin that was never registered\n   * is safe, it simply has no effect.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    if (plugin.keywords) {\n      for (const keyword of Object.keys(plugin.keywords)) {\n        this.pluginKeywordMap.delete(keyword.toLowerCase());\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.operators) {\n      for (const chars of Object.keys(plugin.operators)) {\n        if (chars.length === 2) {\n          const first = chars.charCodeAt(0);\n          const second = chars.charCodeAt(1);\n          const inner = this.pluginOperators.get(first);\n          if (inner) {\n            inner.delete(second);\n            if (inner.size === 0) {\n              this.pluginOperators.delete(first);\n            }\n          }\n        }\n      }\n      this.hasPluginOps = this.pluginOperators.size > 0;\n    }\n\n    if (plugin.units) {\n      for (const unit of plugin.units) {\n        this.pluginUnits.delete(unit);\n      }\n      \n      this.rebuildMergedCollections();\n    }\n\n    if (plugin.rawLinePatterns) {\n      const toRemove = new Set(plugin.rawLinePatterns);\n      this.pluginRawLinePatterns = this.pluginRawLinePatterns.filter((r) => !toRemove.has(r));\n    }\n  }\n\n  reset(input: string): void {\n    this.input = input;\n    this.pos = 0;\n    this.len = input.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n    this.pendingRawLineToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(input) : null;\n  }\n\n  /**\n   * Scan a full document text in a single pass, classifying each line and\n   * tokenizing non-skipped lines.\n   *\n   * Replaces the separate classifyLine() + findInlineSolves() + per-line\n   * reset() + tokenizeAll() pattern with a single character-by-character\n   * walk through the entire document. Key benefits:\n   *\n   * - **Single reset()**: `this.pos`, `this.len`, `this.line`, and\n   *   `this.lineStartPos` are set once for the whole document, not per-line.\n   * - **Single classification**: classifyLine() runs once per line inline;\n   *   skipped lines are jumped over without tokenization.\n   * - **Shared tokenization**: Non-skipped lines are tokenized using the\n   *   existing state machine, yielding Token[] without per-line reset().\n   * - **Inline solve detection**: findInlineSolves() is called only for\n   *   lines that classifyLine() marks as having inline solves.\n   *\n   * Tokenization is scoped to each line by temporarily restricting\n   * `this.len` to the line end position, so the [Symbol.iterator]\n   * generator naturally stops at the line boundary. After tokenization,\n   * `this.len` is restored and `this.pos` advances past the newline.\n   *\n   * @param text The full document text (with newlines).\n   * @returns Array of ScanLineResult, one per line, in document order.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    this.input = text;\n    this.pos = 0;\n    this.len = text.length;\n    this.line = 1;\n    this.lineStartPos = 0;\n\n    const results: ScanLineResult[] = [];\n    const input = this.input;\n    const docLen = this.len;\n\n    while (this.pos < docLen) {\n      const lineStart = this.pos;\n\n      // ── Find end of current line (newline boundary) ───────────────\n      let lineEnd = this.pos;\n      while (lineEnd < docLen) {\n        const cc = input.charCodeAt(lineEnd);\n        if (cc === 10 || cc === 13) break;  // \\n or \\r\n        lineEnd++;\n      }\n\n      const lineNumber = this.line;\n\n      // ── Classify the line ─────────────────────────────────────────\n      // Uses classifyFromPositions() to read from this.input directly\n      // avoids allocating a substring and keeps classification reads\n      // within the same memory region as tokenization.\n      const classification = this.classifyFromPositions(lineStart, lineEnd);\n\n      // ── Slice line text for ScanLineResult.text ────────────────\n      // Hoisted above tokenization (rather than after, as originally) so the\n      // raw-line-pattern check below can test the exact substring a plugin\n      // registered via `LexerVocabulary.rawLinePatterns`. See reset()/\n      // tokenizeAll() for the single-expression-string equivalent of this\n      // same check.\n      const lineText = input.slice(lineStart, lineEnd);\n\n      // ── Tokenize non-skipped lines ────────────────────────────────\n      let tokens: Token[] = [];\n      if (!classification.skip) {\n        const rawToken = this.pluginRawLinePatterns.length > 0 ? this.matchRawLine(lineText) : null;\n        if (rawToken) {\n          tokens = [rawToken];\n        } else {\n          // Scope tokenization to just this line by temporarily restricting len.\n          // The [Symbol.iterator]() generator captures `this.len` at call time,\n          // so creating the iterator AFTER setting this.len = lineEnd ensures\n          // tokenization stops at the line boundary. After tokenization,\n          // this.pos will be at lineEnd (the newline position).\n          const savedLen = this.len;\n          this.len = lineEnd;\n          // Start past any structural marker, so the marker never becomes a\n          // token. Token source offsets stay absolute, so everything\n          // downstream (spans, highlighting, inline solves) still lines up\n          // with the raw document.\n          if (classification.contentOffset !== undefined) this.pos = classification.contentOffset;\n          tokens = Array.from(this);\n          this.len = savedLen;\n          // this.pos is now at lineEnd, advance past newline below\n        }\n      }\n\n      // ── Detect inline solves ──────────────────────────────────────\n      // Two data sources are merged:\n      //   1. _inlineSolveSpans, token indices collected inline during\n      //      [Symbol.iterator](). Provides correct startTokenIndex /\n      //      endTokenIndex. Also handles \\` escape (skips the pair\n      //      instead of closing the span early).\n      //   2. findInlineSolves(), character-level string scan for\n      //      expression text. Still needed because token-based\n      //      reconstruction loses whitespace (the lexer skips spaces),\n      //      which breaks multi-word expressions like\n      //      \"2 weeks in days\" → \"2weeksindays\" (wrong tokenization).\n      let inlineSolves: InlineSolveSpan[] = [];\n      if (classification.hasInlineSolve) {\n        if (!classification.skip && tokens.length > 0) {\n          const charSpans = this.findInlineSolves(lineText);\n          inlineSolves = this._inlineSolveSpans.map((span, i) => ({\n            start: charSpans[i]?.start ?? 0,\n            end: charSpans[i]?.end ?? 0,\n            expression: charSpans[i]?.expression ?? '',\n            columnNumber: charSpans[i]?.columnNumber ?? span.columnNumber,\n            startTokenIndex: span.startTokenIndex,\n            endTokenIndex: span.endTokenIndex,\n          }));\n        } else {\n          // Skipped lines weren't tokenized, fall back to string scan\n          inlineSolves = this.findInlineSolves(lineText);\n        }\n      }\n\n      results.push({\n        text: lineText,\n        lineNumber,\n        startOffset: lineStart,\n        endOffset: lineEnd,\n        classification,\n        tokens,\n        inlineSolves,\n      });\n\n      // ── Advance past newline ─────────────────────────────────────\n      this.pos = lineEnd;\n      if (this.pos < docLen) {\n        const nlChar = input.charCodeAt(this.pos);\n        if (nlChar === 13) {  // \\r\n          this.pos++;\n          if (this.pos < docLen && input.charCodeAt(this.pos) === 10) {\n            this.pos++;  // skip \\n in \\r\\n\n          }\n        } else if (nlChar === 10) {  // \\n\n          this.pos++;\n        }\n      }\n      this.line++;\n      this.lineStartPos = this.pos;\n    }\n\n    return results;\n  }\n\n  /**\n   * Tokenize an expression string into an array of Tokens.\n   *\n   * Delegates to the lazy [Symbol.iterator]() generator and collects all\n   * yielded tokens via Array.from(). For memory-sensitive use cases, prefer\n   * iterating the lexer directly with for...of to avoid array allocation.\n   *\n   * Optimizations:\n   *  - CHAR_CLASS jump table (Uint8Array) → switch on small integers\n   *  - Direct character-code dispatch (c0 cached pattern)\n   *  - Mathematical digit parsing (integer math, not slice+parseFloat)\n   *  - Inline operator tokenizer with two-char peek-ahead\n   *  - Whitespace eliminated in-lexer (never emitted)\n   *  - 0-char and 1-char fast paths\n   */\n  tokenizeAll(): Token[] {\n    if (this.pendingRawLineToken) {\n      this._inlineSolveSpans = [];\n      return [this.pendingRawLineToken];\n    }\n    return Array.from(this);\n  }\n\n  // ── Lazy iterator ─────────────────────────────────────────────────────\n  /**\n   * Lazy token-by-token generator. Yields each token without allocating an\n   * intermediate Token[] array. Supports for...of and spread usage.\n   *\n   * Usage:\n   *   for (const t of lexer) { ... }  // lazy, no array allocation\n   *   const tokens = [...lexer];       // materializes via spread\n   *   const tokens = lexer.tokenizeAll(); // materializes via Array.from()\n   *\n   * IMPORTANT: This generator captures `this.len` ONCE at creation time\n   * (const len = this.len). `scanDocument()` relies on this behavior to\n   * scope tokenization to a single line by temporarily restricting\n   * `this.len` to the line end position before creating the iterator.\n   * Do NOT refactor to re-read `this.len` mid-loop without also updating\n   * `scanDocument()`.\n   */\n  *[Symbol.iterator](): Generator<Token, void, undefined> {\n    const len = this.len;\n\n    // ── 0-char fast path ────────────────────────────────────────────────\n    if (len === 0) { this._inlineSolveSpans = []; return; }\n\n    // Inline solve tracking state, collected inline during tokenization\n    let tokenIndex = 0;\n    let openSpan: { startTokenIndex: number; startColumn: number } | null = null;\n    const collectedSpans: InlineSolveSpan[] = [];\n\n    // ── 1-char fast path ────────────────────────────────────────────────\n    if (len === 1) {\n      const c0 = this.input.charCodeAt(0);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      switch (cc) {\n        case CharClass.DIGIT:\n        case CharClass.DOT:\n          yield new LexerToken('NUMBER', tokenTypeId('NUMBER'), this.input, this.input, 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.ALPHA: {\n          const input = this.input;\n          const identLower = input.toLowerCase();\n          // Use pre-merged collections (built-in + plugin), single lookup each\n          if (this.mergedUnits.has(input)) {\n            yield new LexerToken('UNIT', tokenTypeId('UNIT'), input, input, 0, 0, 1, 1);\n          } else {\n            const kwType = this.mergedKeywords.get(identLower);\n            if (kwType) {\n              yield new LexerToken(kwType, tokenTypeId(kwType), input, input, 0, 0, 1, 1);\n            } else {\n              yield new LexerToken('IDENT', tokenTypeId('IDENT'), input, input, 0, 0, 1, 1);\n            }\n          }\n          tokenIndex++;\n          break;\n        }\n\n        case CharClass.OPERATOR: {\n          const opType = OP_MAP[c0];\n          if (opType) {\n            yield new LexerToken(opType, tokenTypeId(opType), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n\n        case CharClass.QUOTE:\n          // Delegate to tokenizeString for correctness (handles unterminated)\n          this.pos = 0;\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        case CharClass.HASH:\n          // Delegate to tokenizeComment for correctness\n          this.pos = 0;\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        case CharClass.DOLLAR:\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        case CharClass.BACKTICK:\n          // s` is 2 chars, openSpan can never be set in the 1-char fast path\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', 0, 0, 1, 1);\n          tokenIndex++;\n          break;\n\n        default: {\n          // CharClass.SKIP, includes non-ASCII characters (code >= 128)\n          if (isUnicodeSpace(c0)) {\n            // A line holding nothing but a no-break space or a byte-order mark\n            // holds no expression, exactly as a line holding one space does.\n            // Yielding an IDENT for it made it an undefined variable instead.\n          } else if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00B1) {  // U+00B1 plus-minus sign, the uncertainty operator\n            yield new LexerToken('PLUS_MINUS', tokenTypeId('PLUS_MINUS'), '\\u00B1', '\\u00B1', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', 0, 0, 1, 1);\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility\n            yield new LexerToken('IDENT', tokenTypeId('IDENT'), this.input, this.input, 0, 0, 1, 1);\n            tokenIndex++;\n          }\n          break;\n        }\n      }\n      this._inlineSolveSpans = collectedSpans;\n      return;\n    }\n\n    const input = this.input;\n    // Fresh nesting stack for this pass (see the field's doc).\n    this.groupingStack.length = 0;\n\n    // ── Main tokenization loop ──────────────────────────────────────────\n    while (this.pos < len) {\n      const c0 = input.charCodeAt(this.pos);\n      const cc = ExpressionLexer.CHAR_CLASS[c0] ?? CharClass.SKIP;\n\n      // ── Escaped backtick inside inline solve ────────────────────────\n      // \\` is treated as an escaped backtick, skip both characters\n      // without closing the inline solve span. Without this, the\n      // backtick would close the span early, producing wrong expression\n      // text for expressions like s`hello \\` world`.\n      if (openSpan && c0 === 92 && this.pos + 1 < len && input.charCodeAt(this.pos + 1) === 96) {\n        this.pos += 2;  // skip \\ and `\n        continue;\n      }\n\n      switch (cc) {\n        // ── Whitespace, skip entirely, track newlines ────────────────\n        case CharClass.WHITESPACE:\n          this.pos++;\n          if (c0 === 10) {  // \\n\n            this.line++;\n            this.lineStartPos = this.pos;\n            this.groupingStack.length = 0;  // each line groups thousands on its own\n          } else if (c0 === 13) {  // \\r\n            this.line++;\n            if (this.pos < len && input.charCodeAt(this.pos) === 10) {\n              this.pos++;  // skip \\n in \\r\\n\n            }\n            this.lineStartPos = this.pos;\n            this.groupingStack.length = 0;\n          }\n          break;\n\n        // ── Digit, inline number tokenizer ───────────────────────────\n        case CharClass.DIGIT:\n          yield this.tokenizeNumber();\n          tokenIndex++;\n          break;\n\n        // ── Alpha / underscore, identifier or keyword ────────────────\n        case CharClass.ALPHA: {\n          const token = this.tokenizeIdentifier();\n          if (token.type === 'INLINE_SOLVE_START') {\n            openSpan = { startTokenIndex: tokenIndex, startColumn: token.col };\n          }\n          yield token;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Dot, could be decimal (.5) or DOT token ─────────────────\n        case CharClass.DOT:\n          if (this.pos + 1 < len) {\n            const nextCc = ExpressionLexer.CHAR_CLASS[input.charCodeAt(this.pos + 1)] ?? CharClass.SKIP;\n            if (nextCc === CharClass.DIGIT) {\n              yield this.tokenizeNumber();\n            } else {\n              const col = this.pos - this.lineStartPos + 1;\n              yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n              this.pos++;\n            }\n          } else {\n            const col = this.pos - this.lineStartPos + 1;\n            yield new LexerToken('DOT', tokenTypeId('DOT'), '.', '.', this.pos, 0, this.line, col);\n            this.pos++;\n          }\n          tokenIndex++;\n          break;\n\n        // ── Operator / punctuation ────────────────────────────────────\n        case CharClass.OPERATOR:\n          yield this.tokenizeOperator();\n          tokenIndex++;\n          break;\n\n        // ── String literal ────────────────────────────────────────────\n        case CharClass.QUOTE:\n          yield this.tokenizeString();\n          tokenIndex++;\n          break;\n\n        // ── Comment (# or //) ─────────────────────────────────────────\n        case CharClass.HASH:\n          yield this.tokenizeComment();\n          tokenIndex++;\n          break;\n\n        // ── Dollar sign $ ─────────────────────────────────────────────\n        case CharClass.DOLLAR: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('DOLLAR', tokenTypeId('DOLLAR'), '$', '$', this.pos, 0, this.line, col);\n          this.pos++;\n          tokenIndex++;\n          break;\n        }\n\n        // ── Backtick ` ───────────────────────────────────────────────\n        case CharClass.BACKTICK: {\n          const col = this.pos - this.lineStartPos + 1;\n          yield new LexerToken('BACKTICK_OPEN', tokenTypeId('BACKTICK_OPEN'), '`', '`', this.pos, 0, this.line, col);\n          this.pos++;\n          if (openSpan) {\n            const span = openSpan;  // narrow for TS\n            collectedSpans.push({\n              start: 0, end: 0, expression: '',\n              columnNumber: span.startColumn,\n              startTokenIndex: span.startTokenIndex,\n              endTokenIndex: tokenIndex,\n            });\n            openSpan = null;\n          }\n          tokenIndex++;\n          break;\n        }\n\n        // ── Non-ASCII characters ─────────────────────────────────────\n        default: {\n          const col = this.pos - this.lineStartPos + 1;\n          if (isUnicodeSpace(c0)) {\n            // Separates its neighbours instead of joining them. See\n            // isUnicodeSpace()'s doc comment: this branch is why a sum pasted\n            // out of a web page or a spreadsheet evaluates at all.\n            this.pos++;\n            if (c0 === 0x2028 || c0 === 0x2029 || c0 === 0x0085) {\n              // The three that are line breaks rather than spaces, tracked the\n              // same way \"\\n\" is above so a later token reports its own line.\n              this.line++;\n              this.lineStartPos = this.pos;\n            }\n          } else if (c0 === 0x00D7) {  // × → STAR\n            yield new LexerToken('STAR', tokenTypeId('STAR'), '\\u00D7', '\\u00D7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00F7) {  // ÷ → SLASH\n            yield new LexerToken('SLASH', tokenTypeId('SLASH'), '\\u00F7', '\\u00F7', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00B1) {  // U+00B1 plus-minus sign, the uncertainty operator\n            yield new LexerToken('PLUS_MINUS', tokenTypeId('PLUS_MINUS'), '\\u00B1', '\\u00B1', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x2260) {  // ≠ → NEQ\n            yield new LexerToken('NEQ', tokenTypeId('NEQ'), '\\u2260', '\\u2260', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A3) {  // £\n            yield new LexerToken('POUND', tokenTypeId('POUND'), '\\u00A3', '\\u00A3', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AC) {  // €\n            yield new LexerToken('EURO', tokenTypeId('EURO'), '\\u20AC', '\\u20AC', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x00A5) {  // ¥\n            yield new LexerToken('YEN', tokenTypeId('YEN'), '¥', '¥', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BD) {  // ₽\n            yield new LexerToken('RUBLE', tokenTypeId('RUBLE'), '₽', '₽', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A9) {  // ₩\n            yield new LexerToken('WON', tokenTypeId('WON'), '₩', '₩', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B9) {  // ₹ (Indian rupee) — see uom/CurrencyAliases.ts\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₹', '₹', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20BA) {  // ₺ (Turkish lira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₺', '₺', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B4) {  // ₴ (Ukrainian hryvnia)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₴', '₴', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AA) {  // ₪ (Israeli new shekel)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₪', '₪', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20AB) {  // ₫ (Vietnamese dong)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₫', '₫', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20A6) {  // ₦ (Nigerian naira)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₦', '₦', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 === 0x20B1) {  // ₱ (Philippine peso)\n            yield new LexerToken('CURRENCY_SYMBOL', tokenTypeId('CURRENCY_SYMBOL'), '₱', '₱', this.pos, 0, this.line, col);\n            this.pos++;\n            tokenIndex++;\n          } else if (c0 >= 128) {\n            // Unknown unicode, treat as IDENT for forward compatibility.\n            // tokenizeIdentifier() now includes cc >= 128 in its reading loop,\n            // so this properly advances past all consecutive Unicode chars.\n            yield this.tokenizeIdentifier();\n            tokenIndex++;\n          } else {\n            // Unknown ASCII, silently skip\n            this.pos++;\n          }\n          break;\n        }\n      }\n    }\n    this._inlineSolveSpans = collectedSpans;\n  }\n\n  // ── Inline number tokenizer ────────────────────────────────────────────\n  /**\n   * Character-by-character number parsing.\n   *\n   * Supports: integers, floats, scientific notation (1.5e10, 1.5e-10),\n   * hex (0xFF), binary (0b1010), octal (0o17), BigInt suffix (123n),\n   * thousands separators (1,234 or 1.234.567).\n   *\n   * Returns a LexerToken and advances `this.pos` past the number.\n   */\n  private tokenizeNumber(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // ── Hex literal: 0x / 0X ───────────────────────────────────────────\n    if (input.charCodeAt(pos) === 48 && pos + 1 < len) {\n      const next = input.charCodeAt(pos + 1);\n      if (next === 0x78 || next === 0x58) {  // 'x' or 'X'\n        pos += 2;\n        while (\n          pos < len &&\n          ((cc = input.charCodeAt(pos)),\n            (cc >= 48 && cc <= 57) || (cc >= 65 && cc <= 70) || (cc >= 97 && cc <= 102))\n        ) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Binary literal: 0b / 0B ─────────────────────────────────────\n      if (next === 0x62 || next === 0x42) {  // 'b' or 'B'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc === 48 || cc === 49)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n      // ── Octal literal: 0o / 0O ───────────────────────────────────────\n      if (next === 0x6F || next === 0x4F) {  // 'o' or 'O'\n        pos += 2;\n        while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 55)) {\n          pos++;\n        }\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    let hasIntPart = false;\n\n    // ── Integer part ───────────────────────────────────────────────────\n    while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n      hasIntPart = true;\n      pos++;\n    }\n\n    // ── Thousands separators, coalesce with digits ────────────────────\n    while (hasIntPart && pos < len && (input.charCodeAt(pos) === 44 || input.charCodeAt(pos) === 46)) {\n      // A comma inside a call or bracket is an argument/element separator, not a\n      // thousands group: `rgb(255,255,255)` is three numbers and `[100,200,300]`\n      // a three-element vector, not `255255255`/`100200300`. A comma in a bare\n      // grouping paren (`(1,000)`) still groups thousands, and so does a\n      // top-level comma (`1,000,000`). The innermost bracket's context decides;\n      // the `.` grouping form is context-free and unaffected. See\n      // {@link groupingStack}.\n      if (\n        input.charCodeAt(pos) === 44 &&\n        this.groupingStack.length > 0 &&\n        this.groupingStack[this.groupingStack.length - 1]\n      ) {\n        break;\n      }\n      if (pos + 4 <= len) {\n        const d1 = input.charCodeAt(pos + 1);\n        const d2 = input.charCodeAt(pos + 2);\n        const d3 = input.charCodeAt(pos + 3);\n        // A genuine thousands group is always exactly 3 digits, followed\n        // by either another separator, or a non-digit (end of number,\n        // operator, unit, EOF), never a 4th consecutive digit. Without\n        // this check, a plain decimal fraction with 4+ digits after the\n        // point, e.g. \"0.0001\", had its first 3 fractional digits\n        // misread as a \".\" thousands-group, silently truncating the\n        // number to \"0.000\" and leaving the remaining digit(s) as a\n        // separate, unrelated NUMBER token right after it (so\n        // \"0.0001 BTC to USD\" tokenized as \"0.000\", \"1\", \"BTC\", \"to\",\n        // \"USD\", two number literals instead of one, and evaluated to\n        // a bare 0 instead of a real BTC quantity).\n        const d4 = pos + 4 < len ? input.charCodeAt(pos + 4) : -1;\n        const isGroupOfExactlyThree = !(d4 >= 48 && d4 <= 57);\n        if (\n          d1 >= 48 && d1 <= 57 &&\n          d2 >= 48 && d2 <= 57 &&\n          d3 >= 48 && d3 <= 57 &&\n          isGroupOfExactlyThree\n        ) {\n          pos += 4;\n          hasIntPart = true;\n          continue;\n        }\n      }\n      break;\n    }\n\n    // ── Decimal part (.xxx) ───────────────────────────────────────────\n    let hasDecimal = false;\n    if (pos < len && input.charCodeAt(pos) === 46) {\n      if (pos + 1 < len) {\n        const nextCc = input.charCodeAt(pos + 1);\n        if (nextCc >= 48 && nextCc <= 57) {\n          hasDecimal = true;\n          pos++;\n          while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n            pos++;\n          }\n        }\n      }\n    }\n\n    // ── Exponent (e / E [+-]? \\n+) ────────────────────────────────────\n    let hasExponent = false;\n    if (pos < len) {\n      const ec = input.charCodeAt(pos);\n      if (ec === 0x65 || ec === 0x45) {  // 'e' or 'E'\n        if (pos + 1 < len) {\n          const next = input.charCodeAt(pos + 1);\n          if (\n            (next >= 48 && next <= 57) ||\n            next === 43 || next === 45  // + or -\n          ) {\n            hasExponent = true;\n            pos++;\n            if (next === 43 || next === 45) pos++;\n            while (pos < len && ((cc = input.charCodeAt(pos)), cc >= 48 && cc <= 57)) {\n              pos++;\n            }\n          }\n        }\n      }\n    }\n\n    // ── BigInt suffix check ────────────────────────────────────────────\n    if (pos < len && input.charCodeAt(pos) === 110) {  // 'n'\n      if (hasIntPart && !hasDecimal && !hasExponent) {\n        pos++;\n        const text = input.slice(start, pos);\n        this.pos = pos;\n        return new LexerToken('BIGINT', tokenTypeId('BIGINT'), text, text, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Emit NUMBER token ──────────────────────────────────────────────\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('NUMBER', tokenTypeId('NUMBER'), text, text, start, 0, this.line, startCol);\n  }\n\n  // ── Inline identifier / keyword tokenizer ──────────────────────────────\n  /**\n   * Reads [a-zA-Z_][a-zA-Z0-9_]* and resolves to:\n   *   - A unit type (via knownUnits, case-sensitive)\n   *   - A keyword type (via locale keywordMap, case-insensitive)\n   *   - IDENT if none of the above\n   *\n   * Multi-word phrases (e.g., \"to the power of\") are handled by the\n   * TokenNormalizer post-lexer pass, not the lexer.\n   */\n  private tokenizeIdentifier(): Token {\n    const input = this.input;\n    const len = this.len;\n    let pos = this.pos;\n    const start = pos;\n    const startCol = pos - this.lineStartPos + 1;\n    let cc: number;\n\n    // Read [a-zA-Z0-9_]* plus any Unicode (>= 128) including emoji surrogate pairs.\n    // Without this, non-ASCII characters cause an infinite loop: the default case\n    // calls tokenizeIdentifier(), the while loop doesn't match the Unicode char,\n    // pos never advances, and the outer loop re-reads the same char forever.\n    while (\n      pos < len &&\n      ((cc = input.charCodeAt(pos)),\n        (cc >= 48 && cc <= 57) ||   // 0-9\n        (cc >= 65 && cc <= 90) ||   // A-Z\n        (cc >= 97 && cc <= 122) ||  // a-z\n        cc === 95 ||                 // _\n        (cc >= 128 && !isUnicodeSpace(cc)))  // Unicode (accented chars, emoji, etc.), but not Unicode whitespace\n    ) {\n      pos++;\n    }\n\n    const identText = input.slice(start, pos);\n    const identLower = identText.toLowerCase();\n\n    // ── Inline solve marker: s` (lowercase 's' followed by backtick) ──\n    if (identLower === 's' && pos < len && input.charCodeAt(pos) === 96) {\n      pos++;\n      this.pos = pos;\n      const fullText = input.slice(start, pos);\n      return new LexerToken('INLINE_SOLVE_START', tokenTypeId('INLINE_SOLVE_START'), fullText, fullText, start, 0, this.line, startCol);\n    }\n\n    // ── Unit lookup (case-sensitive)\n    const isKnownUnit = this.mergedUnits.has(identText);\n    if (isKnownUnit) {\n      if (!this.isFollowedByLParen(pos)) {\n        this.pos = pos;\n        return new LexerToken('UNIT', tokenTypeId('UNIT'), identText, identText, start, 0, this.line, startCol);\n      }\n    }\n\n    // ── Keyword lookup (case-insensitive)\n    const localeKwType = this.mergedKeywords.get(identLower);\n    if (localeKwType) {\n      this.pos = pos;\n      return new LexerToken(localeKwType, tokenTypeId(localeKwType), identText, identText, start, 0, this.line, startCol);\n    }\n\n    // ── Fall through: emit IDENT\n    // Multi-word phrases are now handled by the TokenNormalizer post-lexer pass,\n    // which keeps the lexer slim and focused on single-token production.\n    this.pos = pos;\n    return new LexerToken('IDENT', tokenTypeId('IDENT'), identText, identText, start, 0, this.line, startCol);\n  }\n\n  /**\n   * Peek past in-expression whitespace (space, tab) from `pos` to check\n   * if the next significant character is '('.\n   */\n  private isFollowedByLParen(pos: number): boolean {\n    const len = this.len;\n    let lookPos = pos;\n    while (lookPos < len) {\n      const cc = this.input.charCodeAt(lookPos);\n      if (cc === 40) return true;\n      if (cc !== 32 && cc !== 9) break;\n      lookPos++;\n    }\n    return false;\n  }\n\n  // ── Inline operator tokenizer ─────────────────────────────────────────\n  /**\n   * Whether the `(` at `parenPos` opens a function call rather than a bare\n   * grouping, deciding whether a comma inside it is a separator or a thousands\n   * group (see {@link groupingStack}).\n   *\n   * It is a call when the nearest non-whitespace character before it belongs to\n   * the value the call applies to: a closing `)`/`]` (a call on a result), or an\n   * IDENTIFIER (`rgb(`, `vec2(`). A run of digits alone is a number, not an\n   * identifier, so `2(1,000)` is implicit multiplication over the grouping\n   * `(1,000)`, not a call, while `vec2(` and `atan2(` (identifiers that end in a\n   * digit) are calls. A `(` after an operator, a comma, or the line start is a\n   * grouping.\n   */\n  private precededByCallTarget(parenPos: number): boolean {\n    const input = this.input;\n    const start = this.lineStartPos;\n    let i = parenPos - 1;\n    while (i >= start && (input.charCodeAt(i) === 32 || input.charCodeAt(i) === 9)) i--;  // skip spaces/tabs\n    if (i < start) return false;  // line start (or only whitespace before): a grouping\n    const c = input.charCodeAt(i);\n    const isWord = (ch: number): boolean =>\n      (ch >= 48 && ch <= 57) || (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch === 95;\n    const isAlpha = (ch: number): boolean =>\n      (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch === 95;\n    // A non-word char before \"(\" (an operator, a comma, a `)`/`]`, or the line\n    // start) is a grouping. There is no curried/first-class call or index-\n    // application in this grammar, so `)(` and `](` are implicit multiplication\n    // over a grouping (`(2)(1,000)` is `2 * 1000`), not a call. The only call\n    // targets are an identifier or a FUNC keyword, handled below.\n    if (!isWord(c)) return false;\n    // Walk back over the whole word run. A bare number run (`2(1,000)`) is\n    // implicit multiplication over a grouping, not a call.\n    const wordEnd = i + 1;\n    let hasAlpha = false;\n    while (i >= start) {\n      const ch = input.charCodeAt(i);\n      if (!isWord(ch)) break;\n      if (isAlpha(ch)) hasAlpha = true;\n      i--;\n    }\n    if (!hasAlpha) return false;\n    // The word is an identifier. A KEYWORD that is not a function name is a\n    // word-operator or connective (`mod`, `xor`, `and`, `to`, `in`) or a\n    // constant (`pi`, `e`), and the `(...)` after it is a grouped operand, so\n    // its comma still groups thousands (`100 mod (1,000)` is `100 mod 1000`).\n    // A plain identifier (a function like `rgb`, or a variable) or a function\n    // keyword (`sqrt`, `max`) is a real call target, where the comma separates.\n    const word = input.slice(i + 1, wordEnd).toLowerCase();\n    const keywordType = this.mergedKeywords.get(word);\n    return keywordType === undefined || keywordType === \"FUNC\";\n  }\n\n  /**\n   * Reads an operator/punctuation token.\n   * Handles two-char operators (==, !=, >=, <=, **) and the special\n   * cases << (LSHIFT) and >> (RSHIFT).\n   */\n  private tokenizeOperator(): Token {\n    const input = this.input;\n    const pos = this.pos;\n    const col = pos - this.lineStartPos + 1;\n    const c0 = input.charCodeAt(pos);\n    const len = this.len;\n\n    // ── Two-character operators ────────────────────────────────────────\n    if (pos + 1 < len) {\n      const c1 = input.charCodeAt(pos + 1);\n\n      // ==, !=, >=, <=\n      const secondMap = TWO_CHAR_OPS[c0];\n      if (secondMap) {\n        const twoCharType = secondMap[c1];\n        if (twoCharType) {\n          const text = input.slice(pos, pos + 2);\n          this.pos = pos + 2;\n          return new LexerToken(twoCharType, tokenTypeId(twoCharType), text, text, pos, 0, this.line, col);\n        }\n      }\n\n      // // comment\n      if (c0 === 47 && c1 === 47) {\n        let commentPos = pos + 2;\n        while (commentPos < len) {\n          const cc = input.charCodeAt(commentPos);\n          if (cc === 10 || cc === 13) break;\n          commentPos++;\n        }\n        const text = input.slice(pos, commentPos);\n        this.pos = commentPos;\n        return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, pos, 0, this.line, col);\n      }\n\n      // << (LSHIFT), >> (RSHIFT) and >>> (URSHIFT).\n      //\n      // >>> is tested before >>, or the two-char match would consume the first\n      // two angle brackets and leave a stray > for the parser to choke on.\n      if (c0 === 60 && c1 === 60) {\n        this.pos = pos + 2;\n        return new LexerToken('LSHIFT', tokenTypeId('LSHIFT'), '<<', '<<', pos, 0, this.line, col);\n      }\n      if (c0 === 62 && c1 === 62) {\n        if (input.charCodeAt(pos + 2) === 62) {\n          this.pos = pos + 3;\n          return new LexerToken('URSHIFT', tokenTypeId('URSHIFT'), '>>>', '>>>', pos, 0, this.line, col);\n        }\n        this.pos = pos + 2;\n        return new LexerToken('RSHIFT', tokenTypeId('RSHIFT'), '>>', '>>', pos, 0, this.line, col);\n      }\n\n      // ── Plugin-registered two-char operators ──────────────────────\n      if (this.hasPluginOps) {\n        const pluginInner = this.pluginOperators.get(c0);\n        if (pluginInner) {\n          const pluginType = pluginInner.get(c1);\n          if (pluginType) {\n            const text = input.slice(pos, pos + 2);\n            this.pos = pos + 2;\n            return new LexerToken(pluginType, tokenTypeId(pluginType), text, text, pos, 0, this.line, col);\n          }\n        }\n      }\n    }\n\n    // ── Single-character operator ──────────────────────────────────────\n    this.pos = pos + 1;\n    // Track `(`/`[` nesting so the number scanner can tell a thousands group\n    // from an argument/element separator (see {@link groupingStack}). `[` always\n    // opens a separator context (a vector/matrix). `(` opens a separator context\n    // only when it is a CALL, i.e. it directly follows a value the call applies\n    // to, an identifier/unit, or a closing `)`/`]`; a bare GROUPING `(`, after an\n    // operator or the line start, keeps thousands so `(1,000)` stays one number.\n    // `)`/`]` pop; a stray closer with an empty stack is ignored.\n    if (c0 === 91) {  // [\n      this.groupingStack.push(true);\n    } else if (c0 === 40) {  // (\n      this.groupingStack.push(this.precededByCallTarget(pos));\n    } else if (c0 === 41 || c0 === 93) {  // ) or ]\n      if (this.groupingStack.length > 0) this.groupingStack.pop();\n    }\n    const opType = OP_MAP[c0];\n    const text = input.charAt(pos);\n    return new LexerToken(opType || 'ERROR', tokenTypeId(opType || 'ERROR'), text, text, pos, 0, this.line, col);\n  }\n\n  // ── String literal tokenizer ──────────────────────────────────────────\n  /**\n   * Reads a double-quoted string literal. Supports backslash escapes.\n   *\n   * `text` is the raw source slice, quotes included, because that is what\n   * `offset` + `text.length` has to span for a host to underline the literal.\n   * `value` is the PAYLOAD, quotes excluded, because that is what\n   * `PUSH_STRING` puts into the Value.\n   *\n   * The two used to be the same string. `\"abc\"` carried the five characters\n   * `\"abc\"` as its value, which was invisible on screen (the formatter prints\n   * the payload raw and the retained quotes landed where a display would have\n   * put them back) and not invisible anywhere else: `parseFloat('\"5\"')` is NaN\n   * whatever the digits say, so `\"5\" + 5` answered 5.\n   *\n   * An unterminated literal is an error rather than a string that happens to\n   * reach the end of the line. It used to return what it had, so `\"abc` and\n   * `\"abc\"` were indistinguishable by payload once the quotes were stripped,\n   * which is the other half of why they are stripped here rather than later.\n   */\n  private tokenizeString(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n    let pos = start + 1;\n    let lineBreaks = 0;\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 34) {\n        pos++;\n        const text = input.slice(start, pos);\n        const value = input.slice(start + 1, pos - 1);\n        this.pos = pos;\n        return new LexerToken('STRING', tokenTypeId('STRING'), value, text, start, lineBreaks, this.line, startCol);\n      }\n      if (c0 === 92 && pos + 1 < len) {\n        pos += 2;\n        continue;\n      }\n      if (c0 === 10) {\n        this.line++;\n        this.lineStartPos = pos + 1;\n        lineBreaks++;\n      }\n      pos++;\n    }\n\n    this.pos = pos;\n    throw ErrorFactory.parsing(\n      \"UNTERMINATED_STRING\",\n      `Unterminated string literal: ${input.slice(start, pos)}`,\n      { literal: input.slice(start, pos), offset: start },\n    );\n  }\n\n  // ── Markdown line scanner (Phase B) ───────────────────────────────────\n\n  /**\n   * L1 expression gating: quickly determine if a line contains any\n   * characters that indicate an expression (digits, operators, currency,\n   * backticks, parentheses, etc.).\n   *\n   * Pure prose lines (e.g., \"The quick brown fox jumps over the lazy dog\")\n   * return false and can be skipped without full tokenization (L2).\n   *\n   * This is a fast character-by-character scan that stops at the first\n   * expression indicator. Called once per line in classifyFromPositions().\n   */\n  static hasExpressionIndicators(input: string, start: number, end: number): boolean {\n    const indicatorCodes = EXPRESSION_INDICATOR_CODES;\n    for (let i = start; i < end; i++) {\n      const cc = input.charCodeAt(i);\n      // Check digits and operators via pre-computed Set (O(1) lookup)\n      if (indicatorCodes.has(cc)) return true;\n      // Unicode math/currency symbols (≥ 128, not in the 128-byte table)\n      if (cc >= 128) {\n        // ×, ÷, ≠, £, €, ¥, ₽, ₩, common expression symbols\n        if (cc === 0x00D7 || cc === 0x00F7 || cc === 0x2260 ||\n            cc === 0x00A3 || cc === 0x20AC ||\n            cc === 0x00A5 || cc === 0x20BD || cc === 0x20A9) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Classify a line by its character positions within this.input.\n   * Reads directly from this.input using start/end boundaries.\n   * DOES NOT modify this.pos, purely a read-only classifier.\n   */\n  /**\n   * Advance past the whitespace after a list marker, and past a task-item\n   * checkbox if one follows.\n   *\n   * The checkbox is included because it is markup by the same argument the\n   * marker is, and because leaving it stopped the line dead: `- [ ] 100 + 20`\n   * lexed `[ ]` as a matrix literal and reported that a matrix cannot be\n   * empty, which tells a user writing a to-do list nothing they can act on.\n   *\n   * @param from - Offset just past the marker character.\n   * @param end - Line end, never read past.\n   * @returns Offset of the first evaluable character.\n   */\n  private skipMarkerGap(from: number, end: number): number {\n    const input = this.input;\n    let pos = from;\n    while (pos < end && (input.charCodeAt(pos) === 32 || input.charCodeAt(pos) === 9)) pos++;\n\n    // `[ ]`, `[x]`, `[X]`, or any single-character state Obsidian allows.\n    if (pos + 2 < end && input.charCodeAt(pos) === 91 && input.charCodeAt(pos + 2) === 93) {\n      let after = pos + 3;\n      while (after < end && (input.charCodeAt(after) === 32 || input.charCodeAt(after) === 9)) after++;\n      // Only when whitespace followed, so `[1,2]` opening a real matrix is\n      // never mistaken for a checkbox.\n      if (after > pos + 3) return after;\n    }\n    return pos;\n  }\n\n  /**\n   * The end offset (exclusive) of a `#hex` colour literal starting at `hashPos`,\n   * or -1 if the run there is not one. A colour is `#` followed by EXACTLY 3, 4,\n   * 6 or 8 hex digits (the CSS forms `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa`) and\n   * then a boundary, not a longer word or number. This is the one predicate that\n   * carves colours out of the two things `#` otherwise means, a markdown heading\n   * at line start and a comment mid-line, and it is pure character logic so line\n   * classification stays vocabulary-independent. Examples: `#f00`, `#ff0000`,\n   * `#deadbeef` match; `# Heading` (space), `#tag`/`#todo` (non-hex letter),\n   * `#12345` (length 5), `#ff0000zz` (trailing word) do not.\n   */\n  private matchHexColourEnd(hashPos: number, end: number): number {\n    const input = this.input;\n    let p = hashPos + 1;\n    let n = 0;\n    while (p < end) {\n      const c = input.charCodeAt(p);\n      const isHex = (c >= 48 && c <= 57) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102);\n      if (!isHex) break;\n      n++;\n      p++;\n    }\n    if (n !== 3 && n !== 4 && n !== 6 && n !== 8) return -1;\n    if (p < end) {\n      const c = input.charCodeAt(p);\n      const isWord = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;\n      if (isWord) return -1;\n    }\n    return p;\n  }\n\n  private classifyFromPositions(start: number, end: number): LineClassification {\n    const len = end;\n\n    if (start >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const input = this.input;\n    let pos = start;\n\n    while (pos < len) {\n      const cc = input.charCodeAt(pos);\n      if (cc !== 32 && cc !== 9) break;\n      pos++;\n    }\n\n    if (pos >= len) {\n      return { type: 'empty', skip: true, hasInlineSolve: false };\n    }\n\n    const c0 = input.charCodeAt(pos);\n    let hasInline: boolean | undefined;\n\n    // ── Heading: #{1,6} ' ' ──────────────────────────────────────────\n    if (c0 === 35) {\n      // A bare #hex colour is a value, not a heading. A real heading has a space\n      // after its #(s), so the colour shape (# + 3/4/6/8 hex digits) never\n      // collides with one. This line is tokenized like any expression.\n      if (this.matchHexColourEnd(pos, len) !== -1) {\n        if (hasInline === undefined) {\n          const idx = input.indexOf('s`', pos);\n          hasInline = idx !== -1 && idx < len;\n        }\n        return { type: 'expression', skip: false, hasInlineSolve: hasInline };\n      }\n      let hashCount = 1;\n      while (pos + hashCount < len && input.charCodeAt(pos + hashCount) === 35) {\n        hashCount++;\n      }\n      if (hashCount <= 6 && pos + hashCount < len && input.charCodeAt(pos + hashCount) === 32) {\n        return { type: 'heading', skip: true, hasInlineSolve: false };\n      }\n      return { type: 'heading', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Blockquote: > ' ' ────────────────────────────────────────────\n    if (c0 === 62) {\n      if (pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n        return { type: 'blockquote', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Code fence: ``` or ~~~ ────────────────────────────────────────\n    if (c0 === 96 && pos + 2 < len && input.charCodeAt(pos + 1) === 96 && input.charCodeAt(pos + 2) === 96) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 126 && pos + 2 < len && input.charCodeAt(pos + 1) === 126 && input.charCodeAt(pos + 2) === 126) {\n      return { type: 'code_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Math fence: $$ ────────────────────────────────────────────────\n    if (c0 === 36 && pos + 1 < len && input.charCodeAt(pos + 1) === 36) {\n      return { type: 'math_fence', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Horizontal rule: ---, ***, ___ (3+ same char, then only whitespace)\n    if (c0 === 45 || c0 === 42 || c0 === 95) {\n      let count = 1;\n      while (pos + count < len && input.charCodeAt(pos + count) === c0) {\n        count++;\n      }\n      if (count >= 3) {\n        let trailPos = pos + count;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'hr', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Unordered list: - ' ', * ' ', + ' ' ──────────────────────────\n    if ((c0 === 45 || c0 === 42 || c0 === 43) && pos + 1 < len && input.charCodeAt(pos + 1) === 32) {\n      if (hasInline === undefined) {\n        const idx = input.indexOf('s`', pos);\n        hasInline = idx !== -1 && idx < len;\n      }\n      // The space is what makes this a marker rather than an operator, and it\n      // is required by CommonMark for exactly that reason. `-100 + 20` has no\n      // space and stays arithmetic; `- 100 + 20` is a bullet.\n      return { type: 'list', skip: false, hasInlineSolve: hasInline, contentOffset: this.skipMarkerGap(pos + 1, len) };\n    }\n\n    // ── Ordered list: \\n+ '. ' ────────────────────────────────────────\n    if (c0 >= 48 && c0 <= 57) {\n      let digitPos = pos;\n      while (digitPos < len && input.charCodeAt(digitPos) >= 48 && input.charCodeAt(digitPos) <= 57) {\n        digitPos++;\n      }\n      if (digitPos < len && input.charCodeAt(digitPos) === 46) {\n        if (digitPos + 1 < len && input.charCodeAt(digitPos + 1) === 32) {\n          if (hasInline === undefined) {\n            const idx = input.indexOf('s`', pos);\n            hasInline = idx !== -1 && idx < len;\n          }\n          return { type: 'list', skip: false, hasInlineSolve: hasInline, contentOffset: this.skipMarkerGap(digitPos + 1, len) };\n        }\n      }\n    }\n\n    // ── Table / table separator: | ────────────────────────────────────\n    if (c0 === 124) {\n      let tPos = pos + 1;\n      while (tPos < len) {\n        const tc = input.charCodeAt(tPos);\n        if (tc !== 45 && tc !== 58 && tc !== 124 && tc !== 32 && tc !== 9 && tc !== 13) break;\n        tPos++;\n      }\n      if (tPos >= len) {\n        return { type: 'table_separator', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // ── Wikilink / embed: [[ or ![[ ───────────────────────────────────\n    if (c0 === 91 && pos + 1 < len && input.charCodeAt(pos + 1) === 91) {\n      const closePos = input.indexOf(']]', pos + 2);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n    if (c0 === 33 && pos + 2 < len && input.charCodeAt(pos + 1) === 91 && input.charCodeAt(pos + 2) === 91) {\n      const closePos = input.indexOf(']]', pos + 3);\n      if (closePos !== -1 && closePos < len) {\n        let trailPos = closePos + 2;\n        while (trailPos < len && (input.charCodeAt(trailPos) === 32 || input.charCodeAt(trailPos) === 9)) {\n          trailPos++;\n        }\n        if (trailPos >= len) {\n          return { type: 'wikilink', skip: true, hasInlineSolve: false };\n        }\n      }\n    }\n\n    // ── Comment: // ──────────────────────────────────────────────────\n    if (c0 === 47 && pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      return { type: 'comment', skip: true, hasInlineSolve: false };\n    }\n\n    // ── Default: expression or prose line ─────────────────────────────\n    if (c0 === 62) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'blockquote', skip: true, hasInlineSolve: false };\n    }\n    if (c0 === 45 || c0 === 42 || c0 === 43) {\n      let trail = pos + 1;\n      while (trail < len && (input.charCodeAt(trail) === 32 || input.charCodeAt(trail) === 9)) trail++;\n      if (trail >= len) return { type: 'list', skip: false, hasInlineSolve: false };\n    }\n    if (hasInline === undefined) {\n      const idx = input.indexOf('s`', pos);\n      hasInline = idx !== -1 && idx < len;\n    }\n\n    // A line built only from characters the tokenizer discards produces no\n    // tokens, so it has nothing to evaluate. Whitespace-only lines already\n    // classify as empty above; the gap was an unknown ASCII character like a\n    // backslash, which the lexer skips (it falls through to CharClass.SKIP)\n    // rather than tokenising. A run of them (\"\\\\\", \"\\\\\\\\\") reached the\n    // expression path, lexed to an empty token stream, and the engine reported\n    // that stream as the number 0: a result on screen for a line that holds no\n    // expression at all. Classify it as empty, the same as a blank line, so\n    // every surface (the batch parse, the incremental evaluator, and the\n    // playground's shouldEvaluateLine) skips it rather than answering 0. A\n    // non-ASCII code point is real content (it lexes as an IDENT for forward\n    // compatibility), so only ASCII whitespace and skip characters count here.\n    if (!hasInline) {\n      let onlySkippable = true;\n      for (let i = pos; i < len; i++) {\n        const code = input.charCodeAt(i);\n        if (code >= 128 || ExpressionLexer.CHAR_CLASS[code] > CharClass.WHITESPACE) {\n          onlySkippable = false;\n          break;\n        }\n      }\n      if (onlySkippable) {\n        return { type: 'empty', skip: true, hasInlineSolve: false };\n      }\n    }\n\n    // Return expression, all non-markdown-structure lines are tokenized.\n    // (L1 prose gating removed: it incorrectly skipped keyword-only lines\n    // like \"pi\", single identifiers like \"hello\", and any line without\n    // digits/operators/currency. Can be re-added with keyword-awareness\n    // and proper test coverage.)\n    return { type: 'expression', skip: false, hasInlineSolve: hasInline };\n  }\n\n  /**\n   * Classify a single line of markdown text.\n   */\n  classifyLine(lineText: string): LineClassification {\n    const savedInput = this.input;\n    const savedLen = this.len;\n    const savedPos = this.pos;\n    this.input = lineText;\n    this.len = lineText.length;\n    this.pos = 0;\n    const result = this.classifyFromPositions(0, lineText.length);\n    this.input = savedInput;\n    this.len = savedLen;\n    this.pos = savedPos;\n    return result;\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes, locale keywords\n   * (`pi`, `sqrt`, `convert`, ...) merged with any plugin-contributed ones\n   * from `registerVocabulary()` (e.g. a package's custom keywords), mapped to\n   * the token type they lex to. A snapshot copy, not a live reference\n   * mutating the return value has no effect on the lexer.\n   */\n  getKeywords(): Record<string, string> {\n    return Object.fromEntries(this.mergedKeywords);\n  }\n\n  /**\n   * Find all inline solve markers in a line with precise coordinate mapping.\n   */\n  findInlineSolves(lineText: string): InlineSolveSpan[] {\n    const results: InlineSolveSpan[] = [];\n    const len = lineText.length;\n    let pos = 0;\n\n    while (pos < len) {\n      const sPos = lineText.indexOf('s`', pos);\n      if (sPos === -1) break;\n\n      const exprStart = sPos + 2;\n\n      let exprEnd = exprStart;\n      while (exprEnd < len) {\n        const cc = lineText.charCodeAt(exprEnd);\n        if (cc === 92 && exprEnd + 1 < len) {\n          exprEnd += 2;\n          continue;\n        }\n        if (cc === 96) break;\n        exprEnd++;\n      }\n\n      if (exprEnd >= len) {\n        exprEnd = len;\n      }\n\n      const expression = lineText.slice(exprStart, exprEnd);\n      const end = exprEnd < len ? exprEnd + 1 : exprEnd;\n\n      results.push({\n        start: sPos,\n        end,\n        expression,\n        columnNumber: sPos + 1,\n      });\n\n      pos = end;\n    }\n\n    return results;\n  }\n\n  // ── Comment tokenizer ─────────────────────────────────────────────────\n  /**\n   * Reads a comment: # to end of line, or // to end of line.\n   */\n  private tokenizeComment(): Token {\n    const input = this.input;\n    const len = this.len;\n    const start = this.pos;\n    const startCol = start - this.lineStartPos + 1;\n\n    // A `#hex` colour literal is not a comment. Recognised here (the single\n    // choke-point both `#` call sites reach) so `#ff0000` becomes a HEX_COLOUR\n    // token while `# comment`, `#tag`, `#face` (length 4 all-hex still counts as a\n    // colour) and `// c` stay comments. Only fires when the char is `#`, never `/`.\n    if (input.charCodeAt(start) === 35) {\n      const hexEnd = this.matchHexColourEnd(start, len);\n      if (hexEnd !== -1) {\n        const text = input.slice(start, hexEnd);\n        this.pos = hexEnd;\n        return new LexerToken('HEX_COLOUR', tokenTypeId('HEX_COLOUR'), text, text, start, 0, this.line, startCol);\n      }\n\n      // A bounded `#tag` annotation: `#` then a letter then a run of\n      // `[A-Za-z0-9_-]`, consuming only the tag, not the rest of the line. So\n      // `1200 #housing // note` keeps the `// note` comment, and a mid-line tag\n      // no longer swallows the line. `# ` (space) and `#123` (leading digit)\n      // still fall through to a comment; a line-start `#` is a heading\n      // (classified elsewhere); a `#hex` colour is caught above.\n      const first = input.charCodeAt(start + 1);\n      const isLetter = (first >= 65 && first <= 90) || (first >= 97 && first <= 122);\n      if (isLetter) {\n        let tagEnd = start + 2;\n        while (tagEnd < len) {\n          const c = input.charCodeAt(tagEnd);\n          const isTagChar = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 45;\n          if (!isTagChar) break;\n          tagEnd++;\n        }\n        // Store the name without the `#`, matching how LINE_REF keeps the bare\n        // number.\n        const name = input.slice(start + 1, tagEnd);\n        this.pos = tagEnd;\n        return new LexerToken('TAG', tokenTypeId('TAG'), name, name, start, 0, this.line, startCol);\n      }\n    }\n\n    let pos = this.pos;\n\n    if (pos + 1 < len && input.charCodeAt(pos + 1) === 47) {\n      pos += 2;\n    } else {\n      pos++;\n    }\n\n    while (pos < len) {\n      const c0 = input.charCodeAt(pos);\n      if (c0 === 10 || c0 === 13) break;\n      pos++;\n    }\n\n    const text = input.slice(start, pos);\n    this.pos = pos;\n    return new LexerToken('COMMENT', tokenTypeId('COMMENT'), text, text, start, 0, this.line, startCol);\n  }\n}"]}

package/dist/{chunk-3OWCDIPN.js → chunk-YNIWOYW6.js}

@@ -1,6 +1,7 @@
 import { autoFormatIntegerOrFloat } from './chunk-UKQHXPGW.js';
 import { formatColour } from './chunk-5HRB36DK.js';
-import { columnMajorToRowMajor, formatSymbolic, CURRENCY_DISPLAY, decimalToFixed } from './chunk-NNQ2TYDF.js';
+import { columnMajorToRowMajor, formatSymbolic, CURRENCY_DISPLAY, decimalToFixed } from './chunk-ZNFFTYWH.js';
+import { Value } from './chunk-5EFKSKMA.js';
 import { getLocale } from './chunk-XBTEO4OB.js';
 
 // src/format/FormattingSettings.ts
@@ -99,7 +100,7 @@ function formatMsDuration(ms) {
 function formatUom(value, unit, locale, settings, exact) {
   if (unit === "ms") return `= ${formatMsDuration(value)}`;
   const dp = settings.unitOfMeasurementResult.decimalPlaces;
-  const timeSpanUnits = ["days", "weeks", "hours", "minutes", "seconds", "day", "week", "hour", "minute", "second"];
+  const timeSpanUnits = ["days", "weeks", "months", "years", "hours", "minutes", "seconds", "day", "week", "month", "year", "hour", "minute", "second"];
   const isTimeSpan = unit && timeSpanUnits.includes(unit);
   let formatted;
   if (isTimeSpan && value === Math.floor(value)) {
@@ -167,6 +168,20 @@ function formatPercentage(value, locale, settings) {
 function formatUnit(value, unit) {
   return `= ${value} ${unit || ""}`.trim();
 }
+function formatSplit(data, locale, settings) {
+  const prefix = locale.display.resultPrefix;
+  const render = (share) => {
+    const v = data.unit !== void 0 ? new Value(6 /* Uom */, share.value, data.unit) : new Value(0 /* Number */, share.value);
+    v.exact = share.exact;
+    const text = formatValue(v, settings);
+    return text.startsWith(prefix) ? text.slice(prefix.length) : text;
+  };
+  const [base, high] = data.shares;
+  const each = `${render(base)} each`;
+  if (high === void 0) return `${prefix}${each}`;
+  const shareWord = high.count === 1 ? "share" : "shares";
+  return `${prefix}${each}, with ${high.count} ${shareWord} paying ${render(high)}`;
+}
 function formatValue(value, settings) {
   const us = settings || DEFAULT_FORMATTING_SETTINGS;
   const localeCode = us.numberResult.decimalSeparatorLocale || "en";
@@ -197,6 +212,8 @@ function formatValue(value, settings) {
     }
     case 14 /* Colour */:
       return `${locale.display.resultPrefix}${formatColour(value.value)}`;
+    case 15 /* Split */:
+      return formatSplit(value.value, locale, us);
     case 9 /* Symbolic */:
       return formatSymbolic(value.value);
     case 5 /* Percentage */:
@@ -211,5 +228,5 @@ function formatValue(value, settings) {
 }
 
 export { DEFAULT_FORMATTING_SETTINGS, formatMatrixAligned, formatValue };
-//# sourceMappingURL=chunk-3OWCDIPN.js.map
-//# sourceMappingURL=chunk-3OWCDIPN.js.map
+//# sourceMappingURL=chunk-YNIWOYW6.js.map
+//# sourceMappingURL=chunk-YNIWOYW6.js.map

package/dist/chunk-YNIWOYW6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format/FormattingSettings.ts","../src/format/FormatEngine.ts"],"names":["formatted"],"mappings":"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","file":"chunk-YNIWOYW6.js","sourcesContent":["/**\n * Minimal formatting settings interface for the engine\n * This allows the engine to format values without depending on app-specific settings\n */\nexport interface FormattingSettings {\n  floatResult: {\n    decimalPlaces: number;\n    enableSeperator: boolean;\n  };\n  numberResult: {\n    decimalSeparatorLocale: string;\n  };\n  hexResult: {\n    enablePadding: boolean;\n    paddingZeros: number;\n  };\n  unitOfMeasurementResult: {\n    decimalPlaces: number;\n  };\n  percentageResult: {\n    decimalPlaces: number;\n  };\n}\n\n/** Formatting used when a host supplies none. */\nexport const DEFAULT_FORMATTING_SETTINGS: FormattingSettings = {\n  floatResult: {\n    decimalPlaces: 2,\n    enableSeperator: true,\n  },\n  numberResult: {\n    decimalSeparatorLocale: \"en-US\",\n  },\n  hexResult: {\n    enablePadding: false,\n    paddingZeros: 0,\n  },\n  unitOfMeasurementResult: {\n    decimalPlaces: 2,\n  },\n  percentageResult: {\n    decimalPlaces: 2,\n  },\n};\n","import { Value, ValueType, type MatrixData, type MatrixEntry, type RangeData, type ColourData, type SplitData, type SplitShare } from \"@solve-js/vm/Value\";\nimport { formatColour } from \"@solve-js/packages/colour/ColourMath\";\nimport { decimalToFixed, type DecimalData } from \"@solve-js/decimal\";\nimport { getLocale, type ILocale } from \"@solve-js/constants/locales\";\nimport { autoFormatIntegerOrFloat } from \"@solve-js/utilities/Number\";\nimport { FormattingSettings, DEFAULT_FORMATTING_SETTINGS } from \"./FormattingSettings\";\nimport { CURRENCY_DISPLAY } from \"@solve-js/uom/CurrencyAliases\";\nimport { columnMajorToRowMajor } from \"@solve-js/vm/MatrixOps\";\nimport { formatSymbolic, type SymbolicNode } from \"@solve-js/symbolic\";\n\nfunction formatNumber(value: number, locale: ILocale, settings: FormattingSettings, decimalPlaces?: number): string {\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  // An explicit precision (`3.14159 to 4 dp`, `round(1.5, 2)`) shows EXACTLY that\n  // many places with trailing zeros kept, where the default trims them and shows\n  // an integer with none. The value was already rounded to this precision when\n  // it was set (see VMBuiltins' roundToPlaces, exact where an exact decimal was\n  // there), so rendering it to the same place count reproduces that rounding.\n  if (decimalPlaces !== undefined && Number.isFinite(value)) {\n    const formatted = value.toLocaleString(loc || \"en-US\", {\n      minimumFractionDigits: decimalPlaces,\n      maximumFractionDigits: decimalPlaces,\n      useGrouping: sep,\n    });\n    return `${locale.display.resultPrefix}${formatted}`;\n  }\n  const dp = settings.floatResult.decimalPlaces;\n  const formatted = autoFormatIntegerOrFloat(value, dp, sep, loc);\n  return `${locale.display.resultPrefix}${formatted}`;\n}\n\n/**\n * Renders a measurement that carries a one-sigma uncertainty as\n * `center ± spread`, e.g. `49.2 ± 2.0`.\n *\n * The center is shown the way any number is, whole numbers as integers and\n * trailing zeros trimmed, so a tolerance-free-looking center still reads\n * cleanly (\"30 ± 2.24\", not \"30.00 ± 2.24\"). The spread is shown to the same\n * decimal-place budget but always keeps at least one fractional digit, which is\n * what distinguishes it as a tolerance and gives \"± 2.0\" rather than \"± 2\".\n * Both use `Intl` with `maximumFractionDigits`, so the trailing-zero trimming is\n * locale-correct (a comma-decimal locale is not string-sliced on \".\").\n *\n * The symbol is always the `±` glyph on output, even when the input was the\n * ASCII `+/-`, since the glyph is the conventional notation and unambiguous to\n * read back.\n */\nfunction formatUncertain(center: number, uncertainty: number, locale: ILocale, settings: FormattingSettings): string {\n  const dp = settings.floatResult.decimalPlaces;\n  const useGrouping = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale || \"en-US\";\n  // The spread needs room for at least one fractional digit, so a zero-decimal\n  // budget cannot leave minimumFractionDigits above maximumFractionDigits.\n  const spreadMax = Math.max(dp, 1);\n  const centerText = center.toLocaleString(loc, { useGrouping, minimumFractionDigits: 0, maximumFractionDigits: dp });\n  const spreadText = Math.abs(uncertainty).toLocaleString(loc, { useGrouping, minimumFractionDigits: 1, maximumFractionDigits: spreadMax });\n  return `${locale.display.resultPrefix}${centerText} ± ${spreadText}`;\n}\n\n/**\n * Renders a number in whichever base it is tagged with.\n *\n * The zero padding is a hexadecimal setting and stays one. Applying it to a\n * binary rendering would pad `0b101` out to the same digit count as a hex\n * value, which is a different quantity of zeros and not what the setting asks\n * for.\n */\nfunction formatHex(value: number | bigint, settings: FormattingSettings, base?: string): string {\n  // An infinity or a NaN has no digits in any base, and asking for them\n  // produced `0xINFINITY`, a literal that reads back as nothing at all. Render\n  // the value itself, which is what every other non-finite result shows.\n  if (typeof value === \"number\" && !Number.isFinite(value)) return `= ${value}`;\n\n  // Truncate and take the sign off before converting. `Number.toString(radix)`\n  // does neither: it renders -255 as \"-ff\", which lands the minus inside the\n  // literal as `0x-FF`, and it renders 255.7 as \"ff.b3333333333\", inventing\n  // fractional hex digits for a notation that has no use for them. Both were\n  // visible on `as hex` until the builtins started sharing this path.\n  //\n  // A bigint needs neither truncation nor a Math call, and must not be routed\n  // through one: passing it to Math.trunc() throws, and converting it to a\n  // double first is exactly the precision loss it is carried as a bigint to\n  // avoid.\n  const negative = typeof value === \"bigint\" ? value < 0n : value < 0;\n  const sign = negative ? \"-\" : \"\";\n  const digits = (radix: number): string =>\n    typeof value === \"bigint\"\n      ? (negative ? -value : value).toString(radix)\n      : Math.abs(Math.trunc(value)).toString(radix);\n\n  if (base === \"bin\") return `= ${sign}0b${digits(2)}`;\n  if (base === \"oct\") return `= ${sign}0o${digits(8)}`;\n  const padding = settings.hexResult.enablePadding ? settings.hexResult.paddingZeros : 0;\n  const hex = digits(16).toUpperCase().padStart(padding, \"0\");\n  return `= ${sign}0x${hex}`;\n}\n\n/**\n * How many decimal digits of an exact integer this will render in full.\n *\n * A little above the ~19,729 digits of the largest bigint the VM will build\n * (`vm/VM.ts`'s MAX_EXACT_POW_BITS / MAX_EXACT_SHIFT_BITS, 65,536 bits), so\n * every value the engine can produce through `^` or `<<` still prints exactly\n * and this ceiling only ever meets a value that came from somewhere else.\n */\nconst MAX_DISPLAYED_BIGINT_DIGITS = 20000;\n\n/**\n * Renders an exact integer, or describes it when writing it out is itself the\n * expensive operation.\n *\n * This used to be a bare `= ${value}` template, which renders whatever it is\n * handed: `1n << 100000000` took 8.5 seconds here turning a 12.5MB integer\n * into a thirty-million-character string, and a host has no way to opt out,\n * since displaying the answer is what it asked the engine for. The VM's own\n * ceiling on `<<` and `^` now stops that value existing, so this is the\n * backstop for every other way a large bigint can arrive (repeated `x * x`,\n * a Value a host built itself), and it costs one comparison for every value\n * that is not absurd.\n *\n * The digit count is estimated from the bit length rather than measured, since\n * measuring means doing the conversion this exists to avoid. Bit length comes\n * off the hexadecimal form, which is linear in the size of the value where the\n * decimal form is not.\n */\nfunction formatBigInt(value: bigint): string {\n  const magnitude = value < 0n ? -value : value;\n  // Every bigint a person actually reads takes this line and nothing else:\n  // anything a double can hold is at most 309 digits, so it is printable\n  // without measuring it at all.\n  if (Number.isFinite(Number(magnitude))) return `= ${value}`;\n  const bits = magnitude.toString(16).length * 4;\n  if (bits * Math.LN2 / Math.LN10 <= MAX_DISPLAYED_BIGINT_DIGITS) return `= ${value}`;\n  const log10 = bits * Math.LN2 / Math.LN10;\n  const exponent = Math.floor(log10);\n  const mantissa = Math.pow(10, log10 - exponent);\n  const sign = value < 0n ? \"-\" : \"\";\n  return `= ${sign}~${mantissa.toFixed(3)}e+${exponent} (an exact integer of about ${(exponent + 1).toLocaleString(\"en-US\")} digits, too large to print)`;\n}\n\nfunction formatString(value: string): string {\n  return `= ${value}`;\n}\n\nfunction formatBoolean(value: boolean): string {\n  return `= ${value}`;\n}\n\n/**\n * Renders a Datetime value locale-aware, the previous implementation\n * called `d.toLocaleString()` with no arguments, which always uses the JS\n * runtime's own default locale and never actually consulted `locale.code`\n * despite receiving it as a parameter (both branches of its old\n * `dateFormat === \"default\"` check were byte-for-byte identical, dead\n * groundwork for a distinction that was never implemented). Concretely,\n * this meant every configured locale (including the shipped German one)\n * always displayed weekday/month names in English. See GitHub issue #77.\n *\n * Uses `weekday`/`month`: \"long\" for a spelled-out date (\"Monday,\n * November 17, 2025\" / \"lundi 17 novembre 2025\") since that's what a\n * literal weekday name is for; a bare numeric date doesn't need\n * localizing beyond the decimal/thousands separators `formatNumber()`\n * already handles. The time-of-day portion is only appended when it's\n * not exactly local midnight, bare date literals (\"today\", \"17/11/2025\")\n * always anchor to local midnight, and showing \"00:00:00\" on every one of\n * those would be noise, not information.\n */\nfunction formatDatetime(value: number, locale: ILocale): string {\n  const d = new Date(value);\n  const dateStr = d.toLocaleDateString(locale.code, { weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\" });\n  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;\n  if (isMidnight) return `= ${dateStr}`;\n  return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;\n}\n\n/**\n * Renders a millisecond duration as clock-style `H:MM` (or `H:MM:SS` when\n * there's a non-zero seconds component). `ms` is never a user-typeable\n * unit (confirmed: it appears nowhere in `lexer/units.ts`), it's only\n * ever produced by subtracting two clock times/datetimes (`9:30 - 8:30`,\n * `VM.ts`'s Datetime SUB case), so this is a safe, narrow special case,\n * not a general change to how durations display.\n */\nfunction formatMsDuration(ms: number): string {\n  const sign = ms < 0 ? \"-\" : \"\";\n  const totalSeconds = Math.round(Math.abs(ms) / 1000);\n  const hours = Math.floor(totalSeconds / 3600);\n  const minutes = Math.floor((totalSeconds % 3600) / 60);\n  const seconds = totalSeconds % 60;\n  const mm = String(minutes).padStart(2, \"0\");\n  if (seconds === 0) return `${sign}${hours}:${mm}`;\n  const ss = String(seconds).padStart(2, \"0\");\n  return `${sign}${hours}:${mm}:${ss}`;\n}\n\nfunction formatUom(value: number, unit: string | undefined, locale: ILocale, settings: FormattingSettings, exact?: DecimalData): string {\n  if (unit === \"ms\") return `= ${formatMsDuration(value)}`;\n\n  const dp = settings.unitOfMeasurementResult.decimalPlaces;\n\n  // For TimeSpan values (days, weeks, hours, etc.), format as integer if the value is a whole number\n  const timeSpanUnits = [\"days\", \"weeks\", \"months\", \"years\", \"hours\", \"minutes\", \"seconds\", \"day\", \"week\", \"month\", \"year\", \"hour\", \"minute\", \"second\"];\n  const isTimeSpan = unit && timeSpanUnits.includes(unit);\n\n  let formatted: string;\n  if (isTimeSpan && value === Math.floor(value)) {\n    // For whole number TimeSpan values, format as integer\n    formatted = value.toString();\n  } else {\n    // For other values, use the configured decimal places\n    formatted = value.toFixed(dp);\n  }\n\n  // Currency display: symbol + culturally-conventional placement (e.g.\n  // \"$100.00\" prefix vs \"100.00 kr\" suffix) instead of the generic\n  // \"amount CODE\" fallback below. See uom/CurrencyAliases.ts's\n  // CURRENCY_DISPLAY table for the exact set covered and the reasoning\n  // behind each placement choice. Any currency code NOT in that table\n  // (most of the ~150 `CurrencyExchange.isCurrency()` recognizes) falls\n  // through to the unchanged \"amount CODE\" format below.\n  const currencyDisplay = unit ? CURRENCY_DISPLAY[unit.toUpperCase()] : undefined;\n  if (currencyDisplay) {\n    // An exact money amount rounds from its decimal, not from the double: a\n    // half-cent like \"$1.005\" reads as \"$1.01\" here, where \"(1.005).toFixed(2)\"\n    // answers \"1.00\" because the double it is handed already sits below the\n    // value the user typed. Amounts with no exact decimal (a currency\n    // conversion, whose rate is a double) keep the toFixed rendering above.\n    const moneyText = exact ? decimalToFixed(exact, dp) : formatted;\n    const sep = currencyDisplay.spaced ? \" \" : \"\";\n    const withSymbol = currencyDisplay.position === \"prefix\"\n      ? `${currencyDisplay.symbol}${sep}${moneyText}`\n      : `${moneyText}${sep}${currencyDisplay.symbol}`;\n    return `= ${withSymbol}`;\n  }\n\n  // The unit is written as the symbol the value carries. There used to be a\n  // `unitOfMeasurementResult.unitNames` setting here whose two branches were\n  // the same expression, so it never changed anything, and it was removed\n  // rather than implemented: the engine has no unit-name data to render from.\n  // The generated unit table maps a spelling to [measure, ratio] only, and\n  // names cannot be recovered from it, because units that differ by an OFFSET\n  // share a ratio, so \"20 C\" would come back as \"20 kelvins\". A real\n  // implementation needs a hand-authored name per unit plus pluralization and\n  // per-locale spelling (metre against meter), which is a feature rather than\n  // the repair of a dead ternary.\n  //\n  // An exact currency with no symbol in the display table above (one of the\n  // less common ISO codes) still rounds from its decimal here, so \"1.005 UYW\"\n  // reads the same way \"$1.005\" does. Non-currency Uoms never carry an exact,\n  // so this leaves \"1.50 kg\" exactly as it was.\n  const genericText = exact ? decimalToFixed(exact, dp) : formatted;\n  return `= ${genericText} ${unit || \"\"}`.trim();\n}\n\nfunction formatMatrixEntry(entry: MatrixEntry, settings: FormattingSettings): string {\n  if (typeof entry === \"boolean\") return entry ? \"true\" : \"false\";\n  if (typeof entry === \"object\" && entry !== null) return formatSymbolic(entry);\n  const dp = settings.floatResult.decimalPlaces;\n  const sep = settings.floatResult.enableSeperator;\n  const loc = settings.numberResult.decimalSeparatorLocale;\n  return autoFormatIntegerOrFloat(entry, dp, sep, loc);\n}\n\n/**\n * Renders a Matrix matching its own literal syntax: a single row (1xN,\n * including plain vectors) as `[a, b, c]`, a single column (Nx1) as\n * `[a; b; c]`, and a general shape as `[r0c0, r0c1; r1c0, r1c1]`, row-major\n * textual output read back out of the column-major storage\n * (`columnMajorToRowMajor()`), matching how `[1,2;3,4]` is written.\n */\nfunction formatMatrix(m: MatrixData, locale: ILocale, settings: FormattingSettings): string {\n  const rowMajor = columnMajorToRowMajor(m);\n  const rows: string[] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const cells: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      cells.push(formatMatrixEntry(rowMajor[r * m.cols + c], settings));\n    }\n    rows.push(cells.join(\", \"));\n  }\n  return `${locale.display.resultPrefix}[${rows.join(\"; \")}]`;\n}\n\n/**\n * Render a matrix as a multi-line, column-aligned block: one row per line (the\n * newline is where {@link formatValue}'s compact form writes `;`), each column\n * right-padded to its widest cell, and every row wrapped in `[ ... ]`. For\n * display where a grid reads better than a line, e.g. a docs notepad or a REPL:\n *\n * ```text\n * [  1   2 ]\n * [ 30   4 ]\n * ```\n *\n * This is deliberately separate from {@link formatValue}, whose single-line\n * matrix form stays the stable, assertable text the API and the worker DTO use.\n * A 1xN row vector is one line; an Nx1 column vector is N lines.\n */\nexport function formatMatrixAligned(m: MatrixData, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const rowMajor = columnMajorToRowMajor(m);\n  const cells: string[][] = [];\n  for (let r = 0; r < m.rows; r++) {\n    const row: string[] = [];\n    for (let c = 0; c < m.cols; c++) {\n      row.push(formatMatrixEntry(rowMajor[r * m.cols + c], us));\n    }\n    cells.push(row);\n  }\n  const colWidth: number[] = [];\n  for (let c = 0; c < m.cols; c++) {\n    let width = 0;\n    for (let r = 0; r < m.rows; r++) width = Math.max(width, cells[r][c].length);\n    colWidth.push(width);\n  }\n  return cells\n    .map((row) => `[ ${row.map((cell, c) => cell.padStart(colWidth[c])).join(\"  \")} ]`)\n    .join(\"\\n\");\n}\n\nfunction formatRange(min: number, max: number, locale: ILocale): string {\n  return `${locale.display.resultPrefix}${min}:${max}`;\n}\n\nfunction formatPercentage(value: number, locale: ILocale, settings: FormattingSettings): string {\n  // ValueType.Percentage stores a fraction (0.25 for 25%). See Value.ts's\n  // documented contract and the sole producer, VM.ts's TO_PERCENTAGE opcode\n  // (`right/left - 1`, e.g. 0.25 for \"800 to 1000\"). Multiply by 100 before\n  // formatting; without this every percentage-change result displayed as\n  // e.g. \"0.25%\" instead of \"25.00%\".\n  const dp = settings.percentageResult.decimalPlaces;\n  const formatted = (value * 100).toFixed(dp);\n  return `= ${formatted}${locale.display.percentageSuffix}`;\n}\n\nfunction formatUnit(value: number, unit: string | undefined): string {\n  return `= ${value} ${unit || \"\"}`.trim();\n}\n\n/**\n * Renders a per-person bill split: \"= $45.00 each\", or, when the division is\n * uneven, \"= $33.33 each, with 1 share paying $33.34\". Each share's amount is\n * rendered through the ordinary value formatter (a throwaway {@link Value}), so\n * a currency share honours the same symbol placement, decimal places and locale\n * as any other money and a bare share trims trailing zeros the way a plain\n * number does; the \"= \" prefix is added once, around the whole sentence, not\n * per share.\n */\nfunction formatSplit(data: SplitData, locale: ILocale, settings: FormattingSettings): string {\n  const prefix = locale.display.resultPrefix;\n  const render = (share: SplitShare): string => {\n    const v = data.unit !== undefined\n      ? new Value(ValueType.Uom, share.value, data.unit)\n      : new Value(ValueType.Number, share.value);\n    v.exact = share.exact;\n    const text = formatValue(v, settings);\n    return text.startsWith(prefix) ? text.slice(prefix.length) : text;\n  };\n\n  const [base, high] = data.shares;\n  const each = `${render(base)} each`;\n  if (high === undefined) return `${prefix}${each}`;\n  const shareWord = high.count === 1 ? \"share\" : \"shares\";\n  return `${prefix}${each}, with ${high.count} ${shareWord} paying ${render(high)}`;\n}\n\n/**\n * Render an evaluated {@link Value} as a display string, dispatching on\n * `value.type` to the type-specific formatter (number, hex, datetime, unit\n * of measurement, matrix, range, percentage, ...).\n *\n * Most branches produce a `\"= \"`-prefixed result string (matching the\n * plugin's inline-result convention); `ValueType.Error` is the one\n * exception, it returns the human-readable error message directly\n * (stored in `value.unit`), not an `\"= \"`-prefixed string.\n *\n * @param value - The evaluated value to format.\n * @param settings - Locale/precision/separator options; defaults to\n *   {@link DEFAULT_FORMATTING_SETTINGS} when omitted.\n * @example\n * ```typescript\n * const [value] = engine.evaluateExpression(\"10 USD to GBP\");\n * formatValue(value); // \"= £7.85\" (exact output depends on live exchange rates)\n * ```\n */\nexport function formatValue(value: Value, settings?: FormattingSettings): string {\n  const us = settings || DEFAULT_FORMATTING_SETTINGS;\n  const localeCode = us.numberResult.decimalSeparatorLocale || \"en\";\n  const locale = getLocale(localeCode);\n\n  switch (value.type) {\n    case ValueType.Number:\n      // A measurement with a tolerance renders as \"center ± spread\"; every\n      // other number is unchanged, so a plain value is byte-for-byte what it was.\n      if (value.uncertainty !== undefined) {\n        return formatUncertain(value.value as number, value.uncertainty, locale, us);\n      }\n      return formatNumber(value.value as number, locale, us, value.decimalPlaces);\n    case ValueType.Hex:\n      return formatHex(value.value as number | bigint, us, value.unit);\n    case ValueType.BigInt:\n      return formatBigInt(value.value as bigint);\n    case ValueType.String:\n      return formatString(value.value as string);\n    case ValueType.Boolean:\n      return formatBoolean(value.value as boolean);\n    case ValueType.Datetime:\n      return formatDatetime(value.value as number, locale);\n    case ValueType.Uom:\n      return formatUom(value.value as number, value.unit, locale, us, value.exact);\n    case ValueType.Matrix:\n      return formatMatrix(value.value as MatrixData, locale, us);\n    case ValueType.Range: {\n      const r = value.value as RangeData;\n      return formatRange(r.min, r.max, locale);\n    }\n    case ValueType.Colour:\n      return `${locale.display.resultPrefix}${formatColour(value.value as ColourData)}`;\n    case ValueType.Split:\n      return formatSplit(value.value as SplitData, locale, us);\n    case ValueType.Symbolic:\n      return formatSymbolic(value.value as SymbolicNode);\n    case ValueType.Percentage:\n      return formatPercentage(value.value as number, locale, us);\n    case ValueType.Unit:\n      return formatUnit(value.value as number, value.unit);\n    case ValueType.Error:\n      // errorValue(code, message) stores the human-readable message in\n      // `.unit` (code goes in `.value`), falling through to the default\n      // case here previously displayed the raw code (e.g.\n      // \"CURRENCY_RATE_UNAVAILABLE\") instead of the actual message.\n      return value.unit ?? String(value.value);\n    default:\n      return `= ${String(value.value)}`;\n  }\n}\n"]}

package/dist/{chunk-WWQEY7BV.js → chunk-ZN6YYPIW.js}

@@ -1,4 +1,4 @@
-import { ErrorCategory, EngineError, ErrorFactory } from './chunk-ERCOHGXD.js';
+import { ErrorCategory, EngineError, ErrorFactory } from './chunk-N7OA4WPJ.js';
 
 // src/errors/WorkerError.ts
 var WorkerErrorCodes = {
@@ -63,5 +63,5 @@ function workerTransportError(detail) {
 }
 
 export { WorkerErrorCodes, deserializeEngineError, serializeEngineError, workerCancelledError, workerTerminatedError, workerTransportError };
-//# sourceMappingURL=chunk-WWQEY7BV.js.map
-//# sourceMappingURL=chunk-WWQEY7BV.js.map
+//# sourceMappingURL=chunk-ZN6YYPIW.js.map
+//# sourceMappingURL=chunk-ZN6YYPIW.js.map

package/dist/{chunk-WWQEY7BV.js.map → chunk-ZN6YYPIW.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/errors/WorkerError.ts"],"names":[],"mappings":";;;AAoBO,IAAM,gBAAA,GAAmB;AAAA;AAAA,EAE/B,gBAAA,EAAkB,kBAAA;AAAA;AAAA,EAElB,iBAAA,EAAmB,mBAAA;AAAA;AAAA,EAEnB,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,qBAAA,EAAuB,uBAAA;AAAA;AAAA,EAEvB,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,sBAAA,EAAwB;AACzB;AAyBO,SAAS,qBAAqB,KAAA,EAA2C;AAC/E,EAAA,MAAM,GAAA,GAA6B;AAAA,IAClC,MAAM,KAAA,CAAM,IAAA;AAAA,IACZ,UAAU,KAAA,CAAM,QAAA;AAAA,IAChB,MAAM,KAAA,CAAM,IAAA;AAAA,IACZ,SAAS,KAAA,CAAM,OAAA;AAAA,IACf,aAAa,KAAA,CAAM;AAAA,GACpB;AAIA,EAAA,IAAI,KAAA,CAAM,QAAA,KAAa,MAAA,EAAW,GAAA,CAAI,WAAW,KAAA,CAAM,QAAA;AACvD,EAAA,IAAI,KAAA,CAAM,KAAA,KAAU,MAAA,EAAW,GAAA,CAAI,QAAQ,KAAA,CAAM,KAAA;AACjD,EAAA,IAAI,KAAA,CAAM,UAAA,KAAe,MAAA,EAAW,GAAA,CAAI,aAAa,KAAA,CAAM,UAAA;AAG3D,EAAA,IAAI,KAAA,CAAM,IAAA,KAAS,MAAA,EAAW,GAAA,CAAI,OAAO,KAAA,CAAM,IAAA;AAC/C,EAAA,OAAO,GAAA;AACR;AAWO,SAAS,uBAAuB,GAAA,EAAyC;AAC/E,EAAA,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO,aAAa,EAAE,QAAA,CAAS,GAAA,CAAI,QAAQ,CAAA,GAChE,GAAA,CAAI,QAAA,GAAA,UAAA;AAEP,EAAA,OAAO,IAAI,YAAY,QAAA,EAAU;AAAA,IAChC,MAAM,GAAA,CAAI,IAAA;AAAA,IACV,SAAS,GAAA,CAAI,OAAA;AAAA,IACb,UAAU,GAAA,CAAI,QAAA;AAAA,IACd,OAAO,GAAA,CAAI,KAAA;AAAA,IACX,YAAY,GAAA,CAAI,UAAA;AAAA,IAChB,aAAa,GAAA,CAAI,WAAA;AAAA,IACjB,MAAM,GAAA,CAAI;AAAA,GACV,CAAA;AACF;AAGO,SAAS,qBAAqB,MAAA,EAA8B;AAClE,EAAA,OAAO,YAAA,CAAa,SAAA;AAAA,IACnB,gBAAA,CAAiB,gBAAA;AAAA,IACjB,MAAA,GACG,CAAA,oBAAA,EAAuB,MAAM,CAAA,eAAA,CAAA,GAC7B,kCAAA;AAAA,IACH,MAAA,GAAS,EAAE,MAAA,EAAO,GAAI;AAAA,GACvB;AACD;AAGO,SAAS,qBAAA,GAAqC;AACpD,EAAA,OAAO,YAAA,CAAa,SAAA;AAAA,IACnB,gBAAA,CAAiB,iBAAA;AAAA,IACjB;AAAA,GACD;AACD;AAGO,SAAS,qBAAqB,MAAA,EAA6B;AACjE,EAAA,OAAO,YAAA,CAAa,QAAA;AAAA,IACnB,gBAAA,CAAiB,uBAAA;AAAA,IACjB,gCAAgC,MAAM,CAAA,CAAA;AAAA,IACtC,EAAE,MAAA;AAAO,GACV;AACD","file":"chunk-WWQEY7BV.js","sourcesContent":["/**\n * Structured errors for the off-main-thread worker harness, and the pair of\n * functions that carry an {@link EngineError} across a `postMessage` boundary.\n *\n * A worker runs in another thread, so a failure there cannot be `throw`n back\n * into the caller's stack. It has to be encoded, posted, and rebuilt on the\n * main side, and it must arrive as a real structured error rather than a lost\n * promise or an opaque string. {@link serializeEngineError} projects an\n * `EngineError` onto a plain, clone-safe object; {@link deserializeEngineError}\n * rebuilds one from that object so the main-side `catch` sees the same\n * `code`/`category`/`message` it would have seen in-process.\n */\n\nimport { EngineError, ErrorCategory, ErrorFactory, type SourceSpan } from \"./EngineError\";\n\n/**\n * Codes the worker harness owns, co-located here rather than unioned into the\n * core catalog, matching the convention `errors/ErrorCode.ts` documents for a\n * domain that keeps its own small code object.\n */\nexport const WorkerErrorCodes = {\n\t/** The caller aborted the request through its `AbortSignal`. */\n\tWORKER_CANCELLED: \"WORKER_CANCELLED\",\n\t/** The worker engine was torn down while a request was still in flight. */\n\tWORKER_TERMINATED: \"WORKER_TERMINATED\",\n\t/** The transport failed or the worker exited before answering. */\n\tWORKER_TRANSPORT_FAILED: \"WORKER_TRANSPORT_FAILED\",\n\t/** A request named a method the runtime does not expose. */\n\tWORKER_UNKNOWN_METHOD: \"WORKER_UNKNOWN_METHOD\",\n\t/** A request arrived before the runtime finished building its engine. */\n\tWORKER_NOT_INITIALISED: \"WORKER_NOT_INITIALISED\",\n\t/** An init named a package the runtime could not resolve. */\n\tWORKER_UNKNOWN_PACKAGE: \"WORKER_UNKNOWN_PACKAGE\",\n} as const;\n\n/**\n * A structured error flattened for transport.\n *\n * Every field is a string, a boolean, or an object of numbers, so the whole\n * thing survives both `structuredClone` (what `postMessage` uses) and\n * `JSON.stringify` (what a host may log). `context`, `cause` and `timestamp`\n * are deliberately dropped rather than posted: a context can hold a value that\n * is not clone-safe, and none of the three is part of what a main-side handler\n * branches on.\n */\nexport interface SerializedEngineError {\n\tname: string;\n\tcategory: ErrorCategory;\n\tcode: string;\n\tmessage: string;\n\texpected?: string;\n\tfound?: string;\n\tsuggestion?: string;\n\trecoverable: boolean;\n\tspan?: SourceSpan;\n}\n\n/** Flatten an {@link EngineError} into a clone-safe {@link SerializedEngineError}. */\nexport function serializeEngineError(error: EngineError): SerializedEngineError {\n\tconst dto: SerializedEngineError = {\n\t\tname: error.name,\n\t\tcategory: error.category,\n\t\tcode: error.code,\n\t\tmessage: error.message,\n\t\trecoverable: error.recoverable,\n\t};\n\t// Only the optional string fields that were actually set cross the wire, so\n\t// a rebuilt error has `undefined` exactly where the original did rather than\n\t// an explicit `undefined` property a deep-equal would trip on.\n\tif (error.expected !== undefined) dto.expected = error.expected;\n\tif (error.found !== undefined) dto.found = error.found;\n\tif (error.suggestion !== undefined) dto.suggestion = error.suggestion;\n\t// A span is character offsets (plain numbers), so it is safe to carry and\n\t// useful for a host that highlights the failing range.\n\tif (error.span !== undefined) dto.span = error.span;\n\treturn dto;\n}\n\n/**\n * Rebuild an {@link EngineError} from its transported form.\n *\n * The category string round-trips straight back into the `ErrorCategory` enum\n * (its members ARE their own string values), so a main-side `catch` reads the\n * same category the worker raised. A malformed category (a message that was not\n * produced by {@link serializeEngineError}) falls back to `INTERNAL` rather than\n * constructing an error with an invalid category.\n */\nexport function deserializeEngineError(dto: SerializedEngineError): EngineError {\n\tconst category = Object.values(ErrorCategory).includes(dto.category)\n\t\t? dto.category\n\t\t: ErrorCategory.INTERNAL;\n\treturn new EngineError(category, {\n\t\tcode: dto.code,\n\t\tmessage: dto.message,\n\t\texpected: dto.expected,\n\t\tfound: dto.found,\n\t\tsuggestion: dto.suggestion,\n\t\trecoverable: dto.recoverable,\n\t\tspan: dto.span,\n\t});\n}\n\n/** The error a request rejects with when its caller aborts through an `AbortSignal`. */\nexport function workerCancelledError(method?: string): EngineError {\n\treturn ErrorFactory.execution(\n\t\tWorkerErrorCodes.WORKER_CANCELLED,\n\t\tmethod\n\t\t\t? `The worker request \"${method}\" was cancelled`\n\t\t\t: \"The worker request was cancelled\",\n\t\tmethod ? { method } : undefined,\n\t);\n}\n\n/** The error every pending request rejects with when the worker engine is terminated. */\nexport function workerTerminatedError(): EngineError {\n\treturn ErrorFactory.execution(\n\t\tWorkerErrorCodes.WORKER_TERMINATED,\n\t\t\"The worker engine was terminated before this request completed\",\n\t);\n}\n\n/** The error a request rejects with when the transport fails or the worker exits early. */\nexport function workerTransportError(detail: string): EngineError {\n\treturn ErrorFactory.external(\n\t\tWorkerErrorCodes.WORKER_TRANSPORT_FAILED,\n\t\t`The worker transport failed: ${detail}`,\n\t\t{ detail },\n\t);\n}\n"]}
+{"version":3,"sources":["../src/errors/WorkerError.ts"],"names":[],"mappings":";;;AAoBO,IAAM,gBAAA,GAAmB;AAAA;AAAA,EAE/B,gBAAA,EAAkB,kBAAA;AAAA;AAAA,EAElB,iBAAA,EAAmB,mBAAA;AAAA;AAAA,EAEnB,uBAAA,EAAyB,yBAAA;AAAA;AAAA,EAEzB,qBAAA,EAAuB,uBAAA;AAAA;AAAA,EAEvB,sBAAA,EAAwB,wBAAA;AAAA;AAAA,EAExB,sBAAA,EAAwB;AACzB;AAyBO,SAAS,qBAAqB,KAAA,EAA2C;AAC/E,EAAA,MAAM,GAAA,GAA6B;AAAA,IAClC,MAAM,KAAA,CAAM,IAAA;AAAA,IACZ,UAAU,KAAA,CAAM,QAAA;AAAA,IAChB,MAAM,KAAA,CAAM,IAAA;AAAA,IACZ,SAAS,KAAA,CAAM,OAAA;AAAA,IACf,aAAa,KAAA,CAAM;AAAA,GACpB;AAIA,EAAA,IAAI,KAAA,CAAM,QAAA,KAAa,MAAA,EAAW,GAAA,CAAI,WAAW,KAAA,CAAM,QAAA;AACvD,EAAA,IAAI,KAAA,CAAM,KAAA,KAAU,MAAA,EAAW,GAAA,CAAI,QAAQ,KAAA,CAAM,KAAA;AACjD,EAAA,IAAI,KAAA,CAAM,UAAA,KAAe,MAAA,EAAW,GAAA,CAAI,aAAa,KAAA,CAAM,UAAA;AAG3D,EAAA,IAAI,KAAA,CAAM,IAAA,KAAS,MAAA,EAAW,GAAA,CAAI,OAAO,KAAA,CAAM,IAAA;AAC/C,EAAA,OAAO,GAAA;AACR;AAWO,SAAS,uBAAuB,GAAA,EAAyC;AAC/E,EAAA,MAAM,QAAA,GAAW,OAAO,MAAA,CAAO,aAAa,EAAE,QAAA,CAAS,GAAA,CAAI,QAAQ,CAAA,GAChE,GAAA,CAAI,QAAA,GAAA,UAAA;AAEP,EAAA,OAAO,IAAI,YAAY,QAAA,EAAU;AAAA,IAChC,MAAM,GAAA,CAAI,IAAA;AAAA,IACV,SAAS,GAAA,CAAI,OAAA;AAAA,IACb,UAAU,GAAA,CAAI,QAAA;AAAA,IACd,OAAO,GAAA,CAAI,KAAA;AAAA,IACX,YAAY,GAAA,CAAI,UAAA;AAAA,IAChB,aAAa,GAAA,CAAI,WAAA;AAAA,IACjB,MAAM,GAAA,CAAI;AAAA,GACV,CAAA;AACF;AAGO,SAAS,qBAAqB,MAAA,EAA8B;AAClE,EAAA,OAAO,YAAA,CAAa,SAAA;AAAA,IACnB,gBAAA,CAAiB,gBAAA;AAAA,IACjB,MAAA,GACG,CAAA,oBAAA,EAAuB,MAAM,CAAA,eAAA,CAAA,GAC7B,kCAAA;AAAA,IACH,MAAA,GAAS,EAAE,MAAA,EAAO,GAAI;AAAA,GACvB;AACD;AAGO,SAAS,qBAAA,GAAqC;AACpD,EAAA,OAAO,YAAA,CAAa,SAAA;AAAA,IACnB,gBAAA,CAAiB,iBAAA;AAAA,IACjB;AAAA,GACD;AACD;AAGO,SAAS,qBAAqB,MAAA,EAA6B;AACjE,EAAA,OAAO,YAAA,CAAa,QAAA;AAAA,IACnB,gBAAA,CAAiB,uBAAA;AAAA,IACjB,gCAAgC,MAAM,CAAA,CAAA;AAAA,IACtC,EAAE,MAAA;AAAO,GACV;AACD","file":"chunk-ZN6YYPIW.js","sourcesContent":["/**\n * Structured errors for the off-main-thread worker harness, and the pair of\n * functions that carry an {@link EngineError} across a `postMessage` boundary.\n *\n * A worker runs in another thread, so a failure there cannot be `throw`n back\n * into the caller's stack. It has to be encoded, posted, and rebuilt on the\n * main side, and it must arrive as a real structured error rather than a lost\n * promise or an opaque string. {@link serializeEngineError} projects an\n * `EngineError` onto a plain, clone-safe object; {@link deserializeEngineError}\n * rebuilds one from that object so the main-side `catch` sees the same\n * `code`/`category`/`message` it would have seen in-process.\n */\n\nimport { EngineError, ErrorCategory, ErrorFactory, type SourceSpan } from \"./EngineError\";\n\n/**\n * Codes the worker harness owns, co-located here rather than unioned into the\n * core catalog, matching the convention `errors/ErrorCode.ts` documents for a\n * domain that keeps its own small code object.\n */\nexport const WorkerErrorCodes = {\n\t/** The caller aborted the request through its `AbortSignal`. */\n\tWORKER_CANCELLED: \"WORKER_CANCELLED\",\n\t/** The worker engine was torn down while a request was still in flight. */\n\tWORKER_TERMINATED: \"WORKER_TERMINATED\",\n\t/** The transport failed or the worker exited before answering. */\n\tWORKER_TRANSPORT_FAILED: \"WORKER_TRANSPORT_FAILED\",\n\t/** A request named a method the runtime does not expose. */\n\tWORKER_UNKNOWN_METHOD: \"WORKER_UNKNOWN_METHOD\",\n\t/** A request arrived before the runtime finished building its engine. */\n\tWORKER_NOT_INITIALISED: \"WORKER_NOT_INITIALISED\",\n\t/** An init named a package the runtime could not resolve. */\n\tWORKER_UNKNOWN_PACKAGE: \"WORKER_UNKNOWN_PACKAGE\",\n} as const;\n\n/**\n * A structured error flattened for transport.\n *\n * Every field is a string, a boolean, or an object of numbers, so the whole\n * thing survives both `structuredClone` (what `postMessage` uses) and\n * `JSON.stringify` (what a host may log). `context`, `cause` and `timestamp`\n * are deliberately dropped rather than posted: a context can hold a value that\n * is not clone-safe, and none of the three is part of what a main-side handler\n * branches on.\n */\nexport interface SerializedEngineError {\n\tname: string;\n\tcategory: ErrorCategory;\n\tcode: string;\n\tmessage: string;\n\texpected?: string;\n\tfound?: string;\n\tsuggestion?: string;\n\trecoverable: boolean;\n\tspan?: SourceSpan;\n}\n\n/** Flatten an {@link EngineError} into a clone-safe {@link SerializedEngineError}. */\nexport function serializeEngineError(error: EngineError): SerializedEngineError {\n\tconst dto: SerializedEngineError = {\n\t\tname: error.name,\n\t\tcategory: error.category,\n\t\tcode: error.code,\n\t\tmessage: error.message,\n\t\trecoverable: error.recoverable,\n\t};\n\t// Only the optional string fields that were actually set cross the wire, so\n\t// a rebuilt error has `undefined` exactly where the original did rather than\n\t// an explicit `undefined` property a deep-equal would trip on.\n\tif (error.expected !== undefined) dto.expected = error.expected;\n\tif (error.found !== undefined) dto.found = error.found;\n\tif (error.suggestion !== undefined) dto.suggestion = error.suggestion;\n\t// A span is character offsets (plain numbers), so it is safe to carry and\n\t// useful for a host that highlights the failing range.\n\tif (error.span !== undefined) dto.span = error.span;\n\treturn dto;\n}\n\n/**\n * Rebuild an {@link EngineError} from its transported form.\n *\n * The category string round-trips straight back into the `ErrorCategory` enum\n * (its members ARE their own string values), so a main-side `catch` reads the\n * same category the worker raised. A malformed category (a message that was not\n * produced by {@link serializeEngineError}) falls back to `INTERNAL` rather than\n * constructing an error with an invalid category.\n */\nexport function deserializeEngineError(dto: SerializedEngineError): EngineError {\n\tconst category = Object.values(ErrorCategory).includes(dto.category)\n\t\t? dto.category\n\t\t: ErrorCategory.INTERNAL;\n\treturn new EngineError(category, {\n\t\tcode: dto.code,\n\t\tmessage: dto.message,\n\t\texpected: dto.expected,\n\t\tfound: dto.found,\n\t\tsuggestion: dto.suggestion,\n\t\trecoverable: dto.recoverable,\n\t\tspan: dto.span,\n\t});\n}\n\n/** The error a request rejects with when its caller aborts through an `AbortSignal`. */\nexport function workerCancelledError(method?: string): EngineError {\n\treturn ErrorFactory.execution(\n\t\tWorkerErrorCodes.WORKER_CANCELLED,\n\t\tmethod\n\t\t\t? `The worker request \"${method}\" was cancelled`\n\t\t\t: \"The worker request was cancelled\",\n\t\tmethod ? { method } : undefined,\n\t);\n}\n\n/** The error every pending request rejects with when the worker engine is terminated. */\nexport function workerTerminatedError(): EngineError {\n\treturn ErrorFactory.execution(\n\t\tWorkerErrorCodes.WORKER_TERMINATED,\n\t\t\"The worker engine was terminated before this request completed\",\n\t);\n}\n\n/** The error a request rejects with when the transport fails or the worker exits early. */\nexport function workerTransportError(detail: string): EngineError {\n\treturn ErrorFactory.external(\n\t\tWorkerErrorCodes.WORKER_TRANSPORT_FAILED,\n\t\t`The worker transport failed: ${detail}`,\n\t\t{ detail },\n\t);\n}\n"]}

package/dist/{chunk-NNQ2TYDF.js → chunk-ZNFFTYWH.js}

@@ -1,5 +1,5 @@
-import { boolValue, symbolicValue, numberValue, matrixValue, errorValue, checkedArray, faultedOperand } from './chunk-267JPOTF.js';
-import { ErrorFactory } from './chunk-ERCOHGXD.js';
+import { boolValue, symbolicValue, numberValue, matrixValue, errorValue, checkedArray, faultedOperand } from './chunk-5EFKSKMA.js';
+import { ErrorFactory } from './chunk-N7OA4WPJ.js';
 
 // src/decimal/Decimal.ts
 var DEFAULT_DIVISION_SCALE = 20;
@@ -11,6 +11,12 @@ function pow10(n) {
   for (let i = POW10.length; i <= n; i++) POW10[i] = POW10[i - 1] * 10n;
   return POW10[n];
 }
+function makeDecimal(coef, scale) {
+  if (!Number.isInteger(scale) || scale < 0) {
+    throw ErrorFactory.internal("DECIMAL_INVALID_SCALE", `A decimal scale must be a non-negative integer, got ${scale}`, { scale });
+  }
+  return { coef, scale };
+}
 function decimalFromInteger(n) {
   return { coef: typeof n === "bigint" ? n : BigInt(n), scale: 0 };
 }
@@ -1843,6 +1849,6 @@ var CURRENCY_DISPLAY = {
   CZK: { symbol: "K\u010D", position: "suffix", spaced: true }
 };
 
-export { COMPLEX_I, CURRENCY_DISPLAY, RATIONAL_ONE, RATIONAL_ZERO, callNode, cancelSymbolic, coefficientGcd, collectionToValues, columnMajorToRowMajor, compareMonomials, complex, complexNode, constNode, decimalAdd, decimalCompare, decimalDivide, decimalFromInteger, decimalFromLiteral, decimalFromNumberIfExact, decimalIsZero, decimalMultiply, decimalNegate, decimalRound, decimalSubtract, decimalToFixed, decimalToNumber, determinant, exactIntegerCbrt, exactIntegerSqrt, exactRationalSqrt2 as exactRationalSqrt, expandSymbolic, formatSymbolic, freeVariables, fromPolynomial, inBounds, inverse, isRationalOne, isRationalZero, isZeroPolynomial, matAt, matIndex, matrixCompare, matrixEntryToValue, matrixMultiply, matrixPower, monomialFromKey, monomialToKey, polyCoefficients, polyDegree, polyUnivariateVar, polynomialDivide, powNode, rational, rationalAdd, rationalCompare, rationalDiv, rationalFromNumber, rationalMul, rationalNeg, rationalSub, rationalToNumber, resolveCurrencyAlias, rowMajorToColumnMajor, sameShape, signedSurdNode, simplifySymbolic, squareFreePart, substitute, surdNode, symbolicKey, symbolicToEntry, toPolynomial, transpose, varNode };
-//# sourceMappingURL=chunk-NNQ2TYDF.js.map
-//# sourceMappingURL=chunk-NNQ2TYDF.js.map
+export { COMPLEX_I, CURRENCY_DISPLAY, RATIONAL_ONE, RATIONAL_ZERO, callNode, cancelSymbolic, coefficientGcd, collectionToValues, columnMajorToRowMajor, compareMonomials, complex, complexNode, constNode, decimalAdd, decimalCompare, decimalDivide, decimalFromInteger, decimalFromLiteral, decimalFromNumberIfExact, decimalIsZero, decimalMultiply, decimalNegate, decimalRound, decimalSubtract, decimalToFixed, decimalToNumber, determinant, exactIntegerCbrt, exactIntegerSqrt, exactRationalSqrt2 as exactRationalSqrt, expandSymbolic, formatSymbolic, freeVariables, fromPolynomial, inBounds, inverse, isRationalOne, isRationalZero, isZeroPolynomial, makeDecimal, matAt, matIndex, matrixCompare, matrixEntryToValue, matrixMultiply, matrixPower, monomialFromKey, monomialToKey, polyCoefficients, polyDegree, polyUnivariateVar, polynomialDivide, powNode, rational, rationalAdd, rationalCompare, rationalDiv, rationalFromNumber, rationalMul, rationalNeg, rationalSub, rationalToNumber, resolveCurrencyAlias, rowMajorToColumnMajor, sameShape, signedSurdNode, simplifySymbolic, squareFreePart, substitute, surdNode, symbolicKey, symbolicToEntry, toPolynomial, transpose, varNode };
+//# sourceMappingURL=chunk-ZNFFTYWH.js.map
+//# sourceMappingURL=chunk-ZNFFTYWH.js.map