solve-engine 2.23.0 → 2.25.0

package/dist/chunk-JVMINMAB.js

@@ -1,2 +0,0 @@
-import {c as c$2}from'./chunk-JP4JMQOG.js';import {b,a as a$2,e,d}from'./chunk-O3BDXOQJ.js';import {c,a}from'./chunk-IJMNVBIS.js';import {a as a$1}from'./chunk-LHLW7JLS.js';import {c as c$1}from'./chunk-PIZQIQVM.js';var D=/^\d{1,3}(\.\d{3}){2,}$/,T=/^\d*\.\d*$/,n=class n{constructor(e,t=50,r="en",p){this.tokens=[];this.current=0;this.depth=0;this.currentExpression="";this.infixMinBindingPower=0;this.registry=e,this.maxDepth=t,this.localeCode=r;let a=a$1(r).display;this.decimalSeparator=a.decimalSeparator,this.thousandsSeparator=a.thousandsSeparator,this.pluginFunctionIndex=p;}getLocaleCode(){return this.localeCode}setDiagnosticPipeline(e,t){this.diagnosticPipeline=e,this.currentExpression=t??"";}load(e,t){if(t===false){this.tokens=e,this.current=0,this.depth=0;return}let r=c(a.LPAREN),p=c(a.RPAREN),a$1=0;for(let l=0;l<e.length;l++)e[l].typeId===r?a$1++:e[l].typeId===p&&a$1--;this.tokens=a$1===0?e:this.balanceParens(e,a$1),this.current=0,this.depth=0;}balanceParens(e,t){let r=e.slice();if(t>0){let p=c(a.RPAREN);for(let a$1=0;a$1<t;a$1++){let l=e[e.length-1];r.push({type:a.RPAREN,typeId:p,value:")",text:")",offset:l?l.offset+l.text.length:0,lineBreaks:0,line:l?l.line:1,col:l?l.col+l.text.length:1});}}else if(t<0){let p=c(a.LPAREN);for(let a$1=0;a$1<-t;a$1++)r.unshift({type:a.LPAREN,typeId:p,value:"(",text:"(",offset:0,lineBreaks:0,line:1,col:1});}return r}parseExpression(e=0,t){if(t&&(this.builder=t),this.depth++,this.depth>this.maxDepth)throw this.depth--,c$1.parsing("NESTING_DEPTH_EXCEEDED",`Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,{maxDepth:this.maxDepth,currentDepth:this.depth});let r=this.consume();if(!r)throw this.depth--,c$1.parsing("UNEXPECTED_END","Unexpected end of expression");this.parsePrefix(r);let p=this.tokens,a=p.length,l=n.BP_TABLE,o=this.registry,c=this.builder,d=this.current;for(;d<a;){let h=p[d];if(!h)break;let I=l[h.typeId];if(I>0){if(I<=e)break;if(this.diagnosticPipeline){let m=o.getInfix(h.typeId);m&&this.fireParseletMatched(m,h,false,I);}this.current=++d;let f=h.typeId;if(f===n.PERCENT_ID)c.emitOpcode(10),c.emitNumber(100),c.emitOpcode(23),c.emitOpcode(74);else if(!(f===n.CARET_ID&&this.tryEmitMatrixCaretOp(c))){let m=f===n.CARET_ID?I-1:I+1;this.parseExpression(m,c),c.emitOpcode(n.INFIX_OPCODE[f]);}}else {let f=o.getInfix(h.typeId);if(!f||f.bindingPower<=e)break;this.current=++d,this.diagnosticPipeline&&this.fireParseletMatched(f,h,false,f.bindingPower),this.infixMinBindingPower=e,f.parse(this,r,h,c);}d=this.current;}this.current=d,this.depth--;}parsePrefix(e$1){let t=this.builder,r=e$1.typeId;if(this.diagnosticPipeline){let a=this.registry.getPrefix(r);a&&this.fireParseletMatched(a,e$1,true);}switch(r){case n.NUMBER_ID:{let a,l=null,o=e$1.value;if(this.decimalSeparator==="."){let c=0,d=o.length>0;for(let h=0;h<o.length;h++){let I=o.charCodeAt(h);if(!(I>=48&&I<=57)){if(I===46&&c===0){c=1;continue}d=false;break}}if(d){if(c===1){t.emitOpcode(16),t.emitString(o);return}t.emitOpcode(10),t.emitNumber(+o);return}}if(o.startsWith("0x")||o.startsWith("0X")){if(a=parseInt(o,16),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid hex literal: "${o}"`,{raw:o})}else if(o.startsWith("0b")||o.startsWith("0B")){if(a=parseInt(o.slice(2),2),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid binary literal: "${o}"`,{raw:o})}else if(o.startsWith("0o")||o.startsWith("0O")){if(a=parseInt(o.slice(2),8),Number.isNaN(a))throw c$1.parsing("INVALID_NUMBER_LITERAL",`Invalid octal literal: "${o}"`,{raw:o})}else if(D.test(o))a=parseFloat(o.split(".").join(""));else {let c=this.decimalSeparator,d=this.thousandsSeparator,h=o;d&&h.indexOf(d)!==-1&&(h=h.split(d).join("")),c&&c!=="."&&(h=h.replace(c,".")),a=parseFloat(h),T.test(h)&&(l=h);}if(l!==null){t.emitOpcode(16),t.emitString(l);return}t.emitOpcode(10),t.emitNumber(a);return}case n.BIGINT_ID:{t.emitOpcode(11),t.emitString(e(e$1.value,this.localeCode));return}case n.STRING_ID:{t.emitOpcode(13),t.emitString(e$1.value);return}case n.IDENT_ID:{if(this.peek()?.typeId===n.LPAREN_ID){this.parseUserFunctionDefOrCall(e$1,t);return}t.emitOpcode(60),t.emitString(e$1.value);return}case n.LPAREN_ID:{this.parseExpression(0,t);let a$1=1;for(;this.match(a.COMMA);)this.parseExpression(0,t),a$1++;this.consume(a.RPAREN),a$1>1&&(t.emitOpcode(152),t.emitIndex(1),t.emitIndex(a$1));return}case n.MINUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(26);return}case n.PLUS_ID:{this.parseExpression(a$2.Prefix,t),t.emitOpcode(27);return}case n.KEYWORD_ID:}let p=this.registry.getPrefix(r);if(!p)throw c$1.parsing("NO_PREFIX_PARSELET",`No prefix parselet found for token: ${e$1.type} ("${e$1.value}")`,{tokenType:e$1.type,tokenValue:e$1.value});p.parse(this,e$1,t);}tryEmitMatrixCaretOp(e){for(let t of n.CARET_SUFFIX_RULES)if(t.matches(this))return t.emit(this,e),true;return  false}findMatchingRParen(e){let t=0;for(let r=e;r<this.tokens.length;r++){let p=this.tokens[r];if(p.typeId===n.LPAREN_ID)t++;else if(p.typeId===n.RPAREN_ID&&(t--,t===0))return r}return null}parseUserFunctionDefOrCall(e,t){let r=this.findMatchingRParen(this.current);if(r===null){t.emitOpcode(60),t.emitString(e.value);return}this.tokens[r+1]?.type===a.EQUALS?this.parseUserFunctionDefinition(e,t):this.parseUserFunctionCall(e,t);}consumeParamName(){let e=this.peek();if(e?.type===a.IDENT||e?.type===a.UNIT)return this.consume(),e.value;throw c$1.parsing("USER_FUNCTION_INVALID_PARAM_NAME",`Expected a parameter name but got "${e?.type??"end of input"}"${e?` ("${e.value}")`:""}`,{actualType:e?.type})}parseUserFunctionDefinition(e,t){this.consume(a.LPAREN);let r=[];if(this.peek()?.type!==a.RPAREN)for(r.push(this.consumeParamName());this.match(a.COMMA);)r.push(this.consumeParamName());if(this.consume(a.RPAREN),this.consume(a.EQUALS),r.length===0)throw c$1.parsing("USER_FUNCTION_NO_PARAMS",`"${e.value}()" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,{name:e.value});let p=new d(this.pluginFunctionIndex);this.parseExpression(a$2.Lowest,p),this.setBuilder(t);let a$1=p.build();if(a$1.hasAsync)throw c$1.parsing("FUNCTION_BODY_MUST_BE_SYNCHRONOUS",`"${e.value}(...)"'s body calls an async operation (weather, stocks, currency, ...) \u2014 user-defined function bodies must be synchronous`,{name:e.value});let l=t.emitUserFunctionBody(e.value,r,a$1);t.emitOpcode(150),t.emitIndex(l),t.emitOpcode(13),t.emitString(`${e.value}(${r.join(", ")}) defined`);}parseUserFunctionCall(e,t){this.consume(a.LPAREN);let r=0;if(this.peek()?.type!==a.RPAREN)for(this.parseExpression(a$2.Lowest,t),r++;this.match(a.COMMA);)this.parseExpression(a$2.Lowest,t),r++;this.consume(a.RPAREN),t.emitOpcode(151),t.emitString(e.value),t.emitByte(r);}consume(e){let t=this.tokens[this.current];if(!t)throw c$1.parsing("UNEXPECTED_END_OF_INPUT","Unexpected end of input");if(e!==void 0){let r=c(e);if(t.typeId!==r)throw c$1.parsing("UNEXPECTED_TOKEN_TYPE",`Expected token type "${e}" but got "${t.type}" ("${t.value}")`,{expectedType:e,actualType:t.type,actualValue:t.value})}return this.current++,t}match(e){let t=this.peek();return t&&t.typeId===c(e)?(this.advance(),true):false}peek(){return this.tokens[this.current]}peekAt(e){return this.tokens[this.current+e]}previous(){return this.current>0?this.tokens[this.current-1]:void 0}advance(){this.current++;}setBuilder(e){this.builder=e;}fireParseletMatched(e,t,r,p){let a=this.diagnosticPipeline,l={type:c$2.ParseletMatched,elapsedNs:0,expression:this.currentExpression,tokenType:t.type,tokenValue:t.value,parseletCategory:e.category,parseletType:e.constructor?.name??"unknown",isPrefix:r,bindingPower:p,tokenOffset:t.offset||0};a.fireParseletMatched(l);}};n.BP_TABLE=b(),n.NUMBER_ID=c(a.NUMBER),n.BIGINT_ID=c(a.BIGINT),n.STRING_ID=c(a.STRING),n.IDENT_ID=c(a.IDENT),n.LPAREN_ID=c(a.LPAREN),n.RPAREN_ID=c(a.RPAREN),n.MINUS_ID=c(a.MINUS),n.PLUS_ID=c(a.PLUS),n.KEYWORD_ID=c(a.KEYWORD),n.STAR_ID=c(a.STAR),n.SLASH_ID=c(a.SLASH),n.MOD_ID=c(a.MOD),n.CARET_ID=c(a.CARET),n.LSHIFT_ID=c(a.LSHIFT),n.RSHIFT_ID=c(a.RSHIFT),n.URSHIFT_ID=c(a.URSHIFT),n.BIT_AND_ID=c(a.BIT_AND),n.BIT_OR_ID=c(a.BIT_OR),n.BIT_XOR_ID=c(a.BIT_XOR),n.PERCENT_ID=c(a.PERCENT),n.OF_ID=c(a.OF),n.INFIX_OPCODE={[c(a.PLUS)]:20,[c(a.MINUS)]:21,[c(a.STAR)]:22,[c(a.SLASH)]:23,[c(a.MOD)]:24,[c(a.CARET)]:25,[c(a.LSHIFT)]:30,[c(a.RSHIFT)]:31,[c(a.URSHIFT)]:32,[c(a.BIT_AND)]:33,[c(a.BIT_OR)]:34,[c(a.BIT_XOR)]:35,[c(a.OF)]:22},n.CARET_SUFFIX_RULES=[{name:"transpose (^T)",matches:e=>{let t=e.peek();return t?.type===a.IDENT&&t.value==="T"},emit:(e,t)=>{e.advance(),t.emitOpcode(51),t.emitIndex(63),t.emitIndex(1);}},{name:"inverse (^-1)",matches:e=>{if(e.peek()?.typeId!==n.MINUS_ID)return  false;let r=e.peekAt(1);return r?.type===a.NUMBER&&r.value==="1"},emit:(e,t)=>{e.advance(),e.advance(),t.emitOpcode(51),t.emitIndex(65),t.emitIndex(1);}}];var v=n;var y=class{constructor(){this.prefixParselets=new Map;this.infixParselets=new Map;this.prefixById=new Map;this.infixById=new Map;}registerPrefix(e,t){let r=this.prefixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Prefix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.prefixParselets.set(e,t),this.prefixById.set(c(e),t);}registerInfix(e,t){let r=this.infixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Infix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.infixParselets.set(e,t),this.infixById.set(c(e),t);}getAllPrefix(){let e=[];for(let[t,r]of this.prefixParselets)e.push({tokenType:t,bindingPower:r.bindingPower??a$2.Prefix,category:r.category});return e}getAllInfix(){let e=[];for(let[t,r]of this.infixParselets){let p=r.bindingPower??0;e.push({tokenType:t,leftBindingPower:p,rightBindingPower:p+1,category:r.category});}return e}get prefixCount(){return this.prefixParselets.size}get infixCount(){return this.infixParselets.size}getPrefix(e){return typeof e=="number"?this.prefixById.get(e):this.prefixParselets.get(e)}getInfix(e){return typeof e=="number"?this.infixById.get(e):this.infixParselets.get(e)}hasPrefix(e){return this.prefixParselets.has(e)}hasInfix(e){return this.infixParselets.has(e)}clear(){this.prefixParselets.clear(),this.infixParselets.clear(),this.prefixById.clear(),this.infixById.clear();}},H=new y;export{v as a,y as b,H as c};//# sourceMappingURL=chunk-JVMINMAB.js.map
-//# sourceMappingURL=chunk-JVMINMAB.js.map

package/dist/chunk-JVMINMAB.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/PrecedenceParser.ts","../src/parser/registry/ParseletRegistry.ts"],"names":["CHAINED_DOT_THOUSANDS_GROUPS","PLAIN_DECIMAL","_PrecedenceParser","parseletRegistry","maxDepth","localeCode","pluginFunctionIndex","display","getLocale","pipeline","expression","tokens","hasParens","LPAREN_ID","tokenTypeId","TokenTypes","RPAREN_ID","openCount","i","result","lastToken","minBp","_builder","ErrorFactory","token","len","bpTable","registry","builder","idx","lookahead","bp","infixParselet","typeId","rightBp","parselet","v","decimalText","raw","dots","plain","c","decimalSep","thousandsSep","normalized","bigIntLiteralDigits","count","BindingPower","prefixParselet","rule","openIdx","depth","t","nameToken","closeIdx","params","bodyBuilder","BytecodeBuilder","bodyProgram","bodyIdx","argCount","expectedType","expectedId","offset","isPrefix","bindingPower","event","DiagnosticEventType","buildBindingPowerTable","p","next","afterMinus","PrecedenceParser","ParseletRegistry","tokenType","existing","left","sharedParseletRegistry"],"mappings":"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","file":"chunk-JVMINMAB.js","sourcesContent":["import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { bigIntLiteralDigits } from \"@solve-js/parser/BigIntLiteral\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * A plain fractional literal: digits, exactly one dot, digits, nothing else.\n *\n * The gate for compiling to PUSH_DECIMAL. It admits \"0.10\", \"1.005\", \".5\" and\n * \"5.\" and refuses anything with an exponent (\"2.5e-3\"), which parses as an\n * ordinary double instead, since scientific notation has no exact base-ten\n * value this representation would keep.\n */\nconst PLAIN_DECIMAL = /^\\d*\\.\\d*$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /** The locale's decimal separator, cached from {@link localeCode}. */\n  private readonly decimalSeparator: string;\n\n  /** The locale's thousands separator, cached from {@link localeCode}. */\n  private readonly thousandsSeparator: string;\n\n  /**\n   * The binding power the current infix parselet is being invoked at, i.e. the\n   * `minBp` of the expression it sits inside. Set immediately before each Tier-2\n   * parselet runs. A parselet that decides whether to swallow a following\n   * loose operator (UomLiteralParselet with a trailing `in`/`to`) reads this to\n   * respect precedence it cannot otherwise see: `120 km / 2 hours in kph` must\n   * group as `(120 km / 2 hours) in kph`, not `120 km / (2 hours in kph)`.\n   */\n  infixMinBindingPower = 0;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly URSHIFT_ID  = tokenTypeId(TokenTypes.URSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.URSHIFT)]: OpCode.URSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  /** Shared with every BytecodeBuilder so a nested-body builder resolves plugin calls by name. */\n  private pluginFunctionIndex?: ReadonlyMap<string, number>;\n\n  constructor(parseletRegistry: ParseletRegistry, maxDepth = 50, localeCode = \"en\", pluginFunctionIndex?: ReadonlyMap<string, number>) {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n    // Read once, not once per number literal. `localeCode` is set here and\n    // never reassigned, so these cannot go stale, and the profile had\n    // getLocale() plus its property chain inside the hot NUMBER path.\n    const display = getLocale(localeCode).display;\n    this.decimalSeparator = display.decimalSeparator;\n    this.thousandsSeparator = display.thousandsSeparator;\n    this.pluginFunctionIndex = pluginFunctionIndex;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp - 1`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter.\n    if (_builder) {\n      this.builder = _builder;\n    }\n    this.depth++;\n    if (this.depth > this.maxDepth) {\n      this.depth--;\n      throw ErrorFactory.parsing(\n        \"NESTING_DEPTH_EXCEEDED\",\n        `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n        { maxDepth: this.maxDepth, currentDepth: this.depth }\n      );\n    }\n\n    const token = this.consume();\n    if (!token) {\n      this.depth--;\n      throw ErrorFactory.parsing(\"UNEXPECTED_END\", \"Unexpected end of expression\");\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → Percentage holding 0.5.\n          //\n          // Must stay byte-for-byte equivalent to PercentParselet, which is\n          // the Tier-2 registration of the same operator. This path is the one\n          // that actually runs for ordinary expressions, so a change made only\n          // in the parselet does nothing at all: that is exactly how the\n          // divide-by-100 here outlived its replacement and kept `200 + 10%`\n          // answering 200.10.\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n          builder.emitOpcode(OpCode.TO_PERCENTAGE);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          //\n          // The threshold has to be bp - 1, not bp. The loop above breaks on\n          // `bp <= minBp`, so a right operand parsed at `bp` stops at the next\n          // `^` exactly as one parsed at `bp + 1` does: the old special case\n          // was dead code and \"2 ^ 3 ^ 2\" grouped left, answering 64. One\n          // below lets the recursive call keep consuming `^`, which is what\n          // makes it 2^(3^2) = 512, as in mathematics, Python, Ruby and\n          // JavaScript's `**`.\n          //\n          // Nothing else sits between Exponent (50) and Product (40), so\n          // 49 cannot collide with another operator's level. Unary minus is\n          // unaffected: it parses its operand at Prefix (60), above `^`\n          // either way, so \"-2 ^ 2\" is still (-2)^2 = 4.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp - 1 : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Expose the level this parselet is bound at, so one that peeks past its\n        // own token (a unit literal weighing whether a trailing `in`/`to` is\n        // its own or an outer operator's) can respect precedence. See\n        // infixMinBindingPower's doc comment.\n        this.infixMinBindingPower = minBp;\n        // Parselet handles its own recursion for right operand internally\n        infixParselet.parse(this, token, lookahead, builder);\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n    this.depth--;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        // The exact dot-decimal text for a literal written with a fractional\n        // point, so it can be pushed as PUSH_DECIMAL and keep its precision\n        // where it later meets money. Stays null for every integer shape\n        // (hex/bin/oct, chained-dot grouping, plain integers), which push the\n        // ordinary PUSH_NUMBER and are unchanged.\n        let decimalText: string | null = null;\n        const raw = token.value;\n\n        // Fast path: plain digits, with at most one \".\".\n        //\n        // Most literals in a document are `144`, `1200`, `0.85`. The general\n        // path below reaches the same answer for them only after six\n        // startsWith() calls, two regular expressions and a split/join that\n        // allocated whether or not the separator was present; a CPU profile put\n        // this whole case at over a third of parse-and-compile. One character\n        // scan settles it instead.\n        //\n        // Guarded on the decimal separator being \".\", which is what makes a\n        // lone dot unambiguous. Where \".\" groups thousands instead, `1.234`\n        // means one thousand two hundred and thirty-four, so that locale has to\n        // keep taking the general path.\n        if (this.decimalSeparator === \".\") {\n          let dots = 0;\n          let plain = raw.length > 0;\n          for (let i = 0; i < raw.length; i++) {\n            const c = raw.charCodeAt(i);\n            if (c >= 48 && c <= 57) continue;\n            if (c === 46 && dots === 0) { dots = 1; continue; }\n            plain = false;\n            break;\n          }\n          if (plain) {\n            // One dot with digits optional on either side is exactly what\n            // PLAIN_DECIMAL matches, so this agrees with it: that is the signal\n            // for the exact-decimal opcode rather than a double.\n            if (dots === 1) {\n              builder.emitOpcode(OpCode.PUSH_DECIMAL);\n              builder.emitString(raw);\n              return;\n            }\n            builder.emitOpcode(OpCode.PUSH_NUMBER);\n            builder.emitNumber(+raw);\n            return;\n          }\n        }\n\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid hex literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid binary literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid octal literal: \"${raw}\"`, { raw });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const decimalSep = this.decimalSeparator;\n          const thousandsSep = this.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation).\n          // The indexOf guard stops that pair allocating an array and a string\n          // for the many literals that contain no separator at all.\n          if (thousandsSep && normalized.indexOf(thousandsSep) !== -1) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n          // A plain fractional literal (digits, one dot, digits) is what carries\n          // an exact decimal. Scientific notation like \"2.5e-3\" has a dot too\n          // but no exact base-ten form worth the trouble, so it stays a\n          // PUSH_NUMBER double, and so does any integer (grouping stripped).\n          if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;\n        }\n        if (decimalText !== null) {\n          builder.emitOpcode(OpCode.PUSH_DECIMAL);\n          builder.emitString(decimalText);\n          return;\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strips the `n` and any thousands grouping the lexer coalesced in.\n        // This used to be `raw.slice(0, -1)` and nothing else, so `1.000n`\n        // reached BigInt(\"1.000\") and threw a raw SyntaxError. See\n        // parser/BigIntLiteral.ts, which the parselet tier shares.\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(bigIntLiteralDigits(token.value, this.localeCode));\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing(\n        \"NO_PREFIX_PARSELET\",\n        `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        { tokenType: token.type, tokenValue: token.value }\n      );\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing(\n      \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      { actualType: token?.type },\n    );\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing(\n        \"USER_FUNCTION_NO_PARAMS\",\n        `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        { name: nameToken.value },\n      );\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder(this.pluginFunctionIndex);\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing(\n        \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        { name: nameToken.value },\n      );\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing(\n        \"UNEXPECTED_END_OF_INPUT\",\n        \"Unexpected end of input\"\n      );\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing(\n          \"UNEXPECTED_TOKEN_TYPE\",\n          `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          { expectedType, actualType: token.type, actualValue: token.value }\n        );\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n","import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\n\n/**\n * The one binding-power field a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `InfixParselet` requires `bindingPower`; `PrefixParselet` declares none, and\n * some prefix parselets carry one anyway. That single field is the whole\n * optional surface deliberately. A `leftBindingPower`/`rightBindingPower` pair\n * used to be read here as well, and reading a name off an object this way finds\n * PRIVATE fields too, since TypeScript's `private` exists only at compile time:\n * `BinaryOpParselet` holds a private `rightBindingPower` meaning \"the minimum\n * power to parse my right operand at\", which is a different quantity from \"the\n * power at which I bind to my right\" and differs from it by one. Reading it\n * silently reported that other number. So neither is read.\n *\n * `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n}\n\n/** Reads the optional binding-power field off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/**\n\t * Iterate all registered prefix parselets for diagnostic display.\n\t *\n\t * `PrefixParselet` declares no binding power, and this used to read a field\n\t * of that name and report 0 for every one of them. 0 is not a neutral\n\t * wrong answer: it is the value that means \"not an operator, stop the\n\t * expression\", so a host drawing a table from this was told none of them\n\t * bind at all. A prefix parselet in this parser has no per-parselet power\n\t * to report, they all bind at the prefix level and each chooses for itself\n\t * at what power to parse its own operand, so that level is what is\n\t * reported. A parselet that does carry its own `bindingPower` still wins.\n\t */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? BindingPower.Prefix,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Iterate all registered infix parselets for diagnostic display.\n\t *\n\t * The field an `InfixParselet` actually declares is `bindingPower`. This\n\t * used to read `leftBindingPower` and `rightBindingPower`, which no\n\t * parselet in this codebase declares, so both reads were `undefined`, both\n\t * fell to the `?? 0` default, and the public `getParseletRegistry()`\n\t * reported a binding power of 0 for every one of the ~60 infix operators.\n\t * A host building a precedence table from it was told `*` and `+` bind\n\t * equally, and that neither binds at all.\n\t *\n\t * The left/right split: `bindingPower` is the LEFT power, and the right is\n\t * one higher. That is the standard encoding for a left-associative\n\t * operator, and it is what the parser itself does, see\n\t * `PrecedenceParser.parseExpression()`'s `bp + 1` for the right operand.\n\t * Every operator is reported that way, `^` included. Associativity is not\n\t * something a parselet declares, it is a property of how each one calls\n\t * `parseExpression`, so this API cannot report it without a new field on\n\t * the interface. See {@link ParseletBindingPowers} for why scraping a\n\t * plausible-looking one off the parselet is worse than not reporting it.\n\t */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tconst left = bindingPowersOf(parselet).bindingPower ?? 0;\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: left,\n\t\t\t\trightBindingPower: left + 1,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. Nothing writes to it now\n * that the global package-registration path is gone; it remains only so the\n * `@solve-js/parser` escape hatch keeps a stable shape.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n"]}

package/dist/chunk-JYLNQOPU.cjs

@@ -1,2 +0,0 @@
-'use strict';var chunkHG4NPDN5_cjs=require('./chunk-HG4NPDN5.cjs'),chunkEN3CDYOS_cjs=require('./chunk-EN3CDYOS.cjs'),chunk5IJD5L3O_cjs=require('./chunk-5IJD5L3O.cjs'),chunkS3DFU33X_cjs=require('./chunk-S3DFU33X.cjs'),chunkCO2BI6WL_cjs=require('./chunk-CO2BI6WL.cjs');var D=/^\d{1,3}(\.\d{3}){2,}$/,T=/^\d*\.\d*$/,n=class n{constructor(e,t=50,r="en",p){this.tokens=[];this.current=0;this.depth=0;this.currentExpression="";this.infixMinBindingPower=0;this.registry=e,this.maxDepth=t,this.localeCode=r;let a=chunkS3DFU33X_cjs.a(r).display;this.decimalSeparator=a.decimalSeparator,this.thousandsSeparator=a.thousandsSeparator,this.pluginFunctionIndex=p;}getLocaleCode(){return this.localeCode}setDiagnosticPipeline(e,t){this.diagnosticPipeline=e,this.currentExpression=t??"";}load(e,t){if(t===false){this.tokens=e,this.current=0,this.depth=0;return}let r=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.LPAREN),p=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.RPAREN),a=0;for(let l=0;l<e.length;l++)e[l].typeId===r?a++:e[l].typeId===p&&a--;this.tokens=a===0?e:this.balanceParens(e,a),this.current=0,this.depth=0;}balanceParens(e,t){let r=e.slice();if(t>0){let p=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.RPAREN);for(let a=0;a<t;a++){let l=e[e.length-1];r.push({type:chunk5IJD5L3O_cjs.a.RPAREN,typeId:p,value:")",text:")",offset:l?l.offset+l.text.length:0,lineBreaks:0,line:l?l.line:1,col:l?l.col+l.text.length:1});}}else if(t<0){let p=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.LPAREN);for(let a=0;a<-t;a++)r.unshift({type:chunk5IJD5L3O_cjs.a.LPAREN,typeId:p,value:"(",text:"(",offset:0,lineBreaks:0,line:1,col:1});}return r}parseExpression(e=0,t){if(t&&(this.builder=t),this.depth++,this.depth>this.maxDepth)throw this.depth--,chunkCO2BI6WL_cjs.c.parsing("NESTING_DEPTH_EXCEEDED",`Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,{maxDepth:this.maxDepth,currentDepth:this.depth});let r=this.consume();if(!r)throw this.depth--,chunkCO2BI6WL_cjs.c.parsing("UNEXPECTED_END","Unexpected end of expression");this.parsePrefix(r);let p=this.tokens,a=p.length,l=n.BP_TABLE,o=this.registry,c=this.builder,d=this.current;for(;d<a;){let h=p[d];if(!h)break;let I=l[h.typeId];if(I>0){if(I<=e)break;if(this.diagnosticPipeline){let m=o.getInfix(h.typeId);m&&this.fireParseletMatched(m,h,false,I);}this.current=++d;let f=h.typeId;if(f===n.PERCENT_ID)c.emitOpcode(10),c.emitNumber(100),c.emitOpcode(23),c.emitOpcode(74);else if(!(f===n.CARET_ID&&this.tryEmitMatrixCaretOp(c))){let m=f===n.CARET_ID?I-1:I+1;this.parseExpression(m,c),c.emitOpcode(n.INFIX_OPCODE[f]);}}else {let f=o.getInfix(h.typeId);if(!f||f.bindingPower<=e)break;this.current=++d,this.diagnosticPipeline&&this.fireParseletMatched(f,h,false,f.bindingPower),this.infixMinBindingPower=e,f.parse(this,r,h,c);}d=this.current;}this.current=d,this.depth--;}parsePrefix(e){let t=this.builder,r=e.typeId;if(this.diagnosticPipeline){let a=this.registry.getPrefix(r);a&&this.fireParseletMatched(a,e,true);}switch(r){case n.NUMBER_ID:{let a,l=null,o=e.value;if(this.decimalSeparator==="."){let c=0,d=o.length>0;for(let h=0;h<o.length;h++){let I=o.charCodeAt(h);if(!(I>=48&&I<=57)){if(I===46&&c===0){c=1;continue}d=false;break}}if(d){if(c===1){t.emitOpcode(16),t.emitString(o);return}t.emitOpcode(10),t.emitNumber(+o);return}}if(o.startsWith("0x")||o.startsWith("0X")){if(a=parseInt(o,16),Number.isNaN(a))throw chunkCO2BI6WL_cjs.c.parsing("INVALID_NUMBER_LITERAL",`Invalid hex literal: "${o}"`,{raw:o})}else if(o.startsWith("0b")||o.startsWith("0B")){if(a=parseInt(o.slice(2),2),Number.isNaN(a))throw chunkCO2BI6WL_cjs.c.parsing("INVALID_NUMBER_LITERAL",`Invalid binary literal: "${o}"`,{raw:o})}else if(o.startsWith("0o")||o.startsWith("0O")){if(a=parseInt(o.slice(2),8),Number.isNaN(a))throw chunkCO2BI6WL_cjs.c.parsing("INVALID_NUMBER_LITERAL",`Invalid octal literal: "${o}"`,{raw:o})}else if(D.test(o))a=parseFloat(o.split(".").join(""));else {let c=this.decimalSeparator,d=this.thousandsSeparator,h=o;d&&h.indexOf(d)!==-1&&(h=h.split(d).join("")),c&&c!=="."&&(h=h.replace(c,".")),a=parseFloat(h),T.test(h)&&(l=h);}if(l!==null){t.emitOpcode(16),t.emitString(l);return}t.emitOpcode(10),t.emitNumber(a);return}case n.BIGINT_ID:{t.emitOpcode(11),t.emitString(chunkEN3CDYOS_cjs.e(e.value,this.localeCode));return}case n.STRING_ID:{t.emitOpcode(13),t.emitString(e.value);return}case n.IDENT_ID:{if(this.peek()?.typeId===n.LPAREN_ID){this.parseUserFunctionDefOrCall(e,t);return}t.emitOpcode(60),t.emitString(e.value);return}case n.LPAREN_ID:{this.parseExpression(0,t);let a=1;for(;this.match(chunk5IJD5L3O_cjs.a.COMMA);)this.parseExpression(0,t),a++;this.consume(chunk5IJD5L3O_cjs.a.RPAREN),a>1&&(t.emitOpcode(152),t.emitIndex(1),t.emitIndex(a));return}case n.MINUS_ID:{this.parseExpression(chunkEN3CDYOS_cjs.a.Prefix,t),t.emitOpcode(26);return}case n.PLUS_ID:{this.parseExpression(chunkEN3CDYOS_cjs.a.Prefix,t),t.emitOpcode(27);return}case n.KEYWORD_ID:}let p=this.registry.getPrefix(r);if(!p)throw chunkCO2BI6WL_cjs.c.parsing("NO_PREFIX_PARSELET",`No prefix parselet found for token: ${e.type} ("${e.value}")`,{tokenType:e.type,tokenValue:e.value});p.parse(this,e,t);}tryEmitMatrixCaretOp(e){for(let t of n.CARET_SUFFIX_RULES)if(t.matches(this))return t.emit(this,e),true;return  false}findMatchingRParen(e){let t=0;for(let r=e;r<this.tokens.length;r++){let p=this.tokens[r];if(p.typeId===n.LPAREN_ID)t++;else if(p.typeId===n.RPAREN_ID&&(t--,t===0))return r}return null}parseUserFunctionDefOrCall(e,t){let r=this.findMatchingRParen(this.current);if(r===null){t.emitOpcode(60),t.emitString(e.value);return}this.tokens[r+1]?.type===chunk5IJD5L3O_cjs.a.EQUALS?this.parseUserFunctionDefinition(e,t):this.parseUserFunctionCall(e,t);}consumeParamName(){let e=this.peek();if(e?.type===chunk5IJD5L3O_cjs.a.IDENT||e?.type===chunk5IJD5L3O_cjs.a.UNIT)return this.consume(),e.value;throw chunkCO2BI6WL_cjs.c.parsing("USER_FUNCTION_INVALID_PARAM_NAME",`Expected a parameter name but got "${e?.type??"end of input"}"${e?` ("${e.value}")`:""}`,{actualType:e?.type})}parseUserFunctionDefinition(e,t){this.consume(chunk5IJD5L3O_cjs.a.LPAREN);let r=[];if(this.peek()?.type!==chunk5IJD5L3O_cjs.a.RPAREN)for(r.push(this.consumeParamName());this.match(chunk5IJD5L3O_cjs.a.COMMA);)r.push(this.consumeParamName());if(this.consume(chunk5IJD5L3O_cjs.a.RPAREN),this.consume(chunk5IJD5L3O_cjs.a.EQUALS),r.length===0)throw chunkCO2BI6WL_cjs.c.parsing("USER_FUNCTION_NO_PARAMS",`"${e.value}()" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,{name:e.value});let p=new chunkEN3CDYOS_cjs.d(this.pluginFunctionIndex);this.parseExpression(chunkEN3CDYOS_cjs.a.Lowest,p),this.setBuilder(t);let a=p.build();if(a.hasAsync)throw chunkCO2BI6WL_cjs.c.parsing("FUNCTION_BODY_MUST_BE_SYNCHRONOUS",`"${e.value}(...)"'s body calls an async operation (weather, stocks, currency, ...) \u2014 user-defined function bodies must be synchronous`,{name:e.value});let l=t.emitUserFunctionBody(e.value,r,a);t.emitOpcode(150),t.emitIndex(l),t.emitOpcode(13),t.emitString(`${e.value}(${r.join(", ")}) defined`);}parseUserFunctionCall(e,t){this.consume(chunk5IJD5L3O_cjs.a.LPAREN);let r=0;if(this.peek()?.type!==chunk5IJD5L3O_cjs.a.RPAREN)for(this.parseExpression(chunkEN3CDYOS_cjs.a.Lowest,t),r++;this.match(chunk5IJD5L3O_cjs.a.COMMA);)this.parseExpression(chunkEN3CDYOS_cjs.a.Lowest,t),r++;this.consume(chunk5IJD5L3O_cjs.a.RPAREN),t.emitOpcode(151),t.emitString(e.value),t.emitByte(r);}consume(e){let t=this.tokens[this.current];if(!t)throw chunkCO2BI6WL_cjs.c.parsing("UNEXPECTED_END_OF_INPUT","Unexpected end of input");if(e!==void 0){let r=chunk5IJD5L3O_cjs.c(e);if(t.typeId!==r)throw chunkCO2BI6WL_cjs.c.parsing("UNEXPECTED_TOKEN_TYPE",`Expected token type "${e}" but got "${t.type}" ("${t.value}")`,{expectedType:e,actualType:t.type,actualValue:t.value})}return this.current++,t}match(e){let t=this.peek();return t&&t.typeId===chunk5IJD5L3O_cjs.c(e)?(this.advance(),true):false}peek(){return this.tokens[this.current]}peekAt(e){return this.tokens[this.current+e]}previous(){return this.current>0?this.tokens[this.current-1]:void 0}advance(){this.current++;}setBuilder(e){this.builder=e;}fireParseletMatched(e,t,r,p){let a=this.diagnosticPipeline,l={type:chunkHG4NPDN5_cjs.c.ParseletMatched,elapsedNs:0,expression:this.currentExpression,tokenType:t.type,tokenValue:t.value,parseletCategory:e.category,parseletType:e.constructor?.name??"unknown",isPrefix:r,bindingPower:p,tokenOffset:t.offset||0};a.fireParseletMatched(l);}};n.BP_TABLE=chunkEN3CDYOS_cjs.b(),n.NUMBER_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.NUMBER),n.BIGINT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIGINT),n.STRING_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.STRING),n.IDENT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.IDENT),n.LPAREN_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.LPAREN),n.RPAREN_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.RPAREN),n.MINUS_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.MINUS),n.PLUS_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.PLUS),n.KEYWORD_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.KEYWORD),n.STAR_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.STAR),n.SLASH_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.SLASH),n.MOD_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.MOD),n.CARET_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.CARET),n.LSHIFT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.LSHIFT),n.RSHIFT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.RSHIFT),n.URSHIFT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.URSHIFT),n.BIT_AND_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_AND),n.BIT_OR_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_OR),n.BIT_XOR_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_XOR),n.PERCENT_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.PERCENT),n.OF_ID=chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.OF),n.INFIX_OPCODE={[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.PLUS)]:20,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.MINUS)]:21,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.STAR)]:22,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.SLASH)]:23,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.MOD)]:24,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.CARET)]:25,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.LSHIFT)]:30,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.RSHIFT)]:31,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.URSHIFT)]:32,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_AND)]:33,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_OR)]:34,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.BIT_XOR)]:35,[chunk5IJD5L3O_cjs.c(chunk5IJD5L3O_cjs.a.OF)]:22},n.CARET_SUFFIX_RULES=[{name:"transpose (^T)",matches:e=>{let t=e.peek();return t?.type===chunk5IJD5L3O_cjs.a.IDENT&&t.value==="T"},emit:(e,t)=>{e.advance(),t.emitOpcode(51),t.emitIndex(63),t.emitIndex(1);}},{name:"inverse (^-1)",matches:e=>{if(e.peek()?.typeId!==n.MINUS_ID)return  false;let r=e.peekAt(1);return r?.type===chunk5IJD5L3O_cjs.a.NUMBER&&r.value==="1"},emit:(e,t)=>{e.advance(),e.advance(),t.emitOpcode(51),t.emitIndex(65),t.emitIndex(1);}}];var v=n;var y=class{constructor(){this.prefixParselets=new Map;this.infixParselets=new Map;this.prefixById=new Map;this.infixById=new Map;}registerPrefix(e,t){let r=this.prefixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Prefix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.prefixParselets.set(e,t),this.prefixById.set(chunk5IJD5L3O_cjs.c(e),t);}registerInfix(e,t){let r=this.infixParselets.get(e);r&&r!==t&&console.warn(`[ParseletRegistry] Infix parselet for token "${e}" is already registered (category: "${r.category??"unknown"}"). Overwriting with a new parselet (category: "${t.category??"unknown"}") \u2014 the previous parselet is now unreachable. Two packages may be claiming the same token type.`),this.infixParselets.set(e,t),this.infixById.set(chunk5IJD5L3O_cjs.c(e),t);}getAllPrefix(){let e=[];for(let[t,r]of this.prefixParselets)e.push({tokenType:t,bindingPower:r.bindingPower??chunkEN3CDYOS_cjs.a.Prefix,category:r.category});return e}getAllInfix(){let e=[];for(let[t,r]of this.infixParselets){let p=r.bindingPower??0;e.push({tokenType:t,leftBindingPower:p,rightBindingPower:p+1,category:r.category});}return e}get prefixCount(){return this.prefixParselets.size}get infixCount(){return this.infixParselets.size}getPrefix(e){return typeof e=="number"?this.prefixById.get(e):this.prefixParselets.get(e)}getInfix(e){return typeof e=="number"?this.infixById.get(e):this.infixParselets.get(e)}hasPrefix(e){return this.prefixParselets.has(e)}hasInfix(e){return this.infixParselets.has(e)}clear(){this.prefixParselets.clear(),this.infixParselets.clear(),this.prefixById.clear(),this.infixById.clear();}},H=new y;exports.a=v;exports.b=y;exports.c=H;//# sourceMappingURL=chunk-JYLNQOPU.cjs.map
-//# sourceMappingURL=chunk-JYLNQOPU.cjs.map

package/dist/chunk-JYLNQOPU.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/PrecedenceParser.ts","../src/parser/registry/ParseletRegistry.ts"],"names":["CHAINED_DOT_THOUSANDS_GROUPS","PLAIN_DECIMAL","_PrecedenceParser","parseletRegistry","maxDepth","localeCode","pluginFunctionIndex","display","getLocale","pipeline","expression","tokens","hasParens","LPAREN_ID","tokenTypeId","TokenTypes","RPAREN_ID","openCount","i","result","lastToken","minBp","_builder","ErrorFactory","token","len","bpTable","registry","builder","idx","lookahead","bp","infixParselet","typeId","rightBp","parselet","v","decimalText","raw","dots","plain","c","decimalSep","thousandsSep","normalized","bigIntLiteralDigits","count","BindingPower","prefixParselet","rule","openIdx","depth","t","nameToken","closeIdx","params","bodyBuilder","BytecodeBuilder","bodyProgram","bodyIdx","argCount","expectedType","expectedId","offset","isPrefix","bindingPower","event","DiagnosticEventType","buildBindingPowerTable","p","next","afterMinus","PrecedenceParser","ParseletRegistry","tokenType","existing","left","sharedParseletRegistry"],"mappings":"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","file":"chunk-JYLNQOPU.cjs","sourcesContent":["import { ParseletRegistry } from \"@solve-js/parser/registry/ParseletRegistry\";\nimport { Token, tokenTypeId, TokenTypes } from \"@solve-js/lexer/Token\";\nimport { BytecodeBuilder } from \"@solve-js/parser/BytecodeBuilder\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { DiagnosticPipeline, DiagnosticEventType, type DiagnosticEvent } from \"@solve-js/diagnostics\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { BindingPower, buildBindingPowerTable } from \"@solve-js/parser/BindingPower\";\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { bigIntLiteralDigits } from \"@solve-js/parser/BigIntLiteral\";\n\n/**\n * Matches a CHAINED thousands-grouped integer using \".\" as the group\n * separator (e.g. \"1.234.567\"), independent of locale. Kept in sync with\n * the identical constant in NumberParselet.ts (not imported from there\n * that file transitively re-imports PrecedenceParser via Parser.ts's\n * `export { PrecedenceParser as Parser }`, so importing the other\n * direction would create a circular dependency for the sake of one\n * regex literal). See NumberParselet.ts's copy for the full explanation.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/**\n * A plain fractional literal: digits, exactly one dot, digits, nothing else.\n *\n * The gate for compiling to PUSH_DECIMAL. It admits \"0.10\", \"1.005\", \".5\" and\n * \"5.\" and refuses anything with an exponent (\"2.5e-3\"), which parses as an\n * ordinary double instead, since scientific notation has no exact base-ten\n * value this representation would keep.\n */\nconst PLAIN_DECIMAL = /^\\d*\\.\\d*$/;\n\n/**\n * ── Hybrid Precedence Climbing Parser ─────────────────────────────────────────\n *\n * Two-tier dispatch strategy:\n *\n *   Tier 1 (Fast Path): Inline switch on token.typeId for built-in operators.\n *     - Prefix: NUMBER, IDENT, LPAREN, MINUS, PLUS, STRING\n *     - Infix:  checked via static BP_TABLE (Uint8Array indexed by typeId)\n *     - No Map.get(), no parselet function call overhead for ~95% of tokens\n *\n *   Tier 2 (Plugin Path): ParseletRegistry fallback for custom/plugin tokens.\n *     - Prefix: Map.get(tokenTypeId) for PrefixParselet\n *     - Infix:  Map.get(tokenTypeId) for InfixParselet\n *     - Full flexibility for custom syntax\n *\n * The parser emits directly to a BytecodeBuilder, no AST intermediate.\n * Implements the same public API as the legacy Parser class so existing\n * parselets continue to work without modification.\n */\nexport class PrecedenceParser {\n  private tokens: Token[] = [];\n  private current = 0;\n  private depth = 0;\n  private maxDepth: number;\n\n  /** Cached registry reference, avoids property chain in hot loop */\n  private registry: ParseletRegistry;\n\n  /** BytecodeBuilder, set before each parseExpression call */\n  private builder!: BytecodeBuilder;\n\n  /** Diagnostic pipeline for parselet-matched events */\n  private diagnosticPipeline: DiagnosticPipeline | undefined;\n  private currentExpression: string = \"\";\n  private localeCode: string;\n\n  /** The locale's decimal separator, cached from {@link localeCode}. */\n  private readonly decimalSeparator: string;\n\n  /** The locale's thousands separator, cached from {@link localeCode}. */\n  private readonly thousandsSeparator: string;\n\n  /**\n   * The binding power the current infix parselet is being invoked at, i.e. the\n   * `minBp` of the expression it sits inside. Set immediately before each Tier-2\n   * parselet runs. A parselet that decides whether to swallow a following\n   * loose operator (UomLiteralParselet with a trailing `in`/`to`) reads this to\n   * respect precedence it cannot otherwise see: `120 km / 2 hours in kph` must\n   * group as `(120 km / 2 hours) in kph`, not `120 km / (2 hours in kph)`.\n   */\n  infixMinBindingPower = 0;\n\n  /**\n   * Static binding power table, built once at module load, shared across all instances.\n   * Index = tokenTypeId, value = binding power (0 = not a built-in infix).\n   */\n  static readonly BP_TABLE: Uint8Array = buildBindingPowerTable();\n\n  // ── Pre-computed token type IDs for inline dispatch ────────────────────────\n  // Prefix built-ins\n  private static readonly NUMBER_ID   = tokenTypeId(TokenTypes.NUMBER);\n  private static readonly BIGINT_ID   = tokenTypeId(TokenTypes.BIGINT);\n  private static readonly STRING_ID   = tokenTypeId(TokenTypes.STRING);\n  private static readonly IDENT_ID    = tokenTypeId(TokenTypes.IDENT);\n  private static readonly LPAREN_ID   = tokenTypeId(TokenTypes.LPAREN);\n  private static readonly RPAREN_ID   = tokenTypeId(TokenTypes.RPAREN);\n  private static readonly MINUS_ID    = tokenTypeId(TokenTypes.MINUS);\n  private static readonly PLUS_ID     = tokenTypeId(TokenTypes.PLUS);\n  private static readonly KEYWORD_ID  = tokenTypeId(TokenTypes.KEYWORD);\n\n  // Infix built-ins (Tier 1, full inline emission)\n  private static readonly STAR_ID     = tokenTypeId(TokenTypes.STAR);\n  private static readonly SLASH_ID    = tokenTypeId(TokenTypes.SLASH);\n  private static readonly MOD_ID      = tokenTypeId(TokenTypes.MOD);\n  private static readonly CARET_ID    = tokenTypeId(TokenTypes.CARET);\n  private static readonly LSHIFT_ID   = tokenTypeId(TokenTypes.LSHIFT);\n  private static readonly RSHIFT_ID   = tokenTypeId(TokenTypes.RSHIFT);\n  private static readonly URSHIFT_ID  = tokenTypeId(TokenTypes.URSHIFT);\n  private static readonly BIT_AND_ID  = tokenTypeId(TokenTypes.BIT_AND);\n  private static readonly BIT_OR_ID   = tokenTypeId(TokenTypes.BIT_OR);\n  private static readonly BIT_XOR_ID  = tokenTypeId(TokenTypes.BIT_XOR);\n  private static readonly PERCENT_ID  = tokenTypeId(TokenTypes.PERCENT);\n  private static readonly OF_ID       = tokenTypeId(TokenTypes.OF);\n\n  /**\n   * Inline opcode map for Tier 1 infix operators.\n   * tokenTypeId → OpCode. PERCENT and CARET are handled specially (not in this map).\n   */\n  private static readonly INFIX_OPCODE: Record<number, OpCode> = {\n    [tokenTypeId(TokenTypes.PLUS)]:    OpCode.ADD,\n    [tokenTypeId(TokenTypes.MINUS)]:   OpCode.SUB,\n    [tokenTypeId(TokenTypes.STAR)]:    OpCode.MUL,\n    [tokenTypeId(TokenTypes.SLASH)]:   OpCode.DIV,\n    [tokenTypeId(TokenTypes.MOD)]:     OpCode.MOD,\n    [tokenTypeId(TokenTypes.CARET)]:   OpCode.EXP,\n    [tokenTypeId(TokenTypes.LSHIFT)]:  OpCode.LSHIFT,\n    [tokenTypeId(TokenTypes.RSHIFT)]:  OpCode.RSHIFT,\n    [tokenTypeId(TokenTypes.URSHIFT)]: OpCode.URSHIFT,\n    [tokenTypeId(TokenTypes.BIT_AND)]: OpCode.BIT_AND,\n    [tokenTypeId(TokenTypes.BIT_OR)]:  OpCode.BIT_OR,\n    [tokenTypeId(TokenTypes.BIT_XOR)]: OpCode.BIT_XOR,\n    [tokenTypeId(TokenTypes.OF)]:      OpCode.MUL,\n  };\n\n  /** Shared with every BytecodeBuilder so a nested-body builder resolves plugin calls by name. */\n  private pluginFunctionIndex?: ReadonlyMap<string, number>;\n\n  constructor(parseletRegistry: ParseletRegistry, maxDepth = 50, localeCode = \"en\", pluginFunctionIndex?: ReadonlyMap<string, number>) {\n    this.registry = parseletRegistry;\n    this.maxDepth = maxDepth;\n    this.localeCode = localeCode;\n    // Read once, not once per number literal. `localeCode` is set here and\n    // never reassigned, so these cannot go stale, and the profile had\n    // getLocale() plus its property chain inside the hot NUMBER path.\n    const display = getLocale(localeCode).display;\n    this.decimalSeparator = display.decimalSeparator;\n    this.thousandsSeparator = display.thousandsSeparator;\n    this.pluginFunctionIndex = pluginFunctionIndex;\n  }\n\n  /** Get locale code for NumberParselet to normalize separators */\n  getLocaleCode(): string {\n    return this.localeCode;\n  }\n\n  /**\n   * Set the diagnostic pipeline for parselet matching events.\n   * Cleared after each non-cached parse to avoid holding refs.\n   */\n  setDiagnosticPipeline(pipeline: DiagnosticPipeline | undefined, expression: string): void {\n    this.diagnosticPipeline = pipeline;\n    this.currentExpression = expression ?? \"\";\n  }\n\n  /**\n   * Load tokens for parsing. Identical to Parser.load().\n   *\n   * @param hasParens - if false, skips the O(n) paren balance scan (~90% of expressions)\n   */\n  load(tokens: Token[], hasParens?: boolean): void {\n    if (hasParens === false) {\n      this.tokens = tokens;\n      this.current = 0;\n      this.depth = 0;\n      return;\n    }\n    // Paren scan: count balance to skip array copy for balanced expressions.\n    const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n    const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n    let openCount = 0;\n    for (let i = 0; i < tokens.length; i++) {\n      if (tokens[i].typeId === LPAREN_ID) openCount++;\n      else if (tokens[i].typeId === RPAREN_ID) openCount--;\n    }\n    this.tokens = openCount === 0 ? tokens : this.balanceParens(tokens, openCount);\n    this.current = 0;\n    this.depth = 0;\n  }\n\n  /**\n   * Auto-balance unmatched parentheses.\n   */\n  private balanceParens(tokens: Token[], openCount: number): Token[] {\n    const result = tokens.slice();\n    if (openCount > 0) {\n      const RPAREN_ID = tokenTypeId(TokenTypes.RPAREN);\n      for (let i = 0; i < openCount; i++) {\n        const lastToken = tokens[tokens.length - 1];\n        result.push({\n          type: TokenTypes.RPAREN,\n          typeId: RPAREN_ID,\n          value: \")\",\n          text: \")\",\n          offset: lastToken ? lastToken.offset + lastToken.text.length : 0,\n          lineBreaks: 0,\n          line: lastToken ? lastToken.line : 1,\n          col: lastToken ? lastToken.col + lastToken.text.length : 1,\n        } as Token);\n      }\n    } else if (openCount < 0) {\n      const LPAREN_ID = tokenTypeId(TokenTypes.LPAREN);\n      for (let i = 0; i < -openCount; i++) {\n        result.unshift({\n          type: TokenTypes.LPAREN,\n          typeId: LPAREN_ID,\n          value: \"(\",\n          text: \"(\",\n          offset: 0,\n          lineBreaks: 0,\n          line: 1,\n          col: 1,\n        } as Token);\n      }\n    }\n    return result;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Main entry point: precedence climbing parse expression\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a full expression starting at the current token position.\n   *\n   * @param minBp - minimum binding power (precedence climbing threshold).\n   *   For left-associative operators, the recursive call uses `bp + 1`.\n   *   For right-associative operators (^), it uses `bp - 1`.\n   * @param _builder - accepted for parselet API compatibility; always uses `this.builder`.\n   */\n  parseExpression(minBp: number = 0, _builder?: BytecodeBuilder): void {\n    // Accept builder via parameter for backward compatibility with the old Parser API.\n    // The ExpressionEngine always calls setBuilder() before parseExpression(),\n    // but tests and parselets pass builder as a parameter.\n    if (_builder) {\n      this.builder = _builder;\n    }\n    this.depth++;\n    if (this.depth > this.maxDepth) {\n      this.depth--;\n      throw ErrorFactory.parsing(\n        \"NESTING_DEPTH_EXCEEDED\",\n        `Parse nesting depth ${this.depth} exceeds maximum of ${this.maxDepth}`,\n        { maxDepth: this.maxDepth, currentDepth: this.depth }\n      );\n    }\n\n    const token = this.consume();\n    if (!token) {\n      this.depth--;\n      throw ErrorFactory.parsing(\"UNEXPECTED_END\", \"Unexpected end of expression\");\n    }\n\n    // ── Prefix ──────────────────────────────────────────────────────────────\n    this.parsePrefix(token);\n\n    // ── Infix loop (precedence climbing with inline Tier 1 dispatch) ──────────\n    const tokens = this.tokens;\n    const len = tokens.length;\n    const bpTable = PrecedenceParser.BP_TABLE;\n    const registry = this.registry;\n    const builder = this.builder;\n    let idx = this.current;\n\n    while (idx < len) {\n      const lookahead = tokens[idx];\n      if (!lookahead) break;\n\n      const bp = bpTable[lookahead.typeId];\n      if (bp > 0) {\n        // Tier 1: Built-in infix, full inline emission, zero parselet delegation\n        if (bp <= minBp) break;\n\n        if (this.diagnosticPipeline) {\n          // Fast path skips the registry, but built-ins are still registered\n          // there (for introspection/tests), look them up only in this\n          // diagnostics-only branch so the playground's \"matched parselets\"\n          // view isn't permanently blind to every arithmetic operator.\n          const infixParselet = registry.getInfix(lookahead.typeId);\n          if (infixParselet) {\n            this.fireParseletMatched(infixParselet, lookahead, false, bp);\n          }\n        }\n\n        this.current = ++idx;\n        const typeId = lookahead.typeId;\n\n        if (typeId === PrecedenceParser.PERCENT_ID) {\n          // Postfix: no right operand. \"50%\" → Percentage holding 0.5.\n          //\n          // Must stay byte-for-byte equivalent to PercentParselet, which is\n          // the Tier-2 registration of the same operator. This path is the one\n          // that actually runs for ordinary expressions, so a change made only\n          // in the parselet does nothing at all: that is exactly how the\n          // divide-by-100 here outlived its replacement and kept `200 + 10%`\n          // answering 200.10.\n          builder.emitOpcode(OpCode.PUSH_NUMBER);\n          builder.emitNumber(100);\n          builder.emitOpcode(OpCode.DIV);\n          builder.emitOpcode(OpCode.TO_PERCENTAGE);\n        } else if (typeId === PrecedenceParser.CARET_ID && this.tryEmitMatrixCaretOp(builder)) {\n          // `^T` (transpose) or `^-1` (inverse), already fully handled\n          // including consuming their own trailing tokens.\n        } else {\n          // Infix: parse right operand, then emit opcode.\n          // Right-associative for CARET (^), left-associative for all others.\n          //\n          // The threshold has to be bp - 1, not bp. The loop above breaks on\n          // `bp <= minBp`, so a right operand parsed at `bp` stops at the next\n          // `^` exactly as one parsed at `bp + 1` does: the old special case\n          // was dead code and \"2 ^ 3 ^ 2\" grouped left, answering 64. One\n          // below lets the recursive call keep consuming `^`, which is what\n          // makes it 2^(3^2) = 512, as in mathematics, Python, Ruby and\n          // JavaScript's `**`.\n          //\n          // Nothing else sits between Exponent (50) and Product (40), so\n          // 49 cannot collide with another operator's level. Unary minus is\n          // unaffected: it parses its operand at Prefix (60), above `^`\n          // either way, so \"-2 ^ 2\" is still (-2)^2 = 4.\n          const rightBp = (typeId === PrecedenceParser.CARET_ID) ? bp - 1 : bp + 1;\n          this.parseExpression(rightBp, builder);\n          builder.emitOpcode(PrecedenceParser.INFIX_OPCODE[typeId]);\n        }\n      } else {\n        // Tier 2: Plugin parselet fallback, full flexibility for custom syntax\n        const infixParselet = registry.getInfix(lookahead.typeId);\n        if (!infixParselet) break;\n        if (infixParselet.bindingPower <= minBp) break;\n\n        this.current = ++idx;\n\n        if (this.diagnosticPipeline) {\n          this.fireParseletMatched(infixParselet, lookahead, false, infixParselet.bindingPower);\n        }\n        // Expose the level this parselet is bound at, so one that peeks past its\n        // own token (a unit literal weighing whether a trailing `in`/`to` is\n        // its own or an outer operator's) can respect precedence. See\n        // infixMinBindingPower's doc comment.\n        this.infixMinBindingPower = minBp;\n        // Parselet handles its own recursion for right operand internally\n        infixParselet.parse(this, token, lookahead, builder);\n      }\n\n      idx = this.current;\n    }\n\n    this.current = idx;\n    this.depth--;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Prefix dispatch: inline switch for built-ins, parselet registry for plugins\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * Parse a prefix token. Built-in tokens (NUMBER, IDENT, LPAREN, etc.) are\n   * handled inline with zero registry lookup. Everything else falls through\n   * to the parselet registry (Tier 2).\n   */\n  private parsePrefix(token: Token): void {\n    const builder = this.builder;\n    const typeId = token.typeId;\n\n    if (this.diagnosticPipeline) {\n      // Fast path below skips the registry for built-ins, but they're still\n      // registered there (for introspection/tests), look up here so the\n      // playground's \"matched parselets\" view isn't permanently blind to\n      // every number, identifier, paren, and unary operator.\n      const parselet = this.registry.getPrefix(typeId);\n      if (parselet) {\n        this.fireParseletMatched(parselet, token, true);\n      }\n    }\n\n    switch (typeId) {\n      // ── Numeric literals ──────────────────────────────────────────────────\n      case PrecedenceParser.NUMBER_ID: {\n        // Parse number with locale-aware separator normalization\n        let v: number;\n        // The exact dot-decimal text for a literal written with a fractional\n        // point, so it can be pushed as PUSH_DECIMAL and keep its precision\n        // where it later meets money. Stays null for every integer shape\n        // (hex/bin/oct, chained-dot grouping, plain integers), which push the\n        // ordinary PUSH_NUMBER and are unchanged.\n        let decimalText: string | null = null;\n        const raw = token.value;\n\n        // Fast path: plain digits, with at most one \".\".\n        //\n        // Most literals in a document are `144`, `1200`, `0.85`. The general\n        // path below reaches the same answer for them only after six\n        // startsWith() calls, two regular expressions and a split/join that\n        // allocated whether or not the separator was present; a CPU profile put\n        // this whole case at over a third of parse-and-compile. One character\n        // scan settles it instead.\n        //\n        // Guarded on the decimal separator being \".\", which is what makes a\n        // lone dot unambiguous. Where \".\" groups thousands instead, `1.234`\n        // means one thousand two hundred and thirty-four, so that locale has to\n        // keep taking the general path.\n        if (this.decimalSeparator === \".\") {\n          let dots = 0;\n          let plain = raw.length > 0;\n          for (let i = 0; i < raw.length; i++) {\n            const c = raw.charCodeAt(i);\n            if (c >= 48 && c <= 57) continue;\n            if (c === 46 && dots === 0) { dots = 1; continue; }\n            plain = false;\n            break;\n          }\n          if (plain) {\n            // One dot with digits optional on either side is exactly what\n            // PLAIN_DECIMAL matches, so this agrees with it: that is the signal\n            // for the exact-decimal opcode rather than a double.\n            if (dots === 1) {\n              builder.emitOpcode(OpCode.PUSH_DECIMAL);\n              builder.emitString(raw);\n              return;\n            }\n            builder.emitOpcode(OpCode.PUSH_NUMBER);\n            builder.emitNumber(+raw);\n            return;\n          }\n        }\n\n        if (raw.startsWith(\"0x\") || raw.startsWith(\"0X\")) {\n          v = parseInt(raw, 16);\n          // A prefix with no digits after it (\"0x\" alone) makes parseInt\n          // return NaN. This used to push straight through as a silent\n          // NaN Number value instead of a visible error.\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid hex literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0b\") || raw.startsWith(\"0B\")) {\n          v = parseInt(raw.slice(2), 2);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid binary literal: \"${raw}\"`, { raw });\n          }\n        } else if (raw.startsWith(\"0o\") || raw.startsWith(\"0O\")) {\n          v = parseInt(raw.slice(2), 8);\n          if (Number.isNaN(v)) {\n            throw ErrorFactory.parsing(\"INVALID_NUMBER_LITERAL\", `Invalid octal literal: \"${raw}\"`, { raw });\n          }\n        } else if (CHAINED_DOT_THOUSANDS_GROUPS.test(raw)) {\n          // The lexer accepts \".\" as a thousands-group separator\n          // independent of locale (ExpressionLexer's number-scanning\n          // \"Thousands separators\" block), but the locale-based\n          // normalization below only strips the ACTIVE locale's own\n          // configured thousandsSeparator character, for \"en\" that's\n          // \",\", not \".\", so a chained dot-grouped literal like\n          // \"1.234.567\" fell through to parseFloat() untouched, which\n          // stops at the second \".\" and silently truncated it to 1.234\n          // (over 99% of the digits dropped, with no error). This is the\n          // REAL number-parsing path for actual evaluation, Tier 1 of\n          // the two-tier dispatch above always returns for NUMBER_ID, so\n          // NumberParselet.parse() (which has the identical fix) never\n          // actually runs except via direct unit tests / the \"matched\n          // parselets\" diagnostic display.\n          v = parseFloat(raw.split(\".\").join(\"\"));\n        } else {\n          const decimalSep = this.decimalSeparator;\n          const thousandsSep = this.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation).\n          // The indexOf guard stops that pair allocating an array and a string\n          // for the many literals that contain no separator at all.\n          if (thousandsSep && normalized.indexOf(thousandsSep) !== -1) {\n            normalized = normalized.split(thousandsSep).join(\"\");\n          }\n          // Replace locale decimal separator with \".\" for JavaScript parsing\n          if (decimalSep && decimalSep !== \".\") {\n            normalized = normalized.replace(decimalSep, \".\");\n          }\n          v = parseFloat(normalized);\n          // A plain fractional literal (digits, one dot, digits) is what carries\n          // an exact decimal. Scientific notation like \"2.5e-3\" has a dot too\n          // but no exact base-ten form worth the trouble, so it stays a\n          // PUSH_NUMBER double, and so does any integer (grouping stripped).\n          if (PLAIN_DECIMAL.test(normalized)) decimalText = normalized;\n        }\n        if (decimalText !== null) {\n          builder.emitOpcode(OpCode.PUSH_DECIMAL);\n          builder.emitString(decimalText);\n          return;\n        }\n        builder.emitOpcode(OpCode.PUSH_NUMBER);\n        builder.emitNumber(v);\n        return;\n      }\n\n      case PrecedenceParser.BIGINT_ID: {\n        // Strips the `n` and any thousands grouping the lexer coalesced in.\n        // This used to be `raw.slice(0, -1)` and nothing else, so `1.000n`\n        // reached BigInt(\"1.000\") and threw a raw SyntaxError. See\n        // parser/BigIntLiteral.ts, which the parselet tier shares.\n        builder.emitOpcode(OpCode.PUSH_BIGINT);\n        builder.emitString(bigIntLiteralDigits(token.value, this.localeCode));\n        return;\n      }\n\n      case PrecedenceParser.STRING_ID: {\n        builder.emitOpcode(OpCode.PUSH_STRING);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Identifiers (variables) ────────────────────────────────────────────\n      case PrecedenceParser.IDENT_ID: {\n        // An identifier immediately followed by \"(\" may be a user-defined\n        // function DEFINITION (`f(x) = ...`) or CALL (`f(5)`). See\n        // parseUserFunctionDefOrCall's doc comment for the full\n        // disambiguation. Only the (cheap) LPAREN check runs for the\n        // overwhelmingly common case of a bare identifier with nothing\n        // following it.\n        if (this.peek()?.typeId === PrecedenceParser.LPAREN_ID) {\n          this.parseUserFunctionDefOrCall(token, builder);\n          return;\n        }\n        // IDENT tokens map to LOAD_VAR by default. The IdentifierParselet\n        // and VariableParselet add STORE_VAR for assignments, those are\n        // handled via the parselet registry below. Note this is also how a\n        // user-defined function's own PARAMETER references compile. See\n        // UserFunctionDef's doc comment in BytecodeBuilder.ts for why there\n        // is no separate parameter-load opcode: `LOAD_VAR` resolution\n        // dynamically checks the VM's innermost call frame first.\n        builder.emitOpcode(OpCode.LOAD_VAR);\n        builder.emitString(token.value);\n        return;\n      }\n\n      // ── Grouping / bare-tuple vector literal ─────────────────────────────────\n      // `(expr)` groups for precedence; `(x, y[, z[, w]])` is the bare-tuple\n      // vector literal documented as an alternative to vec2/vec3/vec4(...)\n      // (wiki: Arithmetic/Vector). This Tier-1 case is what actually runs for\n      // every LPAREN in production parsing, GroupParselet.ts mirrors this\n      // logic for registry-introspection/diagnostic-listing purposes, but a\n      // package can never override LPAREN's dispatch here (Tier 1 always\n      // wins over the ParseletRegistry fallback below), so both must be kept\n      // in sync by hand.\n      case PrecedenceParser.LPAREN_ID: {\n        this.parseExpression(0, builder);\n        let count = 1;\n        while (this.match(TokenTypes.COMMA)) {\n          this.parseExpression(0, builder);\n          count++;\n        }\n        this.consume(TokenTypes.RPAREN);\n        if (count > 1) {\n          // Legacy bare-tuple vector sugar, a 1xN row-vector Matrix (see\n          // packages/vector/parselets/VectorParselet.ts's comment).\n          builder.emitOpcode(OpCode.MAT_NEW);\n          builder.emitIndex(1);\n          builder.emitIndex(count);\n        }\n        return;\n      }\n\n      // ── Unary operators ───────────────────────────────────────────────────\n      case PrecedenceParser.MINUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.NEG);\n        return;\n      }\n\n      case PrecedenceParser.PLUS_ID: {\n        this.parseExpression(BindingPower.Prefix, builder);\n        builder.emitOpcode(OpCode.POS);\n        return;\n      }\n\n      // ── Keyword constants ─────────────────────────────────────────────────\n      case PrecedenceParser.KEYWORD_ID: {\n        // Keywords are handled by parselets (pi→PI, e→E, etc.)\n        // Fall through to registry below.\n      }\n    }\n\n    // ── Tier 2: Plugin/parselet prefix path ──────────────────────────────────\n    const prefixParselet = this.registry.getPrefix(typeId);\n    if (!prefixParselet) {\n      throw ErrorFactory.parsing(\n        \"NO_PREFIX_PARSELET\",\n        `No prefix parselet found for token: ${token.type} (\"${token.value}\")`,\n        { tokenType: token.type, tokenValue: token.value }\n      );\n    }\n\n    prefixParselet.parse(this, token, builder);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // The \"Tier-1 shape-exception\" pattern\n  // ═══════════════════════════════════════════════════════════════════════════════\n  //\n  // Tier 1 exists purely for performance, avoid a Map lookup + parselet call\n  // on ~95% of tokens (see this file's own module doc comment above). A\n  // recurring consequence: any grammar shape tied to a Tier-1 token type can\n  // ONLY be implemented by hand-editing this switch, since a package-\n  // registered ParseletRegistry parselet for that same token type would\n  // simply never run in production (Tier 1 always wins over the registry\n  // fallback). Five confirmed instances of this tension exist in this file\n  // (plus one that had to move OUTSIDE it entirely):\n  //   1. NUMBER_ID, the full locale-aware number-literal parsing (hex/\n  //      binary/octal, chained-dot thousands grouping, decimal-separator\n  //      normalization) is inlined in parsePrefix() above; NumberParselet.ts's\n  //      own copy is dead code for real evaluation, kept registered only for\n  //      the \"matched parselets\" diagnostic view.\n  //   2. IDENT_ID, parseUserFunctionDefOrCall's lookahead (below) disambig-\n  //      uates a function DEFINITION from a CALL from a plain variable load.\n  //   3. LPAREN_ID, the bare-tuple vector-literal sugar (\"(x,y[,z[,w]])\" ->\n  //      MAT_NEW) is inlined in parsePrefix() above; GroupParselet.ts mirrors\n  //      it for introspection only and must be kept in sync by hand.\n  //   4. CARET_ID, the transpose/inverse suffix table just below.\n  //   5. PLUS_ID, the locale word \"and\" lexes as PLUS (Tier-1, fixed Sum\n  //      binding power), so a registry parselet can never intercept it the\n  //      way LogicalParselet.ts intercepts \"or\"/&&/||; unlike the other four,\n  //      there's no SHAPE to special-case on here (the token itself IS the\n  //      operator), so the workaround lives entirely outside this file, as a\n  //      runtime Boolean/Boolean type-check inside vm/VM.ts's OpCode.ADD\n  //      handler instead.\n  //\n  // Deliberate non-goal: none of this is exposed as an IEnginePackage\n  // extension point (unlike prefixParselets/infixParselets). Letting\n  // third-party packages register their own Tier-1 shape-matchers would put\n  // per-package matcher iteration on a genuinely hot path (every CARET/\n  // NUMBER/IDENT/LPAREN/PLUS token, matched or not), a materially bigger\n  // separate product decision than \"make this one table more concise,\" and\n  // not one this pattern write-up makes.\n\n  /**\n   * A single `^`-suffix shape: `matches` peeks ahead (consuming nothing) to\n   * check whether this shape starts at the current position; `emit` is only\n   * called immediately after `matches` returned true for that SAME position,\n   * and is responsible for consuming that shape's own trailing tokens and\n   * emitting its bytecode.\n   */\n  private static readonly CARET_SUFFIX_RULES: ReadonlyArray<{\n    name: string;\n    matches(parser: PrecedenceParser): boolean;\n    emit(parser: PrecedenceParser, builder: BytecodeBuilder): void;\n  }> = [\n    {\n      name: \"transpose (^T)\",\n      matches: (p) => {\n        const next = p.peek();\n        return next?.type === TokenTypes.IDENT && next.value === \"T\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(63); // transpose — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n    {\n      name: \"inverse (^-1)\",\n      matches: (p) => {\n        const next = p.peek();\n        if (next?.typeId !== PrecedenceParser.MINUS_ID) return false;\n        const afterMinus = p.peekAt(1);\n        return afterMinus?.type === TokenTypes.NUMBER && afterMinus.value === \"1\";\n      },\n      emit: (p, builder) => {\n        p.advance();\n        p.advance();\n        builder.emitOpcode(OpCode.CALL_BUILTIN);\n        builder.emitIndex(65); // inv — see VMBuiltins.ts\n        builder.emitIndex(1);\n      },\n    },\n  ];\n\n  /**\n   * After a `^` token (already consumed by the Tier-1 infix loop above),\n   * checks {@link CARET_SUFFIX_RULES} in order for a shape that means\n   * something other than ordinary exponentiation: `^T` (transpose) and `^-1`\n   * (matrix inverse, LITERALLY the integer exponent `-1`; `^-2`, `^-1.5`\n   * etc. still mean ordinary exponentiation). On a match, the rule's `emit`\n   * consumes that shape's own tokens and this returns `true`. On no match,\n   * consumes NOTHING, returning `false` so the caller falls through to\n   * ordinary `EXP` parsing.\n   *\n   * Every rule dispatches purely on SHAPE, never on operand type (unknowable\n   * at parse time): `inv()`'s own handler (`VMBuiltins.ts` index 65) returns\n   * `1/x` for a plain Number, byte-identical to what `Math.pow(x, -1)`\n   * already computed for `x^-1` before this feature existed, and a real\n   * matrix inverse for a Matrix, so `5^-1` still means exactly what it always\n   * has; only a Matrix operand actually inverts.\n   *\n   * Adding a future `^`-suffix shape is a new table entry here, not a new\n   * if-block. See the \"Tier-1 shape-exception\" pattern write-up above for\n   * why this table can't instead be a package-registered parselet.\n   */\n  private tryEmitMatrixCaretOp(builder: BytecodeBuilder): boolean {\n    for (const rule of PrecedenceParser.CARET_SUFFIX_RULES) {\n      if (rule.matches(this)) {\n        rule.emit(this, builder);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // User-defined, parameterized, reusable functions (f(x) = 2*x + 1, then f(5))\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /**\n   * From an LPAREN token index, scan forward tracking paren depth and\n   * return the index of the matching RPAREN, or `null` if the parens never\n   * balance before the token stream ends. No emission, no position\n   * advance. Same class of technique as {@link balanceParens}'s own\n   * pre-scan, just exposed mid-parse instead of only at `load()` time.\n   * `openIdx` must point AT the LPAREN itself.\n   */\n  private findMatchingRParen(openIdx: number): number | null {\n    let depth = 0;\n    for (let i = openIdx; i < this.tokens.length; i++) {\n      const t = this.tokens[i];\n      if (t.typeId === PrecedenceParser.LPAREN_ID) depth++;\n      else if (t.typeId === PrecedenceParser.RPAREN_ID) {\n        depth--;\n        if (depth === 0) return i;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Disambiguates a bare `IDENT` immediately followed by `(` between three\n   * things, using ONLY a bracket-depth scan (no backtracking, nothing is\n   * consumed until the shape is known):\n   * - `f(x) = expr`, a DEFINITION: the matching `)` is followed by `=`.\n   * - `f(5)`, a CALL to a (possibly not-yet-defined) function: anything\n   *   else. This was never valid syntax before this feature (a bare\n   *   `IDENT` immediately before `(` has no pre-existing \"plain variable\n   *   read + separately grouped `(...)`\" meaning to preserve, confirmed\n   *   via `BuiltinNormalizerRules.ts`'s `implicitMultiplyRule()`, which\n   *   only inserts an implicit `*` for `NUMBER/RPAREN` immediately before\n   *   `IDENT/LPAREN`, never for a bare `IDENT` immediately before\n   *   `LPAREN`). Always commits to a CALL; an unregistered name produces a\n   *   clear `UNDEFINED_FUNCTION` error at VM-execution time, the same\n   *   forward-reference philosophy `LOAD_VAR`/`UNDEFINED_VARIABLE` already\n   *   uses, rather than any parse-time registry lookup.\n   * If the parens never balance, this falls through to the ordinary\n   * `LOAD_VAR` path (a malformed expression surfaces its own parse error\n   * shortly after, from the normal expression grammar).\n   */\n  private parseUserFunctionDefOrCall(nameToken: Token, builder: BytecodeBuilder): void {\n    const closeIdx = this.findMatchingRParen(this.current);\n    if (closeIdx === null) {\n      builder.emitOpcode(OpCode.LOAD_VAR);\n      builder.emitString(nameToken.value);\n      return;\n    }\n    const afterClose = this.tokens[closeIdx + 1];\n    if (afterClose?.type === TokenTypes.EQUALS) {\n      this.parseUserFunctionDefinition(nameToken, builder);\n    } else {\n      this.parseUserFunctionCall(nameToken, builder);\n    }\n  }\n\n  /**\n   * A parameter name, accepted as either `IDENT` or `UNIT`, matches this\n   * codebase's established `:name = value` variable-name policy\n   * (`VariableParselet.ts` explicitly accepts `UNIT`-typed tokens too, e.g.\n   * `:b = 5` for the \"b\" bits unit) since common short parameter names\n   * like `h`/`l`/`b`/`t`/`s`/`m` collide with real unit abbreviations\n   * (hour, liter, bits, ton, second, meter, ...) and lex as `UNIT`, not\n   * `IDENT`.\n   */\n  private consumeParamName(): string {\n    const token = this.peek();\n    if (token?.type === TokenTypes.IDENT || token?.type === TokenTypes.UNIT) {\n      this.consume();\n      return token.value;\n    }\n    throw ErrorFactory.parsing(\n      \"USER_FUNCTION_INVALID_PARAM_NAME\",\n      `Expected a parameter name but got \"${token?.type ?? \"end of input\"}\"${token ? ` (\"${token.value}\")` : \"\"}`,\n      { actualType: token?.type },\n    );\n  }\n\n  private parseUserFunctionDefinition(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    const params: string[] = [];\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      params.push(this.consumeParamName());\n      while (this.match(TokenTypes.COMMA)) {\n        params.push(this.consumeParamName());\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n    this.consume(TokenTypes.EQUALS);\n\n    if (params.length === 0) {\n      throw ErrorFactory.parsing(\n        \"USER_FUNCTION_NO_PARAMS\",\n        `\"${nameToken.value}()\" has no parameters -- user-defined functions need at least one (a zero-argument definition is indistinguishable from a plain function CALL with no args, which this grammar doesn't otherwise support)`,\n        { name: nameToken.value },\n      );\n    }\n\n    // Compile the body into its OWN independent BytecodeBuilder, reusing\n    // the SAME parser/token stream but directing emission elsewhere.\n    // `parseExpression(minBp, _builder)` sets `this.builder = _builder`\n    // with NO automatic restore, explicitly restoring via `setBuilder()`\n    // afterward (not a `finally`, since a thrown parse error here should\n    // propagate as-is; there's no further use of `this.builder` on that\n    // path before the whole parse aborts) avoids silently emitting\n    // whatever parses next (in this same expression, or, via\n    // ExpressionEngine's builder pool, a LATER, unrelated line) into a\n    // stale, already-.build()'d body builder.\n    const bodyBuilder = new BytecodeBuilder(this.pluginFunctionIndex);\n    this.parseExpression(BindingPower.Lowest, bodyBuilder);\n    this.setBuilder(builder);\n\n    const bodyProgram = bodyBuilder.build();\n    if (bodyProgram.hasAsync) {\n      // v1 scope decision: a function body calling an async plugin\n      // (weather, stocks, currency, ...) isn't supported yet, propagating\n      // a 'pending' result up through a reentrant executeBytecode() call\n      // would need the OUTER expression's own bytecode position/stack\n      // state to also be resumable later, which this first pass doesn't\n      // implement. Rejecting at DEFINITION time (not call time) gives the\n      // clearest possible error, matching this codebase's \"never silently\n      // pretend to support something it doesn't\" convention (e.g.\n      // addBusinessDays()'s own disclosed holiday-exclusion scope-down).\n      throw ErrorFactory.parsing(\n        \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n        `\"${nameToken.value}(...)\"'s body calls an async operation (weather, stocks, currency, ...) — user-defined function bodies must be synchronous`,\n        { name: nameToken.value },\n      );\n    }\n\n    const bodyIdx = builder.emitUserFunctionBody(nameToken.value, params, bodyProgram);\n    builder.emitOpcode(OpCode.DEFINE_USER_FUNCTION);\n    builder.emitIndex(bodyIdx);\n\n    // A definition line has no single input value to echo back the way an\n    // assignment does, push a plain confirmation string, matching this\n    // codebase's \"never silently produce a misleading numeric 0\" principle.\n    builder.emitOpcode(OpCode.PUSH_STRING);\n    builder.emitString(`${nameToken.value}(${params.join(\", \")}) defined`);\n  }\n\n  private parseUserFunctionCall(nameToken: Token, builder: BytecodeBuilder): void {\n    this.consume(TokenTypes.LPAREN);\n    let argCount = 0;\n    if (this.peek()?.type !== TokenTypes.RPAREN) {\n      this.parseExpression(BindingPower.Lowest, builder);\n      argCount++;\n      while (this.match(TokenTypes.COMMA)) {\n        this.parseExpression(BindingPower.Lowest, builder);\n        argCount++;\n      }\n    }\n    this.consume(TokenTypes.RPAREN);\n\n    builder.emitOpcode(OpCode.CALL_USER_FUNCTION);\n    builder.emitString(nameToken.value);\n    builder.emitByte(argCount);\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Token stream navigation (identical API to Parser)\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  consume(expectedType?: string): Token {\n    const token = this.tokens[this.current];\n    if (!token) {\n      throw ErrorFactory.parsing(\n        \"UNEXPECTED_END_OF_INPUT\",\n        \"Unexpected end of input\"\n      );\n    }\n    if (expectedType !== undefined) {\n      const expectedId = tokenTypeId(expectedType);\n      if (token.typeId !== expectedId) {\n        throw ErrorFactory.parsing(\n          \"UNEXPECTED_TOKEN_TYPE\",\n          `Expected token type \"${expectedType}\" but got \"${token.type}\" (\"${token.value}\")`,\n          { expectedType, actualType: token.type, actualValue: token.value }\n        );\n      }\n    }\n    this.current++;\n    return token;\n  }\n\n  match(expectedType: string): boolean {\n    const token = this.peek();\n    if (token && token.typeId === tokenTypeId(expectedType)) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  peek(): Token | undefined {\n    return this.tokens[this.current];\n  }\n\n  /**\n   * Read-only lookahead `offset` tokens past the current position, without\n   * consuming anything, `peekAt(0)` is equivalent to {@link peek}.\n   * `this.tokens` is a plain in-memory array (not a stream), so this is a\n   * simple, safe index read; no rewind/checkpoint mechanism is needed since\n   * nothing is consumed.\n   */\n  peekAt(offset: number): Token | undefined {\n    return this.tokens[this.current + offset];\n  }\n\n  previous(): Token | undefined {\n    return this.current > 0 ? this.tokens[this.current - 1] : undefined;\n  }\n\n  private advance(): void {\n    this.current++;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Builder access, set before parse, read by inline prefix handlers\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  /** Set the builder to use for the current parse. Called by ExpressionEngine. */\n  setBuilder(builder: BytecodeBuilder): void {\n    this.builder = builder;\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════════\n  // Diagnostics\n  // ═══════════════════════════════════════════════════════════════════════════════\n\n  private fireParseletMatched(\n    parselet: { category: string },\n    token: Token,\n    isPrefix: boolean,\n    bindingPower?: number\n  ): void {\n    const pipeline = this.diagnosticPipeline!;\n    const event: DiagnosticEvent & { type: \"parselet_matched\" } = {\n      type: DiagnosticEventType.ParseletMatched,\n      elapsedNs: 0,\n      expression: this.currentExpression,\n      tokenType: token.type,\n      tokenValue: token.value,\n      parseletCategory: parselet.category,\n      parseletType: parselet.constructor?.name ?? \"unknown\",\n      isPrefix,\n      bindingPower,\n      tokenOffset: token.offset || 0,\n    };\n    pipeline.fireParseletMatched(event);\n  }\n}\n","import { PrefixParselet, InfixParselet } from \"@solve-js/parser/Parselet\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\nimport { BindingPower } from \"@solve-js/parser/BindingPower\";\n\n/**\n * The one binding-power field a parselet may expose beyond what its interface\n * requires, read only for diagnostic display.\n *\n * `InfixParselet` requires `bindingPower`; `PrefixParselet` declares none, and\n * some prefix parselets carry one anyway. That single field is the whole\n * optional surface deliberately. A `leftBindingPower`/`rightBindingPower` pair\n * used to be read here as well, and reading a name off an object this way finds\n * PRIVATE fields too, since TypeScript's `private` exists only at compile time:\n * `BinaryOpParselet` holds a private `rightBindingPower` meaning \"the minimum\n * power to parse my right operand at\", which is a different quantity from \"the\n * power at which I bind to my right\" and differs from it by one. Reading it\n * silently reported that other number. So neither is read.\n *\n * `category` is not here: both interfaces already declare it.\n */\ninterface ParseletBindingPowers {\n\treadonly bindingPower?: number;\n}\n\n/** Reads the optional binding-power field off a parselet for diagnostics. */\nfunction bindingPowersOf(parselet: PrefixParselet | InfixParselet): ParseletBindingPowers {\n\treturn parselet as ParseletBindingPowers;\n}\n\n/**\n * Dual-keyed ParseletRegistry, accepts both string token types and\n * integer token type IDs for fast dispatch in the Parser hot path.\n *\n * Providers call registerPrefix(\"NUMBER\", ...) with string token types.\n * Internally, we populate both string-keyed and integer-keyed maps so\n * Parser.parseExpression() can use token.typeId (integer) for lookup\n * while diagnostics and error messages use token.type (string).\n *\n * Performance: Integer Map.get() avoids string hashing, saving ~2-5ns\n * per dispatch. With ~10-15 dispatches per expression, that's ~20-75ns.\n */\nexport class ParseletRegistry {\n\t// String-keyed maps (kept for diagnostics + backwards compat)\n\tprivate prefixParselets: Map<string, PrefixParselet> = new Map();\n\tprivate infixParselets: Map<string, InfixParselet> = new Map();\n\n\t// Integer-keyed maps for parser hot path\n\tprivate prefixById: Map<number, PrefixParselet> = new Map();\n\tprivate infixById: Map<number, InfixParselet> = new Map();\n\n\t/**\n\t * Register a prefix parselet for `tokenType`.\n\t *\n\t * If another parselet is already registered for this token type, it is\n\t * silently overwritten by default (`Map.set()` semantics), the old\n\t * parselet is simply unreachable from then on, with no error. This is\n\t * a real footgun for third-party packages: two packages independently\n\t * choosing the same custom token type will collide with zero signal\n\t * about which one \"won\". Mirrors ResolverRegistry.register()'s and\n\t * ExpressionEngine.registerPackage()'s existing \"warn and replace\"\n\t * pattern for the same class of problem at the resolver-namespace and\n\t * package-name levels.\n\t *\n\t * Note: this warns about registry-level collisions only. It does NOT\n\t * detect the separate case where `tokenType` is one of PrecedenceParser's\n\t * Tier-1 fast-path token types (NUMBER, STRING, IDENT, LPAREN, MINUS,\n\t * PLUS, and the Tier-1 infix operators), those are deliberately kept\n\t * registered here for introspection/diagnostics even though Tier-1\n\t * always intercepts them before this registry is consulted (see\n\t * PrecedenceParser.parsePrefix()'s docs), so warning there would\n\t * misfire on that intentional, already-documented pattern.\n\t */\n\tregisterPrefix(tokenType: string, parselet: PrefixParselet): void {\n\t\tconst existing = this.prefixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Prefix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.prefixParselets.set(tokenType, parselet);\n\t\tthis.prefixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/** Register an infix parselet for `tokenType`. See {@link registerPrefix} for the collision-warning behavior this mirrors. */\n\tregisterInfix(tokenType: string, parselet: InfixParselet): void {\n\t\tconst existing = this.infixParselets.get(tokenType);\n\t\tif (existing && existing !== parselet) {\n\t\t\tconsole.warn(\n\t\t\t\t`[ParseletRegistry] Infix parselet for token \"${tokenType}\" is already registered ` +\n\t\t\t\t`(category: \"${existing.category ?? \"unknown\"}\"). Overwriting with a new ` +\n\t\t\t\t`parselet (category: \"${parselet.category ?? \"unknown\"}\") — the previous ` +\n\t\t\t\t`parselet is now unreachable. Two packages may be claiming the same token type.`,\n\t\t\t);\n\t\t}\n\t\tthis.infixParselets.set(tokenType, parselet);\n\t\tthis.infixById.set(tokenTypeId(tokenType), parselet);\n\t}\n\n\t/**\n\t * Iterate all registered prefix parselets for diagnostic display.\n\t *\n\t * `PrefixParselet` declares no binding power, and this used to read a field\n\t * of that name and report 0 for every one of them. 0 is not a neutral\n\t * wrong answer: it is the value that means \"not an operator, stop the\n\t * expression\", so a host drawing a table from this was told none of them\n\t * bind at all. A prefix parselet in this parser has no per-parselet power\n\t * to report, they all bind at the prefix level and each chooses for itself\n\t * at what power to parse its own operand, so that level is what is\n\t * reported. A parselet that does carry its own `bindingPower` still wins.\n\t */\n\tgetAllPrefix(): Array<{ tokenType: string; bindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; bindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.prefixParselets) {\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tbindingPower: bindingPowersOf(parselet).bindingPower ?? BindingPower.Prefix,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Iterate all registered infix parselets for diagnostic display.\n\t *\n\t * The field an `InfixParselet` actually declares is `bindingPower`. This\n\t * used to read `leftBindingPower` and `rightBindingPower`, which no\n\t * parselet in this codebase declares, so both reads were `undefined`, both\n\t * fell to the `?? 0` default, and the public `getParseletRegistry()`\n\t * reported a binding power of 0 for every one of the ~60 infix operators.\n\t * A host building a precedence table from it was told `*` and `+` bind\n\t * equally, and that neither binds at all.\n\t *\n\t * The left/right split: `bindingPower` is the LEFT power, and the right is\n\t * one higher. That is the standard encoding for a left-associative\n\t * operator, and it is what the parser itself does, see\n\t * `PrecedenceParser.parseExpression()`'s `bp + 1` for the right operand.\n\t * Every operator is reported that way, `^` included. Associativity is not\n\t * something a parselet declares, it is a property of how each one calls\n\t * `parseExpression`, so this API cannot report it without a new field on\n\t * the interface. See {@link ParseletBindingPowers} for why scraping a\n\t * plausible-looking one off the parselet is worse than not reporting it.\n\t */\n\tgetAllInfix(): Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> {\n\t\tconst result: Array<{ tokenType: string; leftBindingPower: number; rightBindingPower: number; category?: string }> = [];\n\t\tfor (const [tokenType, parselet] of this.infixParselets) {\n\t\t\tconst left = bindingPowersOf(parselet).bindingPower ?? 0;\n\t\t\tresult.push({\n\t\t\t\ttokenType,\n\t\t\t\tleftBindingPower: left,\n\t\t\t\trightBindingPower: left + 1,\n\t\t\t\tcategory: parselet.category,\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t}\n\n\t/** Number of registered prefix parselets. */\n\tget prefixCount(): number { return this.prefixParselets.size; }\n\n\t/** Number of registered infix parselets. */\n\tget infixCount(): number { return this.infixParselets.size; }\n\n\t/**\n\t * Get prefix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings\n\t * (diagnostics, error messages, backwards compatibility).\n\t */\n\tgetPrefix(tokenType: string | number): PrefixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.prefixById.get(tokenType);\n\t\treturn this.prefixParselets.get(tokenType);\n\t}\n\n\t/**\n\t * Get infix parselet by string token type OR integer typeId.\n\t * Fast path for integer IDs (Parser hot path), fallback for strings.\n\t */\n\tgetInfix(tokenType: string | number): InfixParselet | undefined {\n\t\tif (typeof tokenType === 'number') return this.infixById.get(tokenType);\n\t\treturn this.infixParselets.get(tokenType);\n\t}\n\n\thasPrefix(tokenType: string): boolean {\n\t\treturn this.prefixParselets.has(tokenType);\n\t}\n\n\thasInfix(tokenType: string): boolean {\n\t\treturn this.infixParselets.has(tokenType);\n\t}\n\n\tclear(): void {\n\t\tthis.prefixParselets.clear();\n\t\tthis.infixParselets.clear();\n\t\tthis.prefixById.clear();\n\t\tthis.infixById.clear();\n\t}\n}\n\n/**\n * A process-wide parselet registry.\n *\n * @deprecated An engine builds its own registry and does not read this one, so\n * registering here reaches nothing that evaluates. Nothing writes to it now\n * that the global package-registration path is gone; it remains only so the\n * `@solve-js/parser` escape hatch keeps a stable shape.\n */\nexport const sharedParseletRegistry = new ParseletRegistry();\n"]}

package/dist/chunk-KRXO3MOW.cjs

@@ -1,2 +0,0 @@
-'use strict';var chunkY7O4D3BJ_cjs=require('./chunk-Y7O4D3BJ.cjs'),chunkUSQ4KL6S_cjs=require('./chunk-USQ4KL6S.cjs'),chunkS3DFU33X_cjs=require('./chunk-S3DFU33X.cjs'),chunkJ4LSAHCY_cjs=require('./chunk-J4LSAHCY.cjs');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 chunkUSQ4KL6S_cjs.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:chunkY7O4D3BJ_cjs.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="en"){let e=chunkS3DFU33X_cjs.a(a),t=new n;return t.setLocale(e.keywordMap,k),t.setUnits(chunkJ4LSAHCY_cjs.a),t.build()}exports.a=u;exports.b=l;exports.c=T;exports.d=P;//# sourceMappingURL=chunk-KRXO3MOW.cjs.map
-//# sourceMappingURL=chunk-KRXO3MOW.cjs.map

package/dist/chunk-KRXO3MOW.cjs.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-KRXO3MOW.cjs","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"]}