solve-engine 2.5.0 → 2.7.0

package/dist/{chunk-FDE5HWDI.cjs.map → chunk-FNNIAJNY.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/parser/PrecedenceParser.ts","../src/parser/registry/ParseletRegistry.ts"],"names":["CHAINED_DOT_THOUSANDS_GROUPS","PLAIN_DECIMAL","_PrecedenceParser","parseletRegistry","maxDepth","localeCode","pluginFunctionIndex","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","locale","getLocale","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-FDE5HWDI.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  /**\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    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        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 locale = getLocale(this.localeCode);\n          const decimalSep = locale.display.decimalSeparator;\n          const thousandsSep = locale.display.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation)\n          if (thousandsSep) {\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"]}
+{"version":3,"sources":["../src/parser/PrecedenceParser.ts","../src/parser/registry/ParseletRegistry.ts"],"names":["CHAINED_DOT_THOUSANDS_GROUPS","PLAIN_DECIMAL","_PrecedenceParser","parseletRegistry","maxDepth","localeCode","pluginFunctionIndex","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","locale","getLocale","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-FNNIAJNY.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  /**\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    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        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 locale = getLocale(this.localeCode);\n          const decimalSep = locale.display.decimalSeparator;\n          const thousandsSep = locale.display.thousandsSeparator;\n          let normalized = raw;\n          // Replace thousands separator with empty string (split+join avoids per-call RegExp compilation)\n          if (thousandsSep) {\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-FUDVKPB7.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunk4BZIYU7S_cjs=require('./chunk-4BZIYU7S.cjs'),chunkPNDQRCRQ_cjs=require('./chunk-PNDQRCRQ.cjs');var u=[10,11,12,13,14,16,60,61,62,63,150,159,95,96],E=[50,51,151,152,160],m=[157,158],L=(()=>{let r=new Array(256).fill(0);for(let e of u)r[e]=1;for(let e of E)r[e]=2;for(let e of m)r[e]=3;return r})();[...u,...E,...m];function C(r,e){return e+1+(L[r[e]]??0)}var R="currency",A=class{constructor(e){this.namespace=R;this.exchange=e??chunk4BZIYU7S_cjs.b;}preflight(e,N,U,S,y){let{opcodes:c,strings:l}=N,f=c.length,o=0,i=-1,p=-1;for(;o<f;){let t=c[o];if(t===13&&(p=i,i=c[o+1]),(t===84||t===81||t===20||t===21||t===22||t===23)&&p>=0&&i>=0){let n=l[p],s=l[i];if(this.exchange.isCurrency(n)&&this.exchange.isCurrency(s)&&n.toUpperCase()!==s.toUpperCase()&&this.exchange.getRateSync(n,s)===null){let d=n.toUpperCase(),I=s.toUpperCase(),a=[R,d,I];if(y.getQueryData(a)!==void 0){o++;continue}let g=y.fetchQuery({queryKey:a,queryFn:({signal:h})=>this.exchange.getRate(n,s,h).then(T=>chunkPNDQRCRQ_cjs.n(T)),staleTime:300*1e3});return {queryKey:a.join(":"),resolver:g,packageId:U,signal:S,metadata:{fromUnit:n,toUnit:s}}}}o=C(c,o);}return null}destroy(){}};exports.a=C;exports.b=A;//# sourceMappingURL=chunk-FUDVKPB7.cjs.map
+//# sourceMappingURL=chunk-FUDVKPB7.cjs.map

package/dist/chunk-FUDVKPB7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser/OperandWidth.ts","../src/uom/CurrencyResolver.ts"],"names":["ONE_OPERAND","TWO_OPERANDS","THREE_OPERANDS","OPERAND_BYTES","widths","op","nextInstruction","opcodes","index","CURRENCY_NS","CurrencyAsyncResolver","exchange","currencyExchangeService","_tokens","bytecode","packageId","signal","queryClient","strings","len","i","lastStrIdx","prevStrIdx","fromUnit","toUnit","fromUpper","toUpper","cacheKey","resolver","qSignal","rate","numberValue"],"mappings":"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","file":"chunk-FUDVKPB7.cjs","sourcesContent":["/**\n * How many operand bytes follow each opcode, and how to step over one.\n *\n * Anything walking a bytecode stream without executing it needs this: the\n * resolver preflight scanners look for specific opcodes and must skip past\n * everything else without mistaking an operand byte for an instruction.\n *\n * It used to be a hand-copied switch in each of those scanners. They had\n * already drifted: two counted `CALL_PLUGIN` as three bytes wide and the third\n * omitted it from that arm, so a stream containing one desynchronised there and\n * every opcode after it was read at the wrong offset. Adding an opcode meant\n * remembering every copy, and nothing checked that you had.\n *\n * `__tests__/parser/OperandWidth.spec.ts` asserts every opcode has a width, so\n * a new one fails a test rather than silently defaulting to zero operands.\n */\n\nimport { OpCode } from \"@solve-js/parser/OpCode\";\n\n/**\n * Opcodes taking one operand byte.\n *\n * A constant-pool index, or a variable-name index.\n */\nconst ONE_OPERAND: readonly OpCode[] = [\n\tOpCode.PUSH_NUMBER,\n\tOpCode.PUSH_BIGINT,\n\tOpCode.PUSH_HEX,\n\tOpCode.PUSH_STRING,\n\tOpCode.PUSH_BOOLEAN,\n\t// Its operand is a string-pool index holding the exact decimal text, so a\n\t// scanner must step over one byte exactly as it does for PUSH_STRING.\n\tOpCode.PUSH_DECIMAL,\n\tOpCode.LOAD_VAR,\n\tOpCode.STORE_VAR,\n\tOpCode.LOAD_GLOBAL_VAR,\n\tOpCode.STORE_GLOBAL_VAR,\n\tOpCode.DEFINE_USER_FUNCTION,\n\tOpCode.BIND_UNKNOWN,\n\t// Its operand is a constant-pool index, like PUSH_NUMBER's: the epoch-ms\n\t// was resolved at parse time and stored in `numbers`. Omitting it made\n\t// every scanner read that index byte as an opcode, so an ordinary date\n\t// literal desynchronised the whole preflight walk.\n\tOpCode.DATE_LITERAL,\n\t// One byte, the offset direction (0 forward, 1 backward) for \"N working\n\t// days after/before/from <date>\". See WorkdayOffsetParselet. DATE_WORKDAYS_BETWEEN\n\t// takes no operand and so is not listed here.\n\tOpCode.DATE_WORKDAY_OFFSET,\n];\n\n/**\n * Opcodes taking two operand bytes.\n *\n * A callable index plus an argument count, or a matrix's row and column counts.\n */\nconst TWO_OPERANDS: readonly OpCode[] = [\n\tOpCode.CALL_PLUGIN,\n\tOpCode.CALL_BUILTIN,\n\tOpCode.CALL_USER_FUNCTION,\n\tOpCode.MAT_NEW,\n\t// A body index plus the pooled source-expression string.\n\tOpCode.PLOT_INVOKE,\n];\n\n/**\n * Opcodes taking three operand bytes.\n *\n * The map and reduce invocations, which carry a body index alongside their\n * other operands.\n */\nconst THREE_OPERANDS: readonly OpCode[] = [OpCode.MAP_INVOKE, OpCode.REDUCE_INVOKE];\n\n/**\n * Operand byte count for every opcode, indexed by opcode value.\n *\n * A dense array rather than a map, because the preflight scanners run on every\n * keystroke and this is read once per instruction.\n */\nexport const OPERAND_BYTES: readonly number[] = (() => {\n\tconst widths = new Array<number>(256).fill(0);\n\tfor (const op of ONE_OPERAND) widths[op] = 1;\n\tfor (const op of TWO_OPERANDS) widths[op] = 2;\n\tfor (const op of THREE_OPERANDS) widths[op] = 3;\n\treturn widths;\n})();\n\n/**\n * Every opcode that takes at least one operand.\n *\n * Exported so a test can assert the table stays complete as opcodes are added.\n */\nexport const OPCODES_WITH_OPERANDS: readonly OpCode[] = [\n\t...ONE_OPERAND,\n\t...TWO_OPERANDS,\n\t...THREE_OPERANDS,\n];\n\n/**\n * Offset of the instruction after the one at `index`.\n *\n * @param opcodes - The bytecode stream.\n * @param index - Offset of an opcode, not of an operand byte. Passing an\n * operand offset yields nonsense, which is the failure mode this exists to\n * prevent: a caller stepping by hand and getting one width wrong reads the rest\n * of the stream misaligned.\n * @returns Offset of the next opcode. May be past the end when the instruction\n * at `index` is the last one, so callers loop while it is under `opcodes.length`.\n */\nexport function nextInstruction(opcodes: Uint8Array, index: number): number {\n\treturn index + 1 + (OPERAND_BYTES[opcodes[index]] ?? 0);\n}\n","/**\n * Currency async resolver, bridges CurrencyExchangeService to the\n * IAsyncResolver interface for the Suspense architecture.\n *\n * Uses TanStack Query (injected via queryClient) as the single cache layer.\n */\nimport type { QueryClient } from \"@tanstack/query-core\";\nimport type { Token } from \"@solve-js/lexer\";\nimport type { BytecodeProgram } from \"@solve-js/parser/BytecodeBuilder\";\nimport { OpCode } from \"@solve-js/parser/OpCode\";\nimport { numberValue } from \"@solve-js/vm/Value\";\nimport {\n\tcurrencyExchangeService,\n\tCurrencyExchangeService,\n} from \"@solve-js/uom/CurrencyExchange\";\nimport type { IAsyncResolver, AsyncCheckResult } from \"@solve-js/resolvers/ResolverRegistry\";\nimport { nextInstruction } from \"@solve-js/parser/OperandWidth\";\n\nconst CURRENCY_NS = \"currency\";\n\n/**\n * Fetches exchange rates before the VM runs, so a conversion has real numbers.\n *\n * Until rates arrive the line evaluates to a pending value rather than a\n * guessed one, and re-evaluates when they land.\n */\nexport class CurrencyAsyncResolver implements IAsyncResolver {\n\treadonly namespace = CURRENCY_NS;\n\n\tprivate exchange: CurrencyExchangeService;\n\n\tconstructor(exchange?: CurrencyExchangeService) {\n\t\tthis.exchange = exchange ?? currencyExchangeService;\n\t}\n\n\tpreflight(_tokens: Token[], bytecode: BytecodeProgram, packageId: string, signal: AbortSignal, queryClient: QueryClient): AsyncCheckResult | null {\n\t\tconst { opcodes, strings } = bytecode;\n\t\tconst len = opcodes.length;\n\t\tlet i = 0;\n\n\t\tlet lastStrIdx = -1;\n\t\tlet prevStrIdx = -1;\n\n\t\twhile (i < len) {\n\t\t\tconst op = opcodes[i] as OpCode;\n\n\t\t\tif (op === OpCode.PUSH_STRING) {\n\t\t\t\tprevStrIdx = lastStrIdx;\n\t\t\t\tlastStrIdx = opcodes[i + 1];\n\t\t\t}\n\n\t\t\t// Explicit \"X to Y\"/\"X in Y\" conversions (UOM_CONVERT_IN/_TO) are\n\t\t\t// the obvious case, but arithmetic directly on two differently-\n\t\t\t// denominated currency literals, \"0.01 BTC + 1 ETH\", needs the\n\t\t\t// exact same preflight fetch and previously never got it: this\n\t\t\t// scanner only looked for the CONVERT opcodes, so ADD/SUB/MUL/DIV\n\t\t\t// between two currency UOMs skipped preflight entirely, ran with\n\t\t\t// no cached rate, and fell through to the VM's silent-wrong-math\n\t\t\t// fallback instead of ever reaching a network fetch.\n\t\t\tconst isCurrencyCombiningOp =\n\t\t\t\top === OpCode.UOM_CONVERT_IN || op === OpCode.UOM_CONVERT_TO ||\n\t\t\t\top === OpCode.ADD || op === OpCode.SUB || op === OpCode.MUL || op === OpCode.DIV;\n\t\t\tif (isCurrencyCombiningOp) {\n\t\t\t\tif (prevStrIdx >= 0 && lastStrIdx >= 0) {\n\t\t\t\t\tconst fromUnit = strings[prevStrIdx];\n\t\t\t\t\tconst toUnit = strings[lastStrIdx];\n\n\t\t\t\t\tif (\n\t\t\t\t\t\tthis.exchange.isCurrency(fromUnit) &&\n\t\t\t\t\t\tthis.exchange.isCurrency(toUnit) &&\n\t\t\t\t\t\tfromUnit.toUpperCase() !== toUnit.toUpperCase()\n\t\t\t\t\t) {\n\t\t\t\t\t\tconst syncRate = this.exchange.getRateSync(fromUnit, toUnit);\n\t\t\t\t\t\tif (syncRate === null) {\n\t\t\t\t\t\t\tconst fromUpper = fromUnit.toUpperCase();\n\t\t\t\t\t\t\tconst toUpper = toUnit.toUpperCase();\n\n\t\t\t\t\t\t\t// Check TanStack Query cache\n\t\t\t\t\t\t\tconst cacheKey = [CURRENCY_NS, fromUpper, toUpper];\n\t\t\t\t\t\t\tif (queryClient.getQueryData(cacheKey) !== undefined) {\n\t\t\t\t\t\t\t\ti++;\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// Fetch via TanStack Query (dedup + retry automatic)\n\t\t\t\t\t\t\tconst resolver = queryClient.fetchQuery({\n\t\t\t\t\t\t\t\tqueryKey: cacheKey,\n\t\t\t\t\t\t\t\tqueryFn: ({ signal: qSignal }) => {\n\t\t\t\t\t\t\t\t\treturn this.exchange.getRate(fromUnit, toUnit, qSignal).then((rate) => numberValue(rate));\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tstaleTime: 5 * 60 * 1000,\n\t\t\t\t\t\t\t});\n\n\t\t\t\t\t\t\treturn { queryKey: cacheKey.join(\":\"), resolver, packageId, signal, metadata: { fromUnit, toUnit } };\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Step over this instruction and its operands. Shared table, because\n\t\t\t// three hand-copied versions of this had already drifted.\n\t\t\ti = nextInstruction(opcodes, i);\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tdestroy(): void {\n\t\t// Cache cleared by ResolverRegistry.unregister() via removeQueries({ queryKey: [\"currency\"] })\n\t}\n}\n"]}