solve-engine 2.23.0 → 2.25.0

package/dist/chunk-FP6Z6PYR.js

@@ -1,2 +0,0 @@
-import {d}from'./chunk-JPFCXLJV.js';import {b}from'./chunk-AF7HQN6I.js';import {a}from'./chunk-LHLW7JLS.js';import {a as a$1}from'./chunk-CHVGFTO3.js';var u=(s=>(s.Main="main",s.Inline="inline",s.String="string",s))(u||{});var l=class{constructor(e="en",t){this.currentState="main";this.hasPeeked=false;this.tokens=[];this.tokenIdx=0;this.expressionLexer=new b(e,t);}reset(e,t){let s=t??"main";if(this.currentState=s,this.hasPeeked=false,this.peekedToken=void 0,s==="main"){if(this.expressionLexer.classifyLine(e).skip){this.tokens=[],this.tokenIdx=0;return}this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}else this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}classifyLine(e){return this.expressionLexer.classifyLine(e)}findInlineSolves(e){return this.expressionLexer.findInlineSolves(e)}getKeywords(){return this.expressionLexer.getKeywords()}next(){if(this.hasPeeked)return this.hasPeeked=false,this.peekedToken;if(this.tokenIdx<this.tokens.length)return this.tokens[this.tokenIdx++]}peek(){return this.hasPeeked?this.peekedToken:(this.peekedToken=this.next(),this.hasPeeked=true,this.peekedToken)}[Symbol.iterator](){return this.tokens[Symbol.iterator]()}registerVocabulary(e){this.expressionLexer.registerVocabulary(e);}unregisterVocabulary(e){this.expressionLexer.unregisterVocabulary(e);}resetExpression(e){this.currentState="main",this.hasPeeked=false,this.peekedToken=void 0,this.expressionLexer.reset(e),this.tokens=this.expressionLexer.tokenizeAll(),this.tokenIdx=0;}scanDocument(e){return this.expressionLexer.scanDocument(e)}getState(){return this.currentState}setState(e){this.currentState=e;}getHighlightTokens(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectHighlightTokens(e.slice(2)):t.skip?[]:this.collectHighlightTokens(e)}getHighlightTokenObjects(e){let t=this.expressionLexer.classifyLine(e);return t.skip&&e.startsWith("> ")?this.collectTokenObjects(e.slice(2)):t.skip?[]:this.collectTokenObjects(e)}collectTokenObjects(e){this.resetExpression(e);let t=[];for(let s of this)s.type==="WS"||s.type==="NEWLINE"||s.type.startsWith("MD_")||s.type==="INLINE_SOLVE_START"||s.type==="BACKTICK_CLOSE"||t.push(s);return t}collectHighlightTokens(e){return this.collectTokenObjects(e).map(t=>({type:t.type,value:t.value,offset:t.offset,col:t.col,length:t.text.length,category:d(t.type)}))}},T=new l("en",void 0);var n=class{constructor(){this.classes=[];this.localeKeywordMap=null;this.localePhraseMap=null;this.unitNames=null;}register(e){this.classes.push(e);}unregister(e){this.classes=this.classes.filter(t=>t.tokenType!==e);}setLocale(e,t){this.localeKeywordMap=e,this.localePhraseMap=t??null;}setUnits(e){this.unitNames=e;}build(){let e=new Map;if(this.localeKeywordMap)for(let[r,i]of Object.entries(this.localeKeywordMap))e.set(r.toLowerCase(),i);let t=[...this.classes].sort((r,i)=>(r.priority??0)-(i.priority??0));for(let r of t)for(let i of Object.keys(r.keywords))e.set(i.toLowerCase(),r.tokenType);let s=this.buildPhraseTrie(),o=this.buildPhraseStartWords();return {keywordToType:e,phraseTrie:s,phraseStartWords:o,unitNames:this.unitNames??new Set}}buildPhraseTrie(){let e={children:new Map};if(this.localePhraseMap)for(let[t,s]of Object.entries(this.localePhraseMap))this.insertPhrase(e,t.toLowerCase(),s);for(let t of this.classes)if(t.phrases)for(let s of Object.keys(t.phrases))this.insertPhrase(e,s.toLowerCase(),t.tokenType);return e.children.size>0?e:null}insertPhrase(e,t,s){let o=t.split(" "),r=e;for(let i of o)r.children.has(i)||r.children.set(i,{children:new Map}),r=r.children.get(i);r.type||(r.type=s);}buildPhraseStartWords(){let e=new Set;if(this.localePhraseMap)for(let t of Object.keys(this.localePhraseMap)){let s=t.split(" ")[0].toLowerCase();e.add(s);}for(let t of this.classes)if(t.phrases)for(let s of Object.keys(t.phrases)){let o=s.split(" ")[0].toLowerCase();e.add(o);}return e}};var k={"to the power of":"CARET","power of":"CARET","increase by":"INCREASE_BY","decrease by":"DECREASE_BY","times by":"TIMES_BY","multiply by":"MULTIPLY_BY","multiplied by":"MULTIPLY_BY","divide by":"DIVIDE_BY"};function P(a$2="en"){let e=a(a$2),t=new n;return t.setLocale(e.keywordMap,k),t.setUnits(a$1),t.build()}export{u as a,l as b,T as c,P as d};//# sourceMappingURL=chunk-FP6Z6PYR.js.map
-//# sourceMappingURL=chunk-FP6Z6PYR.js.map

package/dist/chunk-FP6Z6PYR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lexer/LexerState.ts","../src/lexer/Lexer.ts","../src/lexer/TokenClassRegistry.ts","../src/lexer/tokenRegistration.ts"],"names":["LexerState","Lexer","localeCode","tokenLookup","ExpressionLexer","input","state","newState","lineText","plugin","text","classification","result","token","getTokenCategory","sharedLexer","TokenClassRegistry","tokenClass","tokenType","c","keywordMap","phraseMap","unitNames","keywordToType","keyword","sorted","a","b","tc","phraseTrie","phraseStartWords","root","phrase","words","node","word","startWords","first","BUILTIN_PHRASES","buildTokenLookup","locale","getLocale","registry","knownUnits"],"mappings":"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","file":"chunk-FP6Z6PYR.js","sourcesContent":["/**\n * Lexer state machine modes.\n * - Main: document-level scanning with markdown classification\n * - Inline: expression embedded in markdown inline solve (`s\\`...\\``)\n * - String: inside a double-quoted string literal\n */\nexport enum LexerState {\n\tMain = \"main\",\n\tInline = \"inline\",\n\tString = \"string\",\n}\n","import { ExpressionLexer, LineClassification, LexerVocabulary, type ScanLineResult } from \"./ExpressionLexer\";\nimport { Token } from \"@solve-js/lexer/Token\";\nimport { LexerState } from \"@solve-js/lexer/LexerState\";\nimport { getTokenCategory } from \"@solve-js/language/TokenCategoryMap\";\nimport type { TokenCategory } from \"@solve-js/language/TokenCategory\";\nimport type { TokenLookup } from \"@solve-js/lexer/TokenClassRegistry\";\n\n/**\n * Public tokenizer wrapper around {@link ExpressionLexer}.\n *\n * `ExpressionLexer` does the actual character-by-character scanning;\n * `Lexer` adds a materialized-token-array streaming interface\n * (`next()`/`peek()`) plus line-classification state (`reset()`) so\n * callers can iterate a line's tokens without re-scanning on each peek.\n *\n * Each `ExpressionEngine` instance owns its own `Lexer`, and packages\n * extend it via {@link registerVocabulary} (keywords, operators, units)\n * see `IEnginePackage.lexerVocabulary`.\n */\nexport class Lexer {\n  /** Expression-mode lexer (Phase A: V8-optimized, replaces moo) */\n  private expressionLexer: ExpressionLexer;\n  private currentState: LexerState = LexerState.Main;\n  private peekedToken: Token | undefined;\n  private hasPeeked = false;\n\n  // Materialized token array from the last reset() call, used for\n  // next()/peek() streaming access.\n  private tokens: Token[] = [];\n  private tokenIdx: number = 0;\n\n  /**\n   * @param localeCode - Locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n   * @param tokenLookup - Optional TokenLookup from TokenClassRegistry.\n   *   When provided, configures ExpressionLexer to use registry-built\n   *   keyword/unit/phrase lookups instead of internal instance maps.\n   */\n  constructor(localeCode = \"en\", tokenLookup?: TokenLookup) {\n    // Pass the lookup directly to ExpressionLexer's constructor, it's an\n    // instance field now, not a static. Each Lexer instance gets its own\n    // isolated lookup, preventing cross-instance corruption.\n    this.expressionLexer = new ExpressionLexer(localeCode, tokenLookup);\n  }\n\n  reset(input: string, state?: LexerState): void {\n    const newState = state ?? LexerState.Main;\n    this.currentState = newState;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n\n    // Phase B: Main state classifies the line with the markdown scanner.\n    // Skip lines (headings, fences, HRs, etc.) produce empty token arrays.\n    // Expression lines and lines with inline solves are tokenized normally.\n    if (newState === LexerState.Main) {\n      const classification = this.expressionLexer.classifyLine(input);\n      if (classification.skip) {\n        this.tokens = [];\n        this.tokenIdx = 0;\n        return;\n      }\n      // Expression line or markdown line with inline solves, tokenize.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    } else {\n      // Non-main states (Inline, String), expression tokenization.\n      this.expressionLexer.reset(input);\n      this.tokens = this.expressionLexer.tokenizeAll();\n      this.tokenIdx = 0;\n    }\n  }\n\n  /**\n   * Classify a single line of markdown text (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  classifyLine(lineText: string): LineClassification {\n    return this.expressionLexer.classifyLine(lineText);\n  }\n\n  /**\n   * Find all inline solve markers in a line (Phase B).\n   * Delegates to the ExpressionLexer's character-by-character scanner.\n   */\n  findInlineSolves(lineText: string) {\n    return this.expressionLexer.findInlineSolves(lineText);\n  }\n\n  /**\n   * Every keyword this lexer currently recognizes (locale + plugin-contributed),\n   * mapped to the token type it lexes to. Delegates to the ExpressionLexer.\n   */\n  getKeywords(): Record<string, string> {\n    return this.expressionLexer.getKeywords();\n  }\n\n  next(): Token | undefined {\n    if (this.hasPeeked) {\n      this.hasPeeked = false;\n      return this.peekedToken;\n    }\n    // Materialized token array (ExpressionLexer path).\n    if (this.tokenIdx < this.tokens.length) {\n      return this.tokens[this.tokenIdx++];\n    }\n    return undefined;\n  }\n\n  peek(): Token | undefined {\n    if (this.hasPeeked) return this.peekedToken;\n    this.peekedToken = this.next();\n    this.hasPeeked = true;\n    return this.peekedToken;\n  }\n\n  [Symbol.iterator](): Iterator<Token> {\n    return this.tokens[Symbol.iterator]();\n  }\n\n  /**\n   * Register a plugin to extend the lexer with custom tokens.\n   * Delegates to the underlying ExpressionLexer.\n   *\n   * @see LexerVocabulary for the supported extension points.\n   */\n  registerVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.registerVocabulary(plugin);\n  }\n\n  /**\n   * Unregister a plugin, removing its custom tokens from the lexer.\n   * Delegates to the underlying ExpressionLexer.\n   */\n  unregisterVocabulary(plugin: LexerVocabulary): void {\n    this.expressionLexer.unregisterVocabulary(plugin);\n  }\n\n  /**\n   * Reset the lexer for expression-only text, skips the classifyLine()\n   * overhead in reset() for callers that already know the input is an\n   * evaluable expression (e.g., after isEmptyLine() confirmed non-skip).\n   */\n  resetExpression(input: string): void {\n    this.currentState = LexerState.Main;\n    this.hasPeeked = false;\n    this.peekedToken = undefined;\n    this.expressionLexer.reset(input);\n    this.tokens = this.expressionLexer.tokenizeAll();\n    this.tokenIdx = 0;\n  }\n\n  /**\n   * Scan a full document in one pass, classifying each line and\n   * tokenizing non-skipped lines. Delegates to ExpressionLexer.\n   *\n   * @returns ScanLineResult[], one per line, with classification + tokens.\n   */\n  scanDocument(text: string): ScanLineResult[] {\n    return this.expressionLexer.scanDocument(text);\n  }\n\n  getState(): LexerState {\n    return this.currentState;\n  }\n\n  setState(state: LexerState): void {\n    this.currentState = state;\n  }\n\n  getHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n\n    // For blockquote lines, strip the \"> \" prefix and tokenize the expression content.\n    // This lets expressions inside blockquotes (e.g., \"> 1 + 2\") get syntax highlighted\n    // while pure structural lines (headings, code fences) remain unhighlighted.\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectHighlightTokens(lineText.slice(2));\n    }\n\n    if (classification.skip) {\n      return [];\n    }\n\n    return this.collectHighlightTokens(lineText);\n  }\n\n  /**\n   * The same tokens {@link getHighlightTokens} reduces, before reduction.\n   *\n   * Exists because normalization operates on tokens, not on the flattened\n   * shape, and a consumer that wants phrase-fused highlighting has to run the\n   * normalizer between the two. See `LanguageService.getSemanticTokens`.\n   *\n   * @param lineText - One line of source.\n   * @returns Every token on the line that is worth painting, unreduced.\n   */\n  getHighlightTokenObjects(lineText: string): Token[] {\n    const classification = this.expressionLexer.classifyLine(lineText);\n    if (classification.skip && lineText.startsWith(\"> \")) {\n      return this.collectTokenObjects(lineText.slice(2));\n    }\n    if (classification.skip) return [];\n    return this.collectTokenObjects(lineText);\n  }\n\n  private collectTokenObjects(lineText: string): Token[] {\n    this.resetExpression(lineText);\n    const result: Token[] = [];\n    for (const token of this) {\n      if (token.type === \"WS\" || token.type === \"NEWLINE\") continue;\n      if (token.type.startsWith(\"MD_\")) continue;\n      if (token.type === \"INLINE_SOLVE_START\" || token.type === \"BACKTICK_CLOSE\") continue;\n      result.push(token);\n    }\n    return result;\n  }\n\n  private collectHighlightTokens(lineText: string): {type: string; value: string; offset: number; col: number; length: number; category: TokenCategory | undefined}[] {\n    return this.collectTokenObjects(lineText).map(token => ({\n      type: token.type,\n      value: token.value,\n      offset: token.offset,\n      col: token.col,\n      // `text`, not `value`: this is a span into the source, and the two\n      // differ for a string literal, whose value is the payload while its\n      // text still carries the quote characters the reader typed.\n      length: token.text.length,\n      category: getTokenCategory(token.type),\n    }));\n  }\n}\n\n/**\n * A lexer for operations that do not depend on registered vocabulary.\n *\n * Line classification and inline-solve detection read characters looking for\n * headings, comment markers, fences and backtick spans, and never consult the\n * keyword, unit or operator tables. Every lexer therefore returns the same\n * answer, so the callers that have no engine to ask can use this one. Checked\n * by `__tests__/lexer/LineClassificationIsVocabularyIndependent.spec.ts`.\n *\n * Do not tokenize with this. An engine's own lexer carries the vocabulary its\n * packages registered; this one carries none.\n */\nexport const sharedLexer = new Lexer(\"en\", undefined);","/**\n * TokenClass, Plugin-extensible keyword registration for the Lexer.\n *\n * Providers call `registry.register(tokenClass)` to teach the lexer about\n * their keywords. The registry merges locale keywords, provider keywords,\n * phrase mappings, and unit names into an optimized TokenLookup structure\n * consumed by the Lexer.\n *\n * @example\n * registry.register({\n *   tokenType: 'CARET',\n *   keywords: {},\n *   phrases: { 'to the power of': true, 'power of': true },\n *   priority: 10,\n *   description: 'Exponentiation operators (x^y)',\n * });\n */\nexport interface TokenClass {\n  /** The token type string produced by the lexer (e.g., \"FUNC\", \"PI\", \"CARET\").\n   *  Must match a token type that a ParseletRegistry has a parselet for. */\n  tokenType: string;\n\n  /** Single-word keywords (case-insensitive). The lexer lowercases input\n   *  before lookup, so these should be lowercase. Example:\n   *  { sqrt: true, abs: true, sin: true, cos: true } for tokenType \"FUNC\" */\n  keywords: Record<string, boolean>;\n\n  /** Multi-word phrases (case-insensitive). Matched by the built-in PhraseMatcher\n   *  via the phrase trie. Example:\n   *  { \"to the power of\": true, \"power of\": true } for tokenType \"CARET\" */\n  phrases?: Record<string, boolean>;\n\n  /** Priority for conflict resolution. When two TokenClasses register\n   *  the same keyword, the higher-priority class wins. Locale keywords\n   *  have priority 0 (set via setLocale). Providers should use\n   *  priority >= 10 to override locale defaults. Default: 0 */\n  priority?: number;\n\n  /** Human-readable description for debugging and introspection */\n  description?: string;\n}\n\n// ── Phrase Trie ──────────────────────────────────────────────────────────────\n\n/** Trie node for multi-word phrase matching. */\nexport interface PhraseNode {\n  /** Complete phrase token type (null = intermediate node) */\n  type?: string;\n  children: Map<string, PhraseNode>;\n}\n\n// ── TokenLookup, Optimized lookup structure for the Lexer ──────────────────\n\n/**\n * The optimized lookup structure built by TokenClassRegistry.build().\n * Consumed by the Lexer for O(1) keyword → token type lookups and\n * O(word-count) phrase matching.\n */\nexport interface TokenLookup {\n  /** Lowercase keyword → token type. O(1) Map lookup. */\n  keywordToType: Map<string, string>;\n\n  /** Phrase trie for multi-word matching. Root node with children maps.\n   *  Null if no phrases registered. */\n  phraseTrie: PhraseNode | null;\n\n  /** Set of lowercase first-words of all registered phrases.\n   *  Used by the lexer to emit IDENT (not a phrase keyword) for words\n   *  that start multi-word phrases, deferring to the PhraseMatcher.\n   *\n   *  Example: \"to\" is in phraseStartWords because \"to the power of\" is a phrase.\n   *  When the lexer sees \"to\", it emits IDENT and lets the phrase matcher\n   *  combine \"to the power of\" into a single CARET token.\n   *\n   *  This prevents plugins from accidentally overriding phrase-start words.\n   */\n  phraseStartWords: Set<string>;\n\n  /** Case-sensitive unit names for UNIT fallback after keyword lookup fails. */\n  unitNames: ReadonlySet<string>;\n}\n\n// ── TokenClassRegistry ───────────────────────────────────────────────────────\n\n/**\n * Central registry for keyword→token-type mappings.\n *\n * Providers register TokenClasses; locales provide keyword maps;\n * units provide a name set. `build()` merges all sources into an\n * optimized TokenLookup consumed by the Lexer.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0)\n *   2. Provider keywords (sorted by priority ascending, higher priority wins)\n *\n * Unit names are stored separately (checked AFTER keyword lookup fails).\n * Phrases are stored in a trie for O(phrase-length) matching.\n */\nexport class TokenClassRegistry {\n  private classes: TokenClass[] = [];\n  private localeKeywordMap: Record<string, string> | null = null;\n  private localePhraseMap: Record<string, string> | null = null;\n  private unitNames: ReadonlySet<string> | null = null;\n\n  /**\n   * Register a provider's TokenClass. Must be called BEFORE build().\n   * Can be called multiple times to add more entries.\n   *\n   * Built-in token types CANNOT be overridden, throws a EngineError\n   * if the TokenClass attempts to register a keyword that conflicts\n   * with an already-registered token type.\n   */\n  register(tokenClass: TokenClass): void {\n    this.classes.push(tokenClass);\n  }\n\n  /**\n   * Unregister all TokenClasses for a given token type.\n   * Useful for plugin unload. Requires rebuild() to take effect.\n   */\n  unregister(tokenType: string): void {\n    this.classes = this.classes.filter(c => c.tokenType !== tokenType);\n  }\n\n  /**\n   * Set the locale's keyword→type map and optional phrase map.\n   * Called on locale change. Priority 0 (cannot override providers with higher priority).\n   */\n  setLocale(keywordMap: Record<string, string>, phraseMap?: Record<string, string>): void {\n    this.localeKeywordMap = keywordMap;\n    this.localePhraseMap = phraseMap ?? null;\n  }\n\n  /**\n   * Set the unit name set. Called when unit list changes.\n   * Units are stored separately (checked AFTER keyword lookup fails).\n   *\n   * Takes a ReadonlySet because the caller's set is derived from the\n   * conversion tables and must not be mutated; this class only ever reads it.\n   */\n  setUnits(unitNames: ReadonlySet<string>): void {\n    this.unitNames = unitNames;\n  }\n\n  /**\n   * Build the optimized TokenLookup from all registered sources.\n   *\n   * Merge order (later overrides earlier):\n   *   1. Locale keywords (priority 0)\n   *   2. Provider classes (sorted by priority ascending)\n   *\n   * Returns a frozen TokenLookup that the Lexer consumes.\n   * Call build() again after register()/setLocale()/setUnits() changes.\n   */\n  build(): TokenLookup {\n    const keywordToType = new Map<string, string>();\n\n    // Layer 1: Locale keywords (priority 0, lowest)\n    if (this.localeKeywordMap) {\n      for (const [keyword, tokenType] of Object.entries(this.localeKeywordMap)) {\n        keywordToType.set(keyword.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider keywords (sorted by priority ascending, higher wins)\n    const sorted = [...this.classes].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n    for (const tc of sorted) {\n      for (const keyword of Object.keys(tc.keywords)) {\n        keywordToType.set(keyword.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    // Build phrase trie from locale + provider phrases\n    const phraseTrie = this.buildPhraseTrie();\n\n    // Build phraseStartWords set (first word of every phrase)\n    const phraseStartWords = this.buildPhraseStartWords();\n\n    return {\n      keywordToType,\n      phraseTrie,\n      phraseStartWords,\n      unitNames: this.unitNames ?? new Set(),\n    };\n  }\n\n  // ── Private helpers ─────────────────────────────────────────────────────\n\n  private buildPhraseTrie(): PhraseNode | null {\n    const root: PhraseNode = { children: new Map() };\n\n    // Layer 1: Locale phrases\n    if (this.localePhraseMap) {\n      for (const [phrase, tokenType] of Object.entries(this.localePhraseMap)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tokenType);\n      }\n    }\n\n    // Layer 2: Provider phrases\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        this.insertPhrase(root, phrase.toLowerCase(), tc.tokenType);\n      }\n    }\n\n    return root.children.size > 0 ? root : null;\n  }\n\n  private insertPhrase(root: PhraseNode, phrase: string, tokenType: string): void {\n    const words = phrase.split(' ');\n    let node = root;\n    for (const word of words) {\n      if (!node.children.has(word)) {\n        node.children.set(word, { children: new Map() });\n      }\n      node = node.children.get(word)!;\n    }\n    // Only set type if not already set, first-registered (locale) wins\n    if (!node.type) {\n      node.type = tokenType;\n    }\n  }\n\n  private buildPhraseStartWords(): Set<string> {\n    const startWords = new Set<string>();\n\n    // Locale phrase first words\n    if (this.localePhraseMap) {\n      for (const phrase of Object.keys(this.localePhraseMap)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    // Provider phrase first words\n    for (const tc of this.classes) {\n      if (!tc.phrases) continue;\n      for (const phrase of Object.keys(tc.phrases)) {\n        const first = phrase.split(' ')[0].toLowerCase();\n        startWords.add(first);\n      }\n    }\n\n    return startWords;\n  }\n}","/**\n * tokenRegistration.ts, Bootstrap for building TokenLookup from locale, units, and phrases.\n *\n * This module centralizes the assembly of the TokenLookup consumed by ExpressionLexer.\n * It merges:\n *   1. Locale keywords (from ILocale.keywordMap)\n *   2. Built-in phrase patterns (to the power of, increase by, etc.)\n *   3. Known unit names (from units.ts)\n *\n * The resulting TokenLookup is frozen and passed to ExpressionLexer.configuredLookup\n * at construction time, enabling data-driven keyword/unit/phrase resolution.\n */\nimport { TokenClassRegistry } from '@solve-js/lexer/TokenClassRegistry';\nimport type { TokenLookup } from '@solve-js/lexer/TokenClassRegistry';\nimport { getLocale, type ILocale } from '@solve-js/constants/locales';\nimport { knownUnits } from '@solve-js/lexer/units';\n\n// ── Built-in phrase map ───────────────────────────────────────────────────\n// These are the multi-word expressions handled as compound tokens.\n// Matched by the PhraseMatcher (trie-based) in ExpressionLexer.tryMatchPhrase().\nconst BUILTIN_PHRASES: Record<string, string> = {\n  'to the power of': 'CARET',\n  'power of': 'CARET',\n  'increase by': 'INCREASE_BY',\n  'decrease by': 'DECREASE_BY',\n  'times by': 'TIMES_BY',\n  'multiply by': 'MULTIPLY_BY',\n  'multiplied by': 'MULTIPLY_BY',\n  'divide by': 'DIVIDE_BY',\n};\n\n/**\n * Build a TokenLookup from locale keywords, known units, and built-in phrases.\n *\n * Merge order (later overrides earlier):\n *   1. Locale keywords (priority 0, lowest, can be overridden by providers)\n *   2. Built-in phrases (via locale phraseMap)\n *   3. Known units (checked AFTER keyword lookup fails, via unitNames set)\n *\n * The resulting TokenLookup replaces the internal keyword map, unit set,\n * phrase trie, and phraseStartWords in ExpressionLexer when set via\n * ExpressionLexer.configuredLookup.\n *\n * @param localeCode - The locale code (e.g., \"en\", \"de\"). Defaults to \"en\".\n * @returns A frozen TokenLookup ready for consumption by the lexer.\n */\nexport function buildTokenLookup(localeCode = 'en'): TokenLookup {\n  const locale: ILocale = getLocale(localeCode);\n  const registry = new TokenClassRegistry();\n\n  // Layer 1: Locale keywords (priority 0, lowest)\n  registry.setLocale(locale.keywordMap, BUILTIN_PHRASES);\n\n  // Layer 2: Known units (checked after keyword lookup)\n  registry.setUnits(knownUnits);\n\n  // Build and return the lookup\n  return registry.build();\n}\n"]}

package/dist/chunk-H3JXNH7X.cjs

@@ -1,3 +0,0 @@
-'use strict';var chunkR2SZFJTT_cjs=require('./chunk-R2SZFJTT.cjs'),chunk5TVI2UPZ_cjs=require('./chunk-5TVI2UPZ.cjs'),chunkJ7ABVGZH_cjs=require('./chunk-J7ABVGZH.cjs'),chunk75JLWK4L_cjs=require('./chunk-75JLWK4L.cjs'),chunkS3DFU33X_cjs=require('./chunk-S3DFU33X.cjs');var b={floatResult:{decimalPlaces:2,enableSeperator:true},numberResult:{decimalSeparatorLocale:"en-US"},hexResult:{enablePadding:false,paddingZeros:0},unitOfMeasurementResult:{decimalPlaces:2},percentageResult:{decimalPlaces:2},dateResult:{format:"long"}};function F(t,r,o,n){let e=o.floatResult.enableSeperator,a=o.numberResult.decimalSeparatorLocale;if(n!==void 0&&Number.isFinite(t)){let c=t.toLocaleString(a||"en-US",{minimumFractionDigits:n,maximumFractionDigits:n,useGrouping:e});return `${r.display.resultPrefix}${c}`}let i=o.floatResult.decimalPlaces,s=chunkR2SZFJTT_cjs.a(t,i,e,a);return `${r.display.resultPrefix}${s}`}function R(t,r,o,n){let e=n.floatResult.decimalPlaces,a=n.floatResult.enableSeperator,i=n.numberResult.decimalSeparatorLocale||"en-US",s=Math.max(e,1),c=t.toLocaleString(i,{useGrouping:a,minimumFractionDigits:0,maximumFractionDigits:e}),u=Math.abs(r).toLocaleString(i,{useGrouping:a,minimumFractionDigits:1,maximumFractionDigits:s});return `${o.display.resultPrefix}${c} \xB1 ${u}`}function L(t,r,o){if(typeof t=="number"&&!Number.isFinite(t))return `= ${t}`;let n=typeof t=="bigint"?t<0n:t<0,e=n?"-":"",a=c=>typeof t=="bigint"?(n?-t:t).toString(c):Math.abs(Math.trunc(t)).toString(c);if(o==="bin")return `= ${e}0b${a(2)}`;if(o==="oct")return `= ${e}0o${a(8)}`;let i=r.hexResult.enablePadding?r.hexResult.paddingZeros:0,s=a(16).toUpperCase().padStart(i,"0");return `= ${e}0x${s}`}var I=2e4;function P(t){let r=t<0n?-t:t;if(Number.isFinite(Number(r)))return `= ${t}`;let o=r.toString(16).length*4;if(o*Math.LN2/Math.LN10<=I)return `= ${t}`;let n=o*Math.LN2/Math.LN10,e=Math.floor(n),a=Math.pow(10,n-e);return `= ${t<0n?"-":""}~${a.toFixed(3)}e+${e} (an exact integer of about ${(e+1).toLocaleString("en-US")} digits, too large to print)`}function T(t){return `= ${t}`}function w(t){return `= ${t}`}function N(t,r,o){let n=new Date(t),e=o.dateResult?.format??"long",a=n.getHours()===0&&n.getMinutes()===0&&n.getSeconds()===0&&n.getMilliseconds()===0;if(e==="long"){let g=n.toLocaleDateString(r.code,{weekday:"long",year:"numeric",month:"long",day:"numeric"});return a?`= ${g}`:`= ${g}, ${n.toLocaleTimeString(r.code)}`}let i=g=>String(g).padStart(2,"0"),s=n.getFullYear(),c=i(n.getMonth()+1),u=i(n.getDate()),m;if(e==="iso"?m=`${s}-${c}-${u}`:e==="dmy"?m=`${u}/${c}/${s}`:m=`${c}/${u}/${s}`,a)return `= ${m}`;let l=`${i(n.getHours())}:${i(n.getMinutes())}:${i(n.getSeconds())}`;return e==="iso"?`= ${m}T${l}`:`= ${m} ${l}`}function C(t){let r=t<0?"-":"",o=Math.round(Math.abs(t)/1e3),n=Math.floor(o/3600),e=Math.floor(o%3600/60),a=o%60,i=String(e).padStart(2,"0");if(a===0)return `${r}${n}:${i}`;let s=String(a).padStart(2,"0");return `${r}${n}:${i}:${s}`}function U(t,r,o,n,e){if(r==="ms")return `= ${C(t)}`;r==="l100km"&&(r="l/100km"),r==="mps2"&&(r="m/s\xB2");let a=n.unitOfMeasurementResult.decimalPlaces,s=r&&["days","weeks","months","years","hours","minutes","seconds","day","week","month","year","hour","minute","second"].includes(r),c;s&&t===Math.floor(t)?c=t.toString():c=t.toFixed(a);let u=r?chunkJ7ABVGZH_cjs.ua[r.toUpperCase()]:void 0;if(u){let l=e?chunkJ7ABVGZH_cjs.sa(e,a):c,g=u.spaced?" ":"";return `= ${u.position==="prefix"?`${u.symbol}${g}${l}`:`${l}${g}${u.symbol}`}`}return `= ${e?chunkJ7ABVGZH_cjs.sa(e,a):c} ${r||""}`.trim()}function D(t,r){if(typeof t=="boolean")return t?"true":"false";if(typeof t=="object"&&t!==null)return chunkJ7ABVGZH_cjs.R(t);let o=r.floatResult.decimalPlaces,n=r.floatResult.enableSeperator,e=r.numberResult.decimalSeparatorLocale;return chunkR2SZFJTT_cjs.a(t,o,n,e)}function E(t,r,o){let n=chunkJ7ABVGZH_cjs.Z(t),e=[];for(let a=0;a<t.rows;a++){let i=[];for(let s=0;s<t.cols;s++)i.push(D(n[a*t.cols+s],o));e.push(i.join(", "));}return `${r.display.resultPrefix}[${e.join("; ")}]`}function et(t,r){let o=r||b,n=chunkJ7ABVGZH_cjs.Z(t),e=[];for(let i=0;i<t.rows;i++){let s=[];for(let c=0;c<t.cols;c++)s.push(D(n[i*t.cols+c],o));e.push(s);}let a=[];for(let i=0;i<t.cols;i++){let s=0;for(let c=0;c<t.rows;c++)s=Math.max(s,e[c][i].length);a.push(s);}return e.map(i=>`[ ${i.map((s,c)=>s.padStart(a[c])).join("  ")} ]`).join(`
-`)}function j(t,r,o){return `${o.display.resultPrefix}${t}:${r}`}function A(t,r,o){let n=o.percentageResult.decimalPlaces;return `= ${(t*100).toFixed(n)}${r.display.percentageSuffix}`}function G(t,r){return `= ${t} ${r||""}`.trim()}function O(t){if(t.addr===void 0)return `/${t.prefix}`;let r=chunk5TVI2UPZ_cjs.D(t.addr);return t.prefix===void 0?r:`${r}/${t.prefix}`}function _(t,r,o){let n=r.display.resultPrefix,e=u=>{let m=t.unit!==void 0?new chunk75JLWK4L_cjs.m(6,u.value,t.unit):new chunk75JLWK4L_cjs.m(0,u.value);m.exact=u.exact;let l=k(m,o);return l.startsWith(n)?l.slice(n.length):l},[a,i]=t.shares,s=`${e(a)} each`;if(i===void 0)return `${n}${s}`;let c=i.count===1?"share":"shares";return `${n}${s}, with ${i.count} ${c} paying ${e(i)}`}function k(t,r){let o=r||b,n=o.numberResult.decimalSeparatorLocale||"en",e=chunkS3DFU33X_cjs.a(n);switch(t.type){case 0:return t.uncertainty!==void 0?R(t.value,t.uncertainty,e,o):F(t.value,e,o,t.decimalPlaces);case 1:return L(t.value,o,t.unit);case 2:return P(t.value);case 3:return T(t.value);case 10:return w(t.value);case 4:return N(t.value,e,o);case 6:return U(t.value,t.unit,e,o,t.exact);case 7:return E(t.value,e,o);case 8:{let a=t.value;return j(a.min,a.max,e)}case 14:return `${e.display.resultPrefix}${chunk5TVI2UPZ_cjs.g(t.value)}`;case 15:return _(t.value,e,o);case 16:return `${e.display.resultPrefix}${t.value.label}`;case 17:return `${e.display.resultPrefix}${O(t.value)}`;case 9:return chunkJ7ABVGZH_cjs.R(t.value);case 5:return A(t.value,e,o);case 11:return G(t.value,t.unit);case 13:return t.unit??String(t.value);default:return `= ${String(t.value)}`}}exports.a=b;exports.b=et;exports.c=k;//# sourceMappingURL=chunk-H3JXNH7X.cjs.map
-//# sourceMappingURL=chunk-H3JXNH7X.cjs.map

package/dist/chunk-H3JXNH7X.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/format/FormattingSettings.ts","../src/format/FormatEngine.ts"],"names":["DEFAULT_FORMATTING_SETTINGS","formatNumber","value","locale","settings","decimalPlaces","sep","loc","formatted","dp","autoFormatIntegerOrFloat","formatUncertain","center","uncertainty","useGrouping","spreadMax","centerText","spreadText","formatHex","base","negative","sign","digits","radix","padding","hex","MAX_DISPLAYED_BIGINT_DIGITS","formatBigInt","magnitude","bits","log10","exponent","mantissa","formatString","formatBoolean","formatDatetime","d","format","isMidnight","dateStr","p2","n","year","month","day","datePart","time","formatMsDuration","ms","totalSeconds","hours","minutes","seconds","mm","ss","formatUom","unit","exact","isTimeSpan","currencyDisplay","CURRENCY_DISPLAY","moneyText","decimalToFixed","formatMatrixEntry","entry","formatSymbolic","formatMatrix","m","rowMajor","columnMajorToRowMajor","rows","r","cells","c","formatMatrixAligned","us","row","colWidth","width","cell","formatRange","min","max","formatPercentage","formatUnit","formatIpCidr","data","dotted","formatIp","formatSplit","prefix","render","share","v","Value","text","formatValue","high","each","shareWord","localeCode","getLocale","formatColour"],"mappings":"2QA8CO,IAAMA,CAAAA,CAAkD,CAC7D,WAAA,CAAa,CACX,aAAA,CAAe,CAAA,CACf,eAAA,CAAiB,IACnB,CAAA,CACA,YAAA,CAAc,CACZ,sBAAA,CAAwB,OAC1B,EACA,SAAA,CAAW,CACT,aAAA,CAAe,KAAA,CACf,YAAA,CAAc,CAChB,CAAA,CACA,uBAAA,CAAyB,CACvB,aAAA,CAAe,CACjB,CAAA,CACA,gBAAA,CAAkB,CAChB,cAAe,CACjB,CAAA,CACA,UAAA,CAAY,CACV,MAAA,CAAQ,MACV,CACF,ECxDA,SAASC,CAAAA,CAAaC,CAAAA,CAAeC,CAAAA,CAAiBC,CAAAA,CAA8BC,CAAAA,CAAgC,CAClH,IAAMC,CAAAA,CAAMF,CAAAA,CAAS,WAAA,CAAY,eAAA,CAC3BG,CAAAA,CAAMH,CAAAA,CAAS,YAAA,CAAa,sBAAA,CAMlC,GAAIC,CAAAA,GAAkB,MAAA,EAAa,MAAA,CAAO,QAAA,CAASH,CAAK,CAAA,CAAG,CACzD,IAAMM,CAAAA,CAAYN,CAAAA,CAAM,cAAA,CAAeK,CAAAA,EAAO,OAAA,CAAS,CACrD,qBAAA,CAAuBF,CAAAA,CACvB,qBAAA,CAAuBA,CAAAA,CACvB,WAAA,CAAaC,CACf,CAAC,CAAA,CACD,OAAO,CAAA,EAAGH,CAAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAGK,CAAS,CAAA,CACnD,CACA,IAAMC,CAAAA,CAAKL,CAAAA,CAAS,YAAY,aAAA,CAC1BI,CAAAA,CAAYE,mBAAAA,CAAyBR,CAAAA,CAAOO,CAAAA,CAAIH,CAAAA,CAAKC,CAAG,CAAA,CAC9D,OAAO,CAAA,EAAGJ,CAAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAGK,CAAS,CAAA,CACnD,CAkBA,SAASG,CAAAA,CAAgBC,CAAAA,CAAgBC,CAAAA,CAAqBV,CAAAA,CAAiBC,CAAAA,CAAsC,CACnH,IAAMK,CAAAA,CAAKL,CAAAA,CAAS,WAAA,CAAY,aAAA,CAC1BU,CAAAA,CAAcV,EAAS,WAAA,CAAY,eAAA,CACnCG,CAAAA,CAAMH,CAAAA,CAAS,YAAA,CAAa,sBAAA,EAA0B,OAAA,CAGtDW,CAAAA,CAAY,IAAA,CAAK,GAAA,CAAIN,CAAAA,CAAI,CAAC,CAAA,CAC1BO,CAAAA,CAAaJ,EAAO,cAAA,CAAeL,CAAAA,CAAK,CAAE,WAAA,CAAAO,CAAAA,CAAa,qBAAA,CAAuB,CAAA,CAAG,qBAAA,CAAuBL,CAAG,CAAC,CAAA,CAC5GQ,CAAAA,CAAa,IAAA,CAAK,GAAA,CAAIJ,CAAW,CAAA,CAAE,cAAA,CAAeN,CAAAA,CAAK,CAAE,WAAA,CAAAO,CAAAA,CAAa,qBAAA,CAAuB,CAAA,CAAG,qBAAA,CAAuBC,CAAU,CAAC,CAAA,CACxI,OAAO,CAAA,EAAGZ,CAAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAGa,CAAU,CAAA,MAAA,EAAMC,CAAU,CAAA,CACpE,CAUA,SAASC,CAAAA,CAAUhB,CAAAA,CAAwBE,CAAAA,CAA8Be,CAAAA,CAAuB,CAI9F,GAAI,OAAOjB,CAAAA,EAAU,QAAA,EAAY,CAAC,MAAA,CAAO,QAAA,CAASA,CAAK,CAAA,CAAG,OAAO,CAAA,EAAA,EAAKA,CAAK,CAAA,CAAA,CAY3E,IAAMkB,CAAAA,CAAW,OAAOlB,GAAU,QAAA,CAAWA,CAAAA,CAAQ,EAAA,CAAKA,CAAAA,CAAQ,CAAA,CAC5DmB,CAAAA,CAAOD,CAAAA,CAAW,GAAA,CAAM,EAAA,CACxBE,CAAAA,CAAUC,CAAAA,EACd,OAAOrB,CAAAA,EAAU,QAAA,CAAA,CACZkB,EAAW,CAAClB,CAAAA,CAAQA,CAAAA,EAAO,QAAA,CAASqB,CAAK,CAAA,CAC1C,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,KAAA,CAAMrB,CAAK,CAAC,CAAA,CAAE,QAAA,CAASqB,CAAK,CAAA,CAEhD,GAAIJ,CAAAA,GAAS,KAAA,CAAO,OAAO,CAAA,EAAA,EAAKE,CAAI,CAAA,EAAA,EAAKC,CAAAA,CAAO,CAAC,CAAC,CAAA,CAAA,CAClD,GAAIH,CAAAA,GAAS,KAAA,CAAO,OAAO,CAAA,EAAA,EAAKE,CAAI,CAAA,EAAA,EAAKC,CAAAA,CAAO,CAAC,CAAC,CAAA,CAAA,CAClD,IAAME,CAAAA,CAAUpB,CAAAA,CAAS,SAAA,CAAU,aAAA,CAAgBA,CAAAA,CAAS,SAAA,CAAU,aAAe,CAAA,CAC/EqB,CAAAA,CAAMH,CAAAA,CAAO,EAAE,CAAA,CAAE,WAAA,EAAY,CAAE,QAAA,CAASE,CAAAA,CAAS,GAAG,CAAA,CAC1D,OAAO,CAAA,EAAA,EAAKH,CAAI,KAAKI,CAAG,CAAA,CAC1B,CAUA,IAAMC,CAAAA,CAA8B,GAAA,CAoBpC,SAASC,CAAAA,CAAazB,CAAAA,CAAuB,CAC3C,IAAM0B,CAAAA,CAAY1B,CAAAA,CAAQ,EAAA,CAAK,CAACA,CAAAA,CAAQA,CAAAA,CAIxC,GAAI,MAAA,CAAO,QAAA,CAAS,MAAA,CAAO0B,CAAS,CAAC,CAAA,CAAG,OAAO,CAAA,EAAA,EAAK1B,CAAK,CAAA,CAAA,CACzD,IAAM2B,EAAOD,CAAAA,CAAU,QAAA,CAAS,EAAE,CAAA,CAAE,MAAA,CAAS,CAAA,CAC7C,GAAIC,CAAAA,CAAO,IAAA,CAAK,GAAA,CAAM,IAAA,CAAK,IAAA,EAAQH,CAAAA,CAA6B,OAAO,KAAKxB,CAAK,CAAA,CAAA,CACjF,IAAM4B,CAAAA,CAAQD,CAAAA,CAAO,IAAA,CAAK,GAAA,CAAM,IAAA,CAAK,IAAA,CAC/BE,CAAAA,CAAW,IAAA,CAAK,KAAA,CAAMD,CAAK,CAAA,CAC3BE,EAAW,IAAA,CAAK,GAAA,CAAI,EAAA,CAAIF,CAAAA,CAAQC,CAAQ,CAAA,CAE9C,OAAO,CAAA,EAAA,EADM7B,CAAAA,CAAQ,EAAA,CAAK,GAAA,CAAM,EAChB,CAAA,CAAA,EAAI8B,CAAAA,CAAS,OAAA,CAAQ,CAAC,CAAC,CAAA,EAAA,EAAKD,CAAQ,CAAA,4BAAA,EAAA,CAAgCA,CAAAA,CAAW,CAAA,EAAG,cAAA,CAAe,OAAO,CAAC,CAAA,4BAAA,CAC3H,CAEA,SAASE,CAAAA,CAAa/B,CAAAA,CAAuB,CAC3C,OAAO,CAAA,EAAA,EAAKA,CAAK,CAAA,CACnB,CAEA,SAASgC,CAAAA,CAAchC,CAAAA,CAAwB,CAC7C,OAAO,CAAA,EAAA,EAAKA,CAAK,CAAA,CACnB,CAqBA,SAASiC,CAAAA,CAAejC,CAAAA,CAAeC,CAAAA,CAAiBC,CAAAA,CAAsC,CAC5F,IAAMgC,CAAAA,CAAI,IAAI,IAAA,CAAKlC,CAAK,CAAA,CAClBmC,CAAAA,CAASjC,CAAAA,CAAS,UAAA,EAAY,QAAU,MAAA,CACxCkC,CAAAA,CAAaF,CAAAA,CAAE,QAAA,EAAS,GAAM,CAAA,EAAKA,CAAAA,CAAE,UAAA,EAAW,GAAM,CAAA,EAAKA,CAAAA,CAAE,UAAA,EAAW,GAAM,CAAA,EAAKA,CAAAA,CAAE,eAAA,EAAgB,GAAM,CAAA,CAGjH,GAAIC,CAAAA,GAAW,MAAA,CAAQ,CACrB,IAAME,CAAAA,CAAUH,CAAAA,CAAE,kBAAA,CAAmBjC,CAAAA,CAAO,IAAA,CAAM,CAAE,OAAA,CAAS,OAAQ,IAAA,CAAM,SAAA,CAAW,KAAA,CAAO,MAAA,CAAQ,GAAA,CAAK,SAAU,CAAC,CAAA,CACrH,OAAImC,CAAAA,CAAmB,CAAA,EAAA,EAAKC,CAAO,CAAA,CAAA,CAC5B,CAAA,EAAA,EAAKA,CAAO,CAAA,EAAA,EAAKH,CAAAA,CAAE,kBAAA,CAAmBjC,CAAAA,CAAO,IAAI,CAAC,CAAA,CAC3D,CAIA,IAAMqC,CAAAA,CAAMC,CAAAA,EAAc,MAAA,CAAOA,CAAC,CAAA,CAAE,SAAS,CAAA,CAAG,GAAG,CAAA,CAC7CC,CAAAA,CAAON,CAAAA,CAAE,WAAA,EAAY,CACrBO,CAAAA,CAAQH,CAAAA,CAAGJ,CAAAA,CAAE,QAAA,EAAS,CAAI,CAAC,CAAA,CAC3BQ,CAAAA,CAAMJ,CAAAA,CAAGJ,CAAAA,CAAE,OAAA,EAAS,CAAA,CACtBS,CAAAA,CAKJ,GAJIR,CAAAA,GAAW,KAAA,CAAOQ,CAAAA,CAAW,CAAA,EAAGH,CAAI,CAAA,CAAA,EAAIC,CAAK,CAAA,CAAA,EAAIC,CAAG,CAAA,CAAA,CAC/CP,CAAAA,GAAW,KAAA,CAAOQ,CAAAA,CAAW,CAAA,EAAGD,CAAG,CAAA,CAAA,EAAID,CAAK,CAAA,CAAA,EAAID,CAAI,CAAA,CAAA,CACxDG,CAAAA,CAAW,CAAA,EAAGF,CAAK,IAAIC,CAAG,CAAA,CAAA,EAAIF,CAAI,CAAA,CAAA,CAEnCJ,CAAAA,CAAY,OAAO,CAAA,EAAA,EAAKO,CAAQ,CAAA,CAAA,CACpC,IAAMC,CAAAA,CAAO,CAAA,EAAGN,CAAAA,CAAGJ,CAAAA,CAAE,UAAU,CAAC,CAAA,CAAA,EAAII,CAAAA,CAAGJ,CAAAA,CAAE,UAAA,EAAY,CAAC,CAAA,CAAA,EAAII,CAAAA,CAAGJ,CAAAA,CAAE,UAAA,EAAY,CAAC,GAE5E,OAAOC,CAAAA,GAAW,KAAA,CAAQ,CAAA,EAAA,EAAKQ,CAAQ,CAAA,CAAA,EAAIC,CAAI,CAAA,CAAA,CAAK,CAAA,EAAA,EAAKD,CAAQ,CAAA,CAAA,EAAIC,CAAI,CAAA,CAC3E,CAUA,SAASC,CAAAA,CAAiBC,CAAAA,CAAoB,CAC5C,IAAM3B,CAAAA,CAAO2B,CAAAA,CAAK,CAAA,CAAI,GAAA,CAAM,EAAA,CACtBC,CAAAA,CAAe,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,GAAA,CAAID,CAAE,CAAA,CAAI,GAAI,CAAA,CAC7CE,CAAAA,CAAQ,IAAA,CAAK,KAAA,CAAMD,CAAAA,CAAe,IAAI,CAAA,CACtCE,CAAAA,CAAU,IAAA,CAAK,KAAA,CAAOF,CAAAA,CAAe,IAAA,CAAQ,EAAE,CAAA,CAC/CG,CAAAA,CAAUH,CAAAA,CAAe,EAAA,CACzBI,CAAAA,CAAK,MAAA,CAAOF,CAAO,CAAA,CAAE,QAAA,CAAS,CAAA,CAAG,GAAG,CAAA,CAC1C,GAAIC,CAAAA,GAAY,CAAA,CAAG,OAAO,CAAA,EAAG/B,CAAI,CAAA,EAAG6B,CAAK,CAAA,CAAA,EAAIG,CAAE,CAAA,CAAA,CAC/C,IAAMC,CAAAA,CAAK,MAAA,CAAOF,CAAO,CAAA,CAAE,QAAA,CAAS,CAAA,CAAG,GAAG,CAAA,CAC1C,OAAO,CAAA,EAAG/B,CAAI,CAAA,EAAG6B,CAAK,CAAA,CAAA,EAAIG,CAAE,CAAA,CAAA,EAAIC,CAAE,CAAA,CACpC,CAEA,SAASC,CAAAA,CAAUrD,EAAesD,CAAAA,CAA0BrD,CAAAA,CAAiBC,CAAAA,CAA8BqD,CAAAA,CAA6B,CACtI,GAAID,CAAAA,GAAS,IAAA,CAAM,OAAO,CAAA,EAAA,EAAKT,CAAAA,CAAiB7C,CAAK,CAAC,CAAA,CAAA,CAGlDsD,IAAS,QAAA,GAAUA,CAAAA,CAAO,SAAA,CAAA,CAC1BA,CAAAA,GAAS,MAAA,GAAQA,CAAAA,CAAO,SAAA,CAAA,CAE5B,IAAM/C,CAAAA,CAAKL,CAAAA,CAAS,uBAAA,CAAwB,aAAA,CAItCsD,CAAAA,CAAaF,CAAAA,EADG,CAAC,MAAA,CAAQ,OAAA,CAAS,QAAA,CAAU,OAAA,CAAS,OAAA,CAAS,SAAA,CAAW,SAAA,CAAW,KAAA,CAAO,MAAA,CAAQ,OAAA,CAAS,MAAA,CAAQ,MAAA,CAAQ,QAAA,CAAU,QAAQ,CAAA,CAC3G,SAASA,CAAI,CAAA,CAElDhD,CAAAA,CACAkD,CAAAA,EAAcxD,CAAAA,GAAU,IAAA,CAAK,KAAA,CAAMA,CAAK,CAAA,CAE1CM,CAAAA,CAAYN,CAAAA,CAAM,QAAA,EAAS,CAG3BM,CAAAA,CAAYN,EAAM,OAAA,CAAQO,CAAE,CAAA,CAU9B,IAAMkD,CAAAA,CAAkBH,CAAAA,CAAOI,oBAAAA,CAAiBJ,CAAAA,CAAK,WAAA,EAAa,CAAA,CAAI,MAAA,CACtE,GAAIG,CAAAA,CAAiB,CAMnB,IAAME,CAAAA,CAAYJ,CAAAA,CAAQK,oBAAAA,CAAeL,CAAAA,CAAOhD,CAAE,CAAA,CAAID,CAAAA,CAChDF,CAAAA,CAAMqD,CAAAA,CAAgB,MAAA,CAAS,GAAA,CAAM,EAAA,CAI3C,OAAO,CAAA,EAAA,EAHYA,CAAAA,CAAgB,QAAA,GAAa,QAAA,CAC5C,CAAA,EAAGA,CAAAA,CAAgB,MAAM,CAAA,EAAGrD,CAAG,CAAA,EAAGuD,CAAS,CAAA,CAAA,CAC3C,CAAA,EAAGA,CAAS,CAAA,EAAGvD,CAAG,GAAGqD,CAAAA,CAAgB,MAAM,CAAA,CACzB,CAAA,CACxB,CAkBA,OAAO,CAAA,EAAA,EADaF,CAAAA,CAAQK,oBAAAA,CAAeL,CAAAA,CAAOhD,CAAE,CAAA,CAAID,CACjC,CAAA,CAAA,EAAIgD,GAAQ,EAAE,CAAA,CAAA,CAAG,IAAA,EAC1C,CAEA,SAASO,CAAAA,CAAkBC,CAAAA,CAAoB5D,CAAAA,CAAsC,CACnF,GAAI,OAAO4D,CAAAA,EAAU,SAAA,CAAW,OAAOA,CAAAA,CAAQ,MAAA,CAAS,OAAA,CACxD,GAAI,OAAOA,CAAAA,EAAU,QAAA,EAAYA,CAAAA,GAAU,IAAA,CAAM,OAAOC,mBAAAA,CAAeD,CAAK,CAAA,CAC5E,IAAMvD,CAAAA,CAAKL,CAAAA,CAAS,WAAA,CAAY,aAAA,CAC1BE,CAAAA,CAAMF,CAAAA,CAAS,WAAA,CAAY,eAAA,CAC3BG,CAAAA,CAAMH,CAAAA,CAAS,YAAA,CAAa,sBAAA,CAClC,OAAOM,mBAAAA,CAAyBsD,CAAAA,CAAOvD,CAAAA,CAAIH,EAAKC,CAAG,CACrD,CASA,SAAS2D,CAAAA,CAAaC,CAAAA,CAAehE,CAAAA,CAAiBC,CAAAA,CAAsC,CAC1F,IAAMgE,CAAAA,CAAWC,mBAAAA,CAAsBF,CAAC,CAAA,CAClCG,EAAiB,EAAC,CACxB,IAAA,IAASC,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIJ,CAAAA,CAAE,IAAA,CAAMI,CAAAA,EAAAA,CAAK,CAC/B,IAAMC,CAAAA,CAAkB,EAAC,CACzB,QAASC,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIN,CAAAA,CAAE,IAAA,CAAMM,CAAAA,EAAAA,CAC1BD,CAAAA,CAAM,IAAA,CAAKT,CAAAA,CAAkBK,CAAAA,CAASG,CAAAA,CAAIJ,CAAAA,CAAE,IAAA,CAAOM,CAAC,CAAA,CAAGrE,CAAQ,CAAC,CAAA,CAElEkE,CAAAA,CAAK,IAAA,CAAKE,CAAAA,CAAM,IAAA,CAAK,IAAI,CAAC,EAC5B,CACA,OAAO,CAAA,EAAGrE,CAAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,CAAA,EAAImE,CAAAA,CAAK,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA,CAC1D,CAiBO,SAASI,EAAAA,CAAoBP,CAAAA,CAAe/D,CAAAA,CAAuC,CACxF,IAAMuE,CAAAA,CAAKvE,GAAYJ,CAAAA,CACjBoE,CAAAA,CAAWC,mBAAAA,CAAsBF,CAAC,CAAA,CAClCK,CAAAA,CAAoB,EAAC,CAC3B,IAAA,IAASD,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIJ,CAAAA,CAAE,IAAA,CAAMI,IAAK,CAC/B,IAAMK,CAAAA,CAAgB,EAAC,CACvB,IAAA,IAAS,CAAA,CAAI,CAAA,CAAG,CAAA,CAAIT,CAAAA,CAAE,IAAA,CAAM,CAAA,EAAA,CAC1BS,CAAAA,CAAI,IAAA,CAAKb,CAAAA,CAAkBK,CAAAA,CAASG,CAAAA,CAAIJ,CAAAA,CAAE,IAAA,CAAO,CAAC,CAAA,CAAGQ,CAAE,CAAC,CAAA,CAE1DH,CAAAA,CAAM,IAAA,CAAKI,CAAG,EAChB,CACA,IAAMC,EAAqB,EAAC,CAC5B,IAAA,IAASJ,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIN,CAAAA,CAAE,IAAA,CAAMM,CAAAA,EAAAA,CAAK,CAC/B,IAAIK,CAAAA,CAAQ,CAAA,CACZ,IAAA,IAASP,EAAI,CAAA,CAAGA,CAAAA,CAAIJ,CAAAA,CAAE,IAAA,CAAMI,CAAAA,EAAAA,CAAKO,CAAAA,CAAQ,IAAA,CAAK,GAAA,CAAIA,CAAAA,CAAON,CAAAA,CAAMD,CAAC,CAAA,CAAEE,CAAC,CAAA,CAAE,MAAM,CAAA,CAC3EI,CAAAA,CAAS,IAAA,CAAKC,CAAK,EACrB,CACA,OAAON,CAAAA,CACJ,GAAA,CAAKI,CAAAA,EAAQ,CAAA,EAAA,EAAKA,CAAAA,CAAI,GAAA,CAAI,CAACG,CAAAA,CAAM,CAAA,GAAMA,CAAAA,CAAK,QAAA,CAASF,CAAAA,CAAS,CAAC,CAAC,CAAC,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA,EAAA,CAAI,CAAA,CACjF,IAAA,CAAK;AAAA,CAAI,CACd,CAEA,SAASG,CAAAA,CAAYC,EAAaC,CAAAA,CAAa/E,CAAAA,CAAyB,CACtE,OAAO,CAAA,EAAGA,EAAO,OAAA,CAAQ,YAAY,GAAG8E,CAAG,CAAA,CAAA,EAAIC,CAAG,CAAA,CACpD,CAEA,SAASC,CAAAA,CAAiBjF,CAAAA,CAAeC,EAAiBC,CAAAA,CAAsC,CAM9F,IAAMK,CAAAA,CAAKL,CAAAA,CAAS,iBAAiB,aAAA,CAErC,OAAO,MADYF,CAAAA,CAAQ,GAAA,EAAK,QAAQO,CAAE,CACrB,GAAGN,CAAAA,CAAO,OAAA,CAAQ,gBAAgB,CAAA,CACzD,CAEA,SAASiF,CAAAA,CAAWlF,CAAAA,CAAesD,EAAkC,CACnE,OAAO,KAAKtD,CAAK,CAAA,CAAA,EAAIsD,GAAQ,EAAE,CAAA,CAAA,CAAG,MACpC,CAeA,SAAS6B,CAAAA,CAAaC,CAAAA,CAA0B,CAC/C,GAAIA,CAAAA,CAAK,OAAS,MAAA,CAAW,OAAO,IAAIA,CAAAA,CAAK,MAAM,GACnD,IAAMC,CAAAA,CAASC,oBAASF,CAAAA,CAAK,IAAI,EACjC,OAAOA,CAAAA,CAAK,SAAW,MAAA,CAAYC,CAAAA,CAAS,GAAGA,CAAM,CAAA,CAAA,EAAID,EAAK,MAAM,CAAA,CACrE,CAEA,SAASG,CAAAA,CAAYH,EAAiBnF,CAAAA,CAAiBC,CAAAA,CAAsC,CAC3F,IAAMsF,CAAAA,CAASvF,EAAO,OAAA,CAAQ,YAAA,CACxBwF,EAAUC,CAAAA,EAA8B,CAC5C,IAAMC,CAAAA,CAAIP,CAAAA,CAAK,OAAS,MAAA,CACpB,IAAIQ,sBAAqBF,CAAAA,CAAM,KAAA,CAAON,EAAK,IAAI,CAAA,CAC/C,IAAIQ,mBAAAA,CAAAA,CAAAA,CAAwBF,CAAAA,CAAM,KAAK,CAAA,CAC3CC,CAAAA,CAAE,MAAQD,CAAAA,CAAM,KAAA,CAChB,IAAMG,CAAAA,CAAOC,CAAAA,CAAYH,EAAGzF,CAAQ,CAAA,CACpC,OAAO2F,CAAAA,CAAK,UAAA,CAAWL,CAAM,CAAA,CAAIK,CAAAA,CAAK,MAAML,CAAAA,CAAO,MAAM,EAAIK,CAC/D,CAAA,CAEM,CAAC5E,CAAAA,CAAM8E,CAAI,EAAIX,CAAAA,CAAK,MAAA,CACpBY,EAAO,CAAA,EAAGP,CAAAA,CAAOxE,CAAI,CAAC,CAAA,KAAA,CAAA,CAC5B,GAAI8E,CAAAA,GAAS,MAAA,CAAW,OAAO,CAAA,EAAGP,CAAM,GAAGQ,CAAI,CAAA,CAAA,CAC/C,IAAMC,CAAAA,CAAYF,CAAAA,CAAK,QAAU,CAAA,CAAI,OAAA,CAAU,SAC/C,OAAO,CAAA,EAAGP,CAAM,CAAA,EAAGQ,CAAI,UAAUD,CAAAA,CAAK,KAAK,IAAIE,CAAS,CAAA,QAAA,EAAWR,EAAOM,CAAI,CAAC,EACjF,CAqBO,SAASD,EAAY9F,CAAAA,CAAcE,CAAAA,CAAuC,CAC/E,IAAMuE,CAAAA,CAAKvE,GAAYJ,CAAAA,CACjBoG,CAAAA,CAAazB,EAAG,YAAA,CAAa,sBAAA,EAA0B,KACvDxE,CAAAA,CAASkG,mBAAAA,CAAUD,CAAU,CAAA,CAEnC,OAAQlG,EAAM,IAAA,EACZ,OAGE,OAAIA,CAAAA,CAAM,cAAgB,MAAA,CACjBS,CAAAA,CAAgBT,EAAM,KAAA,CAAiBA,CAAAA,CAAM,YAAaC,CAAAA,CAAQwE,CAAE,EAEtE1E,CAAAA,CAAaC,CAAAA,CAAM,MAAiBC,CAAAA,CAAQwE,CAAAA,CAAIzE,EAAM,aAAa,CAAA,CAC5E,OACE,OAAOgB,CAAAA,CAAUhB,EAAM,KAAA,CAA0ByE,CAAAA,CAAIzE,EAAM,IAAI,CAAA,CACjE,OACE,OAAOyB,CAAAA,CAAazB,EAAM,KAAe,CAAA,CAC3C,OACE,OAAO+B,CAAAA,CAAa/B,EAAM,KAAe,CAAA,CAC3C,QACE,OAAOgC,CAAAA,CAAchC,EAAM,KAAgB,CAAA,CAC7C,OACE,OAAOiC,CAAAA,CAAejC,EAAM,KAAA,CAAiBC,CAAAA,CAAQwE,CAAE,CAAA,CACzD,KAAA,CAAA,CACE,OAAOpB,CAAAA,CAAUrD,CAAAA,CAAM,MAAiBA,CAAAA,CAAM,IAAA,CAAMC,EAAQwE,CAAAA,CAAIzE,CAAAA,CAAM,KAAK,CAAA,CAC7E,KAAA,CAAA,CACE,OAAOgE,CAAAA,CAAahE,CAAAA,CAAM,MAAqBC,CAAAA,CAAQwE,CAAE,EAC3D,KAAA,CAAA,CAAsB,CACpB,IAAMJ,CAAAA,CAAIrE,CAAAA,CAAM,MAChB,OAAO8E,CAAAA,CAAYT,EAAE,GAAA,CAAKA,CAAAA,CAAE,IAAKpE,CAAM,CACzC,CACA,KAAA,EAAA,CACE,OAAO,GAAGA,CAAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAGmG,mBAAAA,CAAapG,EAAM,KAAmB,CAAC,GACjF,KAAA,EAAA,CACE,OAAOuF,EAAYvF,CAAAA,CAAM,KAAA,CAAoBC,EAAQwE,CAAE,CAAA,CACzD,QAGE,OAAO,CAAA,EAAGxE,EAAO,OAAA,CAAQ,YAAY,GAAID,CAAAA,CAAM,KAAA,CAAoB,KAAK,CAAA,CAAA,CAC1E,KAAA,EAAA,CACE,OAAO,CAAA,EAAGC,CAAAA,CAAO,QAAQ,YAAY,CAAA,EAAGkF,EAAanF,CAAAA,CAAM,KAAmB,CAAC,CAAA,CAAA,CACjF,KAAA,CAAA,CACE,OAAO+D,mBAAAA,CAAe/D,CAAAA,CAAM,KAAqB,CAAA,CACnD,KAAA,CAAA,CACE,OAAOiF,CAAAA,CAAiBjF,CAAAA,CAAM,MAAiBC,CAAAA,CAAQwE,CAAE,EAC3D,KAAA,EAAA,CACE,OAAOS,EAAWlF,CAAAA,CAAM,KAAA,CAAiBA,EAAM,IAAI,CAAA,CACrD,QAKE,OAAOA,CAAAA,CAAM,MAAQ,MAAA,CAAOA,CAAAA,CAAM,KAAK,CAAA,CACzC,QACE,OAAO,CAAA,EAAA,EAAK,MAAA,CAAOA,EAAM,KAAK,CAAC,EACnC,CACF","file":"chunk-H3JXNH7X.cjs","sourcesContent":["/**\n * How a Datetime value is rendered.\n *\n * - `'long'`: the spelled-out form, \"Tuesday, March 10, 2026\" (the default).\n * - `'iso'`: \"2026-03-10\" (ISO 8601, with a `T`-separated time when present).\n * - `'dmy'`: \"10/03/2026\" (day first).\n * - `'mdy'`: \"03/10/2026\" (month first).\n *\n * The weekday and long month name in `'long'` are localised through the same\n * locale the number separators come from; the numeric forms are locale-neutral.\n */\nexport type DateOutputFormat = \"long\" | \"iso\" | \"dmy\" | \"mdy\";\n\n/**\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   * Optional so a host that built a `FormattingSettings` before this field\n   * existed still compiles; a missing `dateResult` reads as `'long'`, the\n   * historic output.\n   */\n  dateResult?: {\n    format: DateOutputFormat;\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  dateResult: {\n    format: \"long\",\n  },\n};\n","import { Value, ValueType, type MatrixData, type MatrixEntry, type RangeData, type ColourData, type SplitData, type SplitShare, type ChartData, type IpCidrData } from \"@solve-js/vm/Value\";\nimport { formatColour } from \"@solve-js/packages/colour/ColourMath\";\nimport { formatIp } from \"@solve-js/packages/ip/IpMath\";\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, settings: FormattingSettings): string {\n  const d = new Date(value);\n  const format = settings.dateResult?.format ?? \"long\";\n  const isMidnight = d.getHours() === 0 && d.getMinutes() === 0 && d.getSeconds() === 0 && d.getMilliseconds() === 0;\n\n  // The spelled-out default, localised through the locale's own names.\n  if (format === \"long\") {\n    const dateStr = d.toLocaleDateString(locale.code, { weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\" });\n    if (isMidnight) return `= ${dateStr}`;\n    return `= ${dateStr}, ${d.toLocaleTimeString(locale.code)}`;\n  }\n\n  // The numeric forms, built from the local calendar fields so they read the\n  // same regardless of the JS runtime's own default locale.\n  const p2 = (n: number) => String(n).padStart(2, \"0\");\n  const year = d.getFullYear();\n  const month = p2(d.getMonth() + 1);\n  const day = p2(d.getDate());\n  let datePart: string;\n  if (format === \"iso\") datePart = `${year}-${month}-${day}`;\n  else if (format === \"dmy\") datePart = `${day}/${month}/${year}`;\n  else datePart = `${month}/${day}/${year}`; // mdy\n\n  if (isMidnight) return `= ${datePart}`;\n  const time = `${p2(d.getHours())}:${p2(d.getMinutes())}:${p2(d.getSeconds())}`;\n  // ISO joins date and time with `T`; the slash forms with a space.\n  return format === \"iso\" ? `= ${datePart}T${time}` : `= ${datePart} ${time}`;\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  // A fuel-consumption unit is stored slash-free (so it is not read as a rate)\n  // but shown the way it is written.\n  if (unit === \"l100km\") unit = \"l/100km\";\n  if (unit === \"mps2\") unit = \"m/s²\";\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 */\n/**\n * An IP/CIDR as text: the dotted quad, plus `/prefix` when present, or a bare\n * `/prefix` when there is no address (`netmask of /24` before it resolves).\n */\nfunction formatIpCidr(data: IpCidrData): string {\n\tif (data.addr === undefined) return `/${data.prefix}`;\n\tconst dotted = formatIp(data.addr);\n\treturn data.prefix === undefined ? dotted : `${dotted}/${data.prefix}`;\n}\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, us);\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.Chart:\n      // A chart is drawn from its data by the host; the text answer is its label\n      // (`sin(x) over [0, 6.28]`, or the series a sparkline came from).\n      return `${locale.display.resultPrefix}${(value.value as ChartData).label}`;\n    case ValueType.IpCidr:\n      return `${locale.display.resultPrefix}${formatIpCidr(value.value as IpCidrData)}`;\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"]}