solve-engine 1.2.0 → 2.0.0

package/dist/chunk-MI7OTUHL.cjs

@@ -1,339 +0,0 @@
-'use strict';
-
-var chunkG2YPPLGX_cjs = require('./chunk-G2YPPLGX.cjs');
-var chunkOUHT5Z36_cjs = require('./chunk-OUHT5Z36.cjs');
-var chunkMIGXCBXT_cjs = require('./chunk-MIGXCBXT.cjs');
-
-// src/parser/BindingPower.ts
-var BindingPower = {
-  Lowest: 0,
-  Assignment: 10,
-  LogicalOr: 12,
-  // `or`, `||` — loosest of the boolean-logic operators
-  LogicalAnd: 14,
-  // `&&` — binds tighter than `or` ("a or b and c" = "a or (b and c)")
-  // The word "and" (`AND_CONJ`), which is both arithmetic addition ("5 and 3"
-  // is 8) and boolean conjunction ("true and false"). A phrase parselet
-  // collecting a list ("average of X, Y and Z") parses each argument at this
-  // level, and an argument stops at any operator whose power is <= the level it
-  // was parsed at, so putting "and" here is what makes it end an argument
-  // rather than be consumed as the addition it also is. Everything an argument
-  // should keep binds tighter, including a genuine "+" (`Sum`).
-  //
-  // It sits BELOW `Conditional` because the boolean reading needs comparisons
-  // to be its operands: at 28, "5 > 3 and 2 > 1" parsed as "5 > (3 and 2) > 1"
-  // and answered false. Above `LogicalAnd` so that "and" is still the tighter
-  // of the two conjunctions, and two steps off each neighbour to leave room.
-  Conjunction: 16,
-  // The bitwise trio and the shifts, ordered exactly as C and JavaScript order
-  // them, which is the order every language that borrowed these operators from
-  // C uses: `|` looser than `xor`, `xor` looser than `&`, all three looser than
-  // comparison, and the shifts tighter than comparison but looser than `+`.
-  // They used to share one level (35) between `Sum` and `Product`, so
-  // "1 + 2 << 3" answered 17 where JavaScript answers 24 and "4 & 3 + 1"
-  // answered 1 where JavaScript answers 4. Each has its own level now because
-  // a shared level makes "4 | 6 & 3" group left instead of letting `&` win.
-  //
-  // They stay TIGHTER than `Conjunction` so that a phrase argument parsed at
-  // that level ("average of 5 | 3, 2 and 4") keeps its bitwise operators
-  // instead of stopping at the first one.
-  BitwiseOr: 18,
-  // `|`
-  BitwiseXor: 20,
-  // the `xor` keyword (`BIT_XOR`), not the `^` exponent token
-  BitwiseAnd: 22,
-  // `&`
-  Conditional: 24,
-  // comparisons (`==`, `<`, `>=`, ...), tighter than the bitwise trio, looser than the shifts
-  Shift: 27,
-  // `<<`, `>>`, `>>>`
-  Sum: 30,
-  Product: 40,
-  // `±` (the uncertainty operator), tighter than `+ - * /` and looser than `^`,
-  // so the tolerance attaches to its adjacent values: `12.3 ± 0.5 * 4` reads as
-  // `(12.3 ± 0.5) * 4` (the parenthesised headline case), and `2 + 3 ± 0.5` as
-  // `2 + (3 ± 0.5)`. A Tier-2 parselet (packages/uncertainty/), so this level is
-  // read off the parselet rather than the Tier-1 BUILTIN_INFIX_BP table below.
-  Uncertainty: 45,
-  // `^`, RIGHT-associative: "2 ^ 3 ^ 2" is 2^(3^2) = 512, as in mathematics,
-  // Python, Ruby and JavaScript's `**`. See PrecedenceParser.parseExpression
-  // and BinaryOpParselet for the two places that associativity is implemented.
-  Exponent: 50,
-  Prefix: 60,
-  Postfix: 70,
-  Call: 80
-};
-var BUILTIN_INFIX_BP = {
-  // Arithmetic (infix, left-associative)
-  [chunkG2YPPLGX_cjs.TokenTypes.PLUS]: BindingPower.Sum,
-  [chunkG2YPPLGX_cjs.TokenTypes.MINUS]: BindingPower.Sum,
-  [chunkG2YPPLGX_cjs.TokenTypes.STAR]: BindingPower.Product,
-  [chunkG2YPPLGX_cjs.TokenTypes.SLASH]: BindingPower.Product,
-  [chunkG2YPPLGX_cjs.TokenTypes.MOD]: BindingPower.Product,
-  // Arithmetic (infix, RIGHT-associative, PrecedenceParser handles this specially)
-  [chunkG2YPPLGX_cjs.TokenTypes.CARET]: BindingPower.Exponent,
-  // Bitwise and shift (infix, left-associative), one level each, ordered as C
-  // and JavaScript order them. `>>>` used to be missing from this table
-  // entirely, which left it running at its Tier 2 parselet level while `>>`
-  // ran at the Tier 1 one, so "16 >> 3 & 1" and "16 >>> 3 & 1" grouped
-  // differently and answered 0 and 8.
-  [chunkG2YPPLGX_cjs.TokenTypes.BIT_OR]: BindingPower.BitwiseOr,
-  [chunkG2YPPLGX_cjs.TokenTypes.BIT_XOR]: BindingPower.BitwiseXor,
-  [chunkG2YPPLGX_cjs.TokenTypes.BIT_AND]: BindingPower.BitwiseAnd,
-  [chunkG2YPPLGX_cjs.TokenTypes.LSHIFT]: BindingPower.Shift,
-  [chunkG2YPPLGX_cjs.TokenTypes.RSHIFT]: BindingPower.Shift,
-  [chunkG2YPPLGX_cjs.TokenTypes.URSHIFT]: BindingPower.Shift,
-  // Postfix (no right operand, PrecedenceParser handles this specially)
-  [chunkG2YPPLGX_cjs.TokenTypes.PERCENT]: BindingPower.Postfix,
-  // Percentage keyword (infix, left-associative: "50% of 200" → MUL)
-  [chunkG2YPPLGX_cjs.TokenTypes.OF]: BindingPower.Product
-};
-var _bpTable = null;
-function buildBindingPowerTable() {
-  if (_bpTable) return _bpTable;
-  let maxId = 0;
-  for (const name of Object.keys(BUILTIN_INFIX_BP)) {
-    const id = chunkG2YPPLGX_cjs.tokenTypeId(name);
-    if (id > maxId) maxId = id;
-  }
-  for (const name of Object.values(chunkG2YPPLGX_cjs.TokenTypes)) {
-    const id = chunkG2YPPLGX_cjs.tokenTypeId(name);
-    if (id > maxId) maxId = id;
-  }
-  const table = new Uint8Array(maxId + 1);
-  for (const [name, bp] of Object.entries(BUILTIN_INFIX_BP)) {
-    const id = chunkG2YPPLGX_cjs.tokenTypeId(name);
-    table[id] = bp;
-  }
-  _bpTable = table;
-  return table;
-}
-function invalidateBindingPowerTable() {
-  _bpTable = null;
-}
-
-// src/parser/BytecodeBuilder.ts
-var MAX_CONSTANT_POOL_INDEX = 255;
-var BytecodeBuilder = class {
-  constructor() {
-    this.opcodes = [];
-    this.numbers = [];
-    this.strings = [];
-    this.stringIndex = /* @__PURE__ */ new Map();
-    this._hasAsync = false;
-    this.userFunctionBodies = [];
-    this.anonymousBodies = [];
-  }
-  /** Emit an {@link OpCode} instruction. */
-  emitOpcode(op) {
-    this.opcodes.push(op);
-    if (op === 50 /* CALL_PLUGIN */) {
-      this._hasAsync = true;
-    }
-  }
-  /**
-   * Emit a numeric literal: appends `n` to the program's constant pool and
-   * writes its index into the opcode stream (read back by the VM as e.g.
-   * `PUSH_NUMBER <idx>`).
-   *
-   * Numeric constants are NOT deduplicated (unlike {@link emitString})
-   * every call appends a new entry, so an expression with more than
-   * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences
-   * throws rather than silently wrapping the index (see
-   * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).
-   *
-   * @throws If the constant pool would exceed 256 entries.
-   */
-  emitNumber(n) {
-    const idx = this.numbers.length;
-    if (idx > MAX_CONSTANT_POOL_INDEX) {
-      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
-        "TOO_MANY_NUMERIC_CONSTANTS",
-        `Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} numeric literals, exceeding the bytecode constant pool's limit.`,
-        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
-      );
-    }
-    this.numbers.push(n);
-    this.opcodes.push(idx);
-  }
-  /**
-   * Emit a string literal: interns `s` into the program's string pool
-   * (deduplicated via `stringIndex`) and writes its index into the opcode
-   * stream. Subject to the same constant-pool bound as {@link emitNumber},
-   * but since strings ARE deduplicated, only distinct string values count
-   * against the limit.
-   *
-   * @throws If the string pool would exceed 256 distinct entries.
-   */
-  emitString(s) {
-    let idx = this.stringIndex.get(s);
-    if (idx === void 0) {
-      idx = this.strings.length;
-      if (idx > MAX_CONSTANT_POOL_INDEX) {
-        throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
-          "TOO_MANY_STRING_CONSTANTS",
-          `Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} distinct string literals, exceeding the bytecode constant pool's limit.`,
-          { limit: MAX_CONSTANT_POOL_INDEX + 1 }
-        );
-      }
-      this.strings.push(s);
-      this.stringIndex.set(s, idx);
-    }
-    this.opcodes.push(idx);
-  }
-  /**
-   * Emit a raw numeric operand (0-255) following an opcode, e.g. a
-   * plugin-function index for `CALL_PLUGIN`, or an argument count. Unlike
-   * {@link emitOpcode}, this does not go through the `OpCode` enum, so
-   * package authors use this (not an unsafe cast to `OpCode`) to push
-   * operands their own opcode handler expects to read positionally.
-   */
-  emitIndex(idx) {
-    this.opcodes.push(idx);
-  }
-  /** Emit a raw byte (0-255), used for fixed small operands like argument counts. */
-  emitByte(b) {
-    this.opcodes.push(b);
-  }
-  /** Number of opcodes/operands emitted so far, used to compute jump targets before {@link patchJump}. */
-  get currentLength() {
-    return this.opcodes.length;
-  }
-  /**
-   * Register a compiled user-defined-function body, returning its index
-   * into this program's `userFunctionBodies` side-table, the caller emits
-   * that index as `DEFINE_USER_FUNCTION`'s operand via {@link emitIndex}.
-   * Subject to the same {@link MAX_CONSTANT_POOL_INDEX} bound as
-   * {@link emitNumber}/{@link emitString} (the index itself is a single
-   * opcode-stream byte), in practice a single line defines at most a
-   * handful of functions, so this limit is never realistically reached.
-   *
-   * @throws If more than 256 function bodies are registered on one program.
-   */
-  emitUserFunctionBody(name, params, program) {
-    const idx = this.userFunctionBodies.length;
-    if (idx > MAX_CONSTANT_POOL_INDEX) {
-      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
-        "TOO_MANY_FUNCTION_DEFINITIONS",
-        `More than ${MAX_CONSTANT_POOL_INDEX + 1} function definitions on one line, exceeding the bytecode constant pool's limit.`,
-        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
-      );
-    }
-    this.userFunctionBodies.push({ name, params, program });
-    return idx;
-  }
-  /**
-   * Register a compiled `map`/`reduce` anonymous transform body, returning
-   * its index into this program's `anonymousBodies` side-table, the
-   * caller emits that index as `MAP_INVOKE`/`REDUCE_INVOKE`'s operand via
-   * {@link emitIndex}. Same {@link MAX_CONSTANT_POOL_INDEX} bound as
-   * {@link emitUserFunctionBody}.
-   *
-   * @throws If more than 256 anonymous bodies are registered on one program.
-   */
-  emitAnonymousBody(params, program) {
-    const idx = this.anonymousBodies.length;
-    if (idx > MAX_CONSTANT_POOL_INDEX) {
-      throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
-        "TOO_MANY_ANONYMOUS_BODIES",
-        `More than ${MAX_CONSTANT_POOL_INDEX + 1} map/reduce transform expressions on one line, exceeding the bytecode constant pool's limit.`,
-        { limit: MAX_CONSTANT_POOL_INDEX + 1 }
-      );
-    }
-    this.anonymousBodies.push({ params, program });
-    return idx;
-  }
-  /** Overwrite a previously-emitted placeholder operand at `position` with the real jump `target`, once known. */
-  patchJump(position, target) {
-    this.opcodes[position] = target;
-  }
-  /**
-   * Build the accumulated opcodes/numbers/strings into a BytecodeProgram.
-   * Creates new TypedArrays, the builder can be reused after this call.
-   */
-  build() {
-    return {
-      opcodes: new Uint8Array(this.opcodes),
-      numbers: new Float64Array(this.numbers),
-      // Defensive copy: .length = 0 in reset() would clear a shared reference.
-      // Strings are rare (only UoM/datetime parselets emit them), so the copy
-      // cost is negligible.
-      strings: [...this.strings],
-      constants: /* @__PURE__ */ new Map(),
-      hasAsync: this._hasAsync,
-      userFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : void 0,
-      anonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : void 0
-    };
-  }
-  /**
-   * Build directly into a pre-allocated buffer for zero-copy VM consumption.
-   *
-   * When `buf` is provided and large enough, writes into it and returns
-   * subarray **views** (not copies), the returned TypedArrays share the
-   * buffer's underlying ArrayBuffer. The caller MUST NOT mutate the buffer
-   * until the returned BytecodeProgram is no longer needed.
-   *
-   * If the caller intends to cache the result, they must copy the TypedArrays
-   * (e.g. `new Uint8Array(program.opcodes)`) before reusing the buffer pool.
-   *
-   * When `buf` is omitted or too small, allocates fresh TypedArrays.
-   */
-  buildInto(buf) {
-    const opLen = this.opcodes.length;
-    const numLen = this.numbers.length;
-    const reuseOpcodes = buf && buf.opcodes.length >= opLen;
-    const reuseNumbers = buf && buf.numbers.length >= numLen;
-    const opcodes = reuseOpcodes ? new Uint8Array(buf.opcodes.buffer, buf.opcodes.byteOffset, opLen) : new Uint8Array(opLen);
-    const numbers = reuseNumbers ? new Float64Array(buf.numbers.buffer, buf.numbers.byteOffset, numLen) : new Float64Array(numLen);
-    for (let i = 0; i < opLen; i++) opcodes[i] = this.opcodes[i];
-    for (let i = 0; i < numLen; i++) numbers[i] = this.numbers[i];
-    return {
-      opcodes,
-      numbers,
-      strings: [...this.strings],
-      constants: /* @__PURE__ */ new Map(),
-      hasAsync: this._hasAsync,
-      userFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : void 0,
-      anonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : void 0
-    };
-  }
-  reset() {
-    this.opcodes.length = 0;
-    this.numbers.length = 0;
-    this.strings.length = 0;
-    this.stringIndex.clear();
-    this._hasAsync = false;
-    this.userFunctionBodies.length = 0;
-    this.anonymousBodies.length = 0;
-  }
-};
-
-// src/parser/BigIntLiteral.ts
-var CHAINED_DOT_THOUSANDS_GROUPS = /^\d{1,3}(\.\d{3}){2,}$/;
-var DIGITS_ONLY = /^\d+$/;
-function bigIntLiteralDigits(raw, localeCode) {
-  const withoutSuffix = raw.endsWith("n") ? raw.slice(0, -1) : raw;
-  if (DIGITS_ONLY.test(withoutSuffix)) return withoutSuffix;
-  const digits = CHAINED_DOT_THOUSANDS_GROUPS.test(withoutSuffix) ? withoutSuffix.split(".").join("") : stripLocaleGrouping(withoutSuffix, localeCode);
-  if (!DIGITS_ONLY.test(digits)) {
-    const separator = withoutSuffix.includes(".") ? "." : withoutSuffix.includes(",") ? "," : withoutSuffix;
-    throw chunkMIGXCBXT_cjs.ErrorFactory.parsing(
-      "INVALID_NUMBER_LITERAL",
-      `"${raw}" is not a whole number: "${separator}" separates decimals in the ${localeCode} locale, and a whole number cannot have a fractional part.`,
-      { raw, localeCode, separator }
-    );
-  }
-  return digits;
-}
-function stripLocaleGrouping(text, localeCode) {
-  const thousandsSeparator = chunkOUHT5Z36_cjs.getLocale(localeCode).display.thousandsSeparator;
-  return thousandsSeparator ? text.split(thousandsSeparator).join("") : text;
-}
-
-exports.BindingPower = BindingPower;
-exports.BytecodeBuilder = BytecodeBuilder;
-exports.bigIntLiteralDigits = bigIntLiteralDigits;
-exports.buildBindingPowerTable = buildBindingPowerTable;
-exports.invalidateBindingPowerTable = invalidateBindingPowerTable;
-//# sourceMappingURL=chunk-MI7OTUHL.cjs.map
-//# sourceMappingURL=chunk-MI7OTUHL.cjs.map

package/dist/chunk-MI7OTUHL.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parser/BindingPower.ts","../src/parser/BytecodeBuilder.ts","../src/parser/BigIntLiteral.ts"],"names":["TokenTypes","tokenTypeId","ErrorFactory","getLocale"],"mappings":"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","file":"chunk-MI7OTUHL.cjs","sourcesContent":["/**\n * Named precedence levels for the Pratt parser, from loosest (`Lowest`) to\n * tightest (`Call`) binding. A custom infix parselet compares its own\n * binding power against the current expression's to decide whether to\n * consume the next operator (higher power binds tighter, e.g. `*` over `+`).\n *\n * Package authors reference these when registering an infix parselet via\n * `IPackageRegistry.registerInfixParselet`. See the built-in packages for\n * examples of picking an appropriate level (e.g. arithmetic `+`/`-` use\n * `Sum`, `*`/`/` use `Product`).\n */\nexport const BindingPower = {\n  Lowest: 0,\n  Assignment: 10,\n  LogicalOr: 12,   // `or`, `||` — loosest of the boolean-logic operators\n  LogicalAnd: 14,  // `&&` — binds tighter than `or` (\"a or b and c\" = \"a or (b and c)\")\n  // The word \"and\" (`AND_CONJ`), which is both arithmetic addition (\"5 and 3\"\n  // is 8) and boolean conjunction (\"true and false\"). A phrase parselet\n  // collecting a list (\"average of X, Y and Z\") parses each argument at this\n  // level, and an argument stops at any operator whose power is <= the level it\n  // was parsed at, so putting \"and\" here is what makes it end an argument\n  // rather than be consumed as the addition it also is. Everything an argument\n  // should keep binds tighter, including a genuine \"+\" (`Sum`).\n  //\n  // It sits BELOW `Conditional` because the boolean reading needs comparisons\n  // to be its operands: at 28, \"5 > 3 and 2 > 1\" parsed as \"5 > (3 and 2) > 1\"\n  // and answered false. Above `LogicalAnd` so that \"and\" is still the tighter\n  // of the two conjunctions, and two steps off each neighbour to leave room.\n  Conjunction: 16,\n  // The bitwise trio and the shifts, ordered exactly as C and JavaScript order\n  // them, which is the order every language that borrowed these operators from\n  // C uses: `|` looser than `xor`, `xor` looser than `&`, all three looser than\n  // comparison, and the shifts tighter than comparison but looser than `+`.\n  // They used to share one level (35) between `Sum` and `Product`, so\n  // \"1 + 2 << 3\" answered 17 where JavaScript answers 24 and \"4 & 3 + 1\"\n  // answered 1 where JavaScript answers 4. Each has its own level now because\n  // a shared level makes \"4 | 6 & 3\" group left instead of letting `&` win.\n  //\n  // They stay TIGHTER than `Conjunction` so that a phrase argument parsed at\n  // that level (\"average of 5 | 3, 2 and 4\") keeps its bitwise operators\n  // instead of stopping at the first one.\n  BitwiseOr: 18,   // `|`\n  BitwiseXor: 20,  // the `xor` keyword (`BIT_XOR`), not the `^` exponent token\n  BitwiseAnd: 22,  // `&`\n  Conditional: 24, // comparisons (`==`, `<`, `>=`, ...), tighter than the bitwise trio, looser than the shifts\n  Shift: 27,       // `<<`, `>>`, `>>>`\n  Sum: 30,\n  Product: 40,\n  // `±` (the uncertainty operator), tighter than `+ - * /` and looser than `^`,\n  // so the tolerance attaches to its adjacent values: `12.3 ± 0.5 * 4` reads as\n  // `(12.3 ± 0.5) * 4` (the parenthesised headline case), and `2 + 3 ± 0.5` as\n  // `2 + (3 ± 0.5)`. A Tier-2 parselet (packages/uncertainty/), so this level is\n  // read off the parselet rather than the Tier-1 BUILTIN_INFIX_BP table below.\n  Uncertainty: 45,\n  // `^`, RIGHT-associative: \"2 ^ 3 ^ 2\" is 2^(3^2) = 512, as in mathematics,\n  // Python, Ruby and JavaScript's `**`. See PrecedenceParser.parseExpression\n  // and BinaryOpParselet for the two places that associativity is implemented.\n  Exponent: 50,\n  Prefix: 60,\n  Postfix: 70,\n  Call: 80,\n} as const;\n\n/**\n * Set the binding power of a named operator.\n *\n * Binding power is what decides precedence in the Pratt parser: a higher number\n * binds tighter, so `*` outranks `+`. Changing one changes how every existing\n * expression using that operator parses, which is why packages should allocate\n * a new name rather than adjust a built-in.\n *\n * @param name - Operator name.\n * @param power - Higher binds tighter.\n */\nexport function setBindingPower(name: string, power: number): void {\n  (BindingPower as Record<string, number>)[name] = power;\n}\n\n/**\n * Read the binding power of a named operator.\n *\n * @param name - Operator name.\n * @returns Its binding power, or 0 when the name is unknown, which makes an\n * unregistered operator terminate an expression rather than swallow the rest\n * of it.\n */\nexport function getBindingPower(name: string): number {\n  return (BindingPower as Record<string, number>)[name] ?? 0;\n}\n\n// ── Built-in Infix Operator Binding Power Table ──────────────────────────────\n// Pre-computed Uint8Array lookup indexed by token typeId.\n// value > 0  → built-in infix operator with that binding power\n// value = 0  → not a built-in infix, fall through to Tier 2 parselet registry\n//\n// Built at module load via buildBindingPowerTable(). The table is sparse\n// most entries are 0 since only ~15 of 80+ token types are infix operators.\n//\n// Performance: Uint8Array[typeId] is a single typed array load, no Map.get()\n// no string hashing, no property chain. V8 eliminates bounds checks when typeId\n// is known to be within array length.\n\nimport { TokenTypes } from \"@solve-js/lexer/Token\";\nimport { tokenTypeId } from \"@solve-js/lexer/Token\";\n\n/**\n * Mapping of token type names → binding powers for built-in infix operators.\n * Only operators listed here get the Tier 1 fast path in PrecedenceParser.\n * All other infix tokens use the Tier 2 parselet registry fallback.\n */\nconst BUILTIN_INFIX_BP: Record<string, number> = {\n  // Arithmetic (infix, left-associative)\n  [TokenTypes.PLUS]:     BindingPower.Sum,\n  [TokenTypes.MINUS]:    BindingPower.Sum,\n  [TokenTypes.STAR]:     BindingPower.Product,\n  [TokenTypes.SLASH]:    BindingPower.Product,\n  [TokenTypes.MOD]:      BindingPower.Product,\n\n  // Arithmetic (infix, RIGHT-associative, PrecedenceParser handles this specially)\n  [TokenTypes.CARET]:    BindingPower.Exponent,\n\n  // Bitwise and shift (infix, left-associative), one level each, ordered as C\n  // and JavaScript order them. `>>>` used to be missing from this table\n  // entirely, which left it running at its Tier 2 parselet level while `>>`\n  // ran at the Tier 1 one, so \"16 >> 3 & 1\" and \"16 >>> 3 & 1\" grouped\n  // differently and answered 0 and 8.\n  [TokenTypes.BIT_OR]:   BindingPower.BitwiseOr,\n  [TokenTypes.BIT_XOR]:  BindingPower.BitwiseXor,\n  [TokenTypes.BIT_AND]:  BindingPower.BitwiseAnd,\n  [TokenTypes.LSHIFT]:   BindingPower.Shift,\n  [TokenTypes.RSHIFT]:   BindingPower.Shift,\n  [TokenTypes.URSHIFT]:  BindingPower.Shift,\n\n  // Postfix (no right operand, PrecedenceParser handles this specially)\n  [TokenTypes.PERCENT]:  BindingPower.Postfix,\n\n  // Percentage keyword (infix, left-associative: \"50% of 200\" → MUL)\n  [TokenTypes.OF]:       BindingPower.Product,\n};\n\n// Note: These token types are intentionally NOT in the BP_TABLE, they stay in\n// the Tier 2 parselet registry because they require complex handling:\n//   IN, TO    → UoM conversion parselets (peek at target unit token, complex logic)\n//   DOT       → Property access (chained OBJ_GET, needs left-token tracking)\n//   EQUALS    → Assignment (VariableParselet handles :var = expr pattern)\n//   EQUALITY, NEQ, GTE, LTE → Comparison ops (need dedicated VM opcodes, task 2.15a)\n//   COMMA     → Argument separator (function calls, array/object literals)\n\n/** Cached BP_TABLE, built once at module load, immutable thereafter. */\nlet _bpTable: Uint8Array | null = null;\n\n/**\n * Build the Uint8Array binding power table indexed by token typeId.\n * Idempotent, returns cached table on subsequent calls.\n *\n * Must be called after all token types are registered (via registerAllTokenTypes())\n * and after plugin providers have registered their token types.\n */\nexport function buildBindingPowerTable(): Uint8Array {\n  if (_bpTable) return _bpTable;\n\n  // Size to the largest registered typeId + 1\n  let maxId = 0;\n  for (const name of Object.keys(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n  // Also scan all TokenTypes to ensure table covers all registered IDs\n  for (const name of Object.values(TokenTypes)) {\n    const id = tokenTypeId(name);\n    if (id > maxId) maxId = id;\n  }\n\n  const table = new Uint8Array(maxId + 1);\n  for (const [name, bp] of Object.entries(BUILTIN_INFIX_BP)) {\n    const id = tokenTypeId(name);\n    table[id] = bp;\n  }\n\n  _bpTable = table;\n  return table;\n}\n\n/**\n * Drop the cached table, so the next {@link buildBindingPowerTable} call builds\n * a fresh one sized to the token types registered by then.\n *\n * It does NOT add a plugin's operator to the Tier 1 fast path, which is what\n * this comment used to promise. The values in the table come from\n * `BUILTIN_INFIX_BP`, which is module-private and has no registration path, so\n * a rebuilt table holds the same binding powers and a plugin token still reads\n * 0. `PrecedenceParser.BP_TABLE` is a static initialized once at class\n * definition time and never re-read, so it would not see a rebuild anyway.\n *\n * A plugin's infix operator takes the Tier 2 parselet-registry route instead,\n * which is where an operator whose binding power the engine does not already\n * know is meant to live.\n */\nexport function invalidateBindingPowerTable(): void {\n  _bpTable = null;\n}\n","import { OpCode } from \"@solve-js/parser/OpCode\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * `BytecodeProgram.opcodes` is a `Uint8Array`, every operand written into\n * it (including constant-pool indices from {@link BytecodeBuilder.emitNumber}/\n * {@link BytecodeBuilder.emitString}) is truncated to a single byte on\n * `build()`. Exceeding this silently wraps the index (e.g. entry 300 reads\n * back as entry 44), producing a wrong result with no error. See\n * {@link BytecodeBuilder.emitNumber} for the guard that turns this into a\n * thrown error instead.\n */\nconst MAX_CONSTANT_POOL_INDEX = 255;\n\n/**\n * Compiled bytecode program produced by {@link BytecodeBuilder}.\n * Ready for consumption by {@link executeBytecode} without further processing.\n */\nexport interface BytecodeProgram {\n\topcodes: Uint8Array;\n\tnumbers: Float64Array;\n\tstrings: string[];\n\tconstants?: Map<number, number>;\n\t/**\n\t * Whether the program contains any async opcodes (CALL_PLUGIN, etc.).\n\t * Set during compilation by the BytecodeBuilder. Allows the engine\n\t * to skip the O(n) resolver preflight check in O(1) for purely\n\t * synchronous expressions like `2 + 2`.\n\t */\n\thasAsync: boolean;\n\t/**\n\t * User-defined-function bodies compiled alongside this program (one\n\t * entry per `name(params) = body` definition on this line). See\n\t * {@link BytecodeBuilder.emitUserFunctionBody}. `OpCode.DEFINE_USER_FUNCTION`'s\n\t * operand is an index into this array, resolved at VM-execution time\n\t * (not parse time) so a diagnostic/lookahead parse that never actually\n\t * executes the definition line has no side effect on `vm.userFunctions`.\n\t */\n\tuserFunctionBodies?: UserFunctionDef[];\n\t/**\n\t * Anonymous function bodies compiled alongside this program, one entry\n\t * per `map`/`reduce` inline transform expression (e.g. the `10*x` in\n\t * `map(10*x, [0,1,500])`). See {@link BytecodeBuilder.emitAnonymousBody}.\n\t * Deliberately a SEPARATE side-table from `userFunctionBodies`, not\n\t * routed through `vm.userFunctions` at all: an inline body has no name\n\t * and must never leak into the persistent name-keyed registry the way\n\t * a real `f(x) = ...` definition does.\n\t */\n\tanonymousBodies?: AnonymousBodyDef[];\n}\n\n/**\n * An anonymous transform body for `map`/`reduce`'s inline-expression form\n * (e.g. `10*x` in `map(10*x, [0,1,500])`, or `acc+x` in `reduce(acc+x,\n * [1,2,3])`). Structurally identical to {@link UserFunctionDef} minus the\n * `name`. See `OpCode.MAP_INVOKE`/`REDUCE_INVOKE` and\n * `vm/VM.ts`'s handlers, which build a call frame from `params`/`args`\n * exactly like `CALL_USER_FUNCTION` does, just without ever registering\n * the body in `vm.userFunctions`.\n */\nexport interface AnonymousBodyDef {\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * A user-defined, parameterized, reusable function's compiled form\n * (`f(x) = 2*x + 1`). See `OpCode.DEFINE_USER_FUNCTION`/`CALL_USER_FUNCTION`\n * and `vm/VM.ts`'s `VM.defineUserFunction`/`getUserFunction`.\n *\n * `program` is the body compiled to its OWN independent `BytecodeProgram`,\n * not a fragment of the definition line's own bytecode. Parameter names\n * inside the body compile to ORDINARY `LOAD_VAR <name>` opcodes, no\n * parse-time rewriting, because parameter resolution happens dynamically\n * at the VM level: `CALL_USER_FUNCTION` pushes a name-keyed call frame\n * (`Map<string, Value>`) before re-executing `program`, and `VM.getVar()`\n * checks the innermost call frame before falling back to the flat\n * document-variable store. This is why a `UNIT`-collision parameter name\n * (e.g. `h` in `area(w, h) = w * h`, which lexes as the \"hour\" unit) needs\n * no special handling anywhere, it's just another `LOAD_VAR \"h\"`, resolved\n * the same way as any other name.\n */\nexport interface UserFunctionDef {\n\tname: string;\n\tparams: string[];\n\tprogram: BytecodeProgram;\n}\n\n/**\n * Direct-to-bytecode compiler for the Pratt parser.\n *\n * Accumulates opcodes, numeric constants, and string references during parsing,\n * then produces a {@link BytecodeProgram} for VM execution. Supports:\n * - Standard build via {@link build}\n * - Zero-copy build into pre-allocated buffers via {@link buildInto}\n * - In-place reset for reuse without reallocation\n */\nexport class BytecodeBuilder {\n\tprivate opcodes: number[] = [];\n\tprivate numbers: number[] = [];\n\tprivate strings: string[] = [];\n\tprivate stringIndex = new Map<string, number>();\n\tprivate _hasAsync = false;\n\tprivate userFunctionBodies: UserFunctionDef[] = [];\n\tprivate anonymousBodies: AnonymousBodyDef[] = [];\n\n\t/** Emit an {@link OpCode} instruction. */\n\temitOpcode(op: OpCode): void {\n\t\tthis.opcodes.push(op);\n\t\tif (op === OpCode.CALL_PLUGIN) {\n\t\t\tthis._hasAsync = true;\n\t\t}\n\t}\n\n\t/**\n\t * Emit a numeric literal: appends `n` to the program's constant pool and\n\t * writes its index into the opcode stream (read back by the VM as e.g.\n\t * `PUSH_NUMBER <idx>`).\n\t *\n\t * Numeric constants are NOT deduplicated (unlike {@link emitString})\n\t * every call appends a new entry, so an expression with more than\n\t * {@link MAX_CONSTANT_POOL_INDEX}+1 distinct numeric-literal occurrences\n\t * throws rather than silently wrapping the index (see\n\t * `MAX_CONSTANT_POOL_INDEX`'s doc for what that would otherwise do).\n\t *\n\t * @throws If the constant pool would exceed 256 entries.\n\t */\n\temitNumber(n: number): void {\n\t\tconst idx = this.numbers.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_NUMERIC_CONSTANTS\",\n\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} numeric literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.numbers.push(n);\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a string literal: interns `s` into the program's string pool\n\t * (deduplicated via `stringIndex`) and writes its index into the opcode\n\t * stream. Subject to the same constant-pool bound as {@link emitNumber},\n\t * but since strings ARE deduplicated, only distinct string values count\n\t * against the limit.\n\t *\n\t * @throws If the string pool would exceed 256 distinct entries.\n\t */\n\temitString(s: string): void {\n\t\tlet idx = this.stringIndex.get(s);\n\t\tif (idx === undefined) {\n\t\t\tidx = this.strings.length;\n\t\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\t\"TOO_MANY_STRING_CONSTANTS\",\n\t\t\t\t\t`Expression has more than ${MAX_CONSTANT_POOL_INDEX + 1} distinct string literals, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t\t);\n\t\t\t}\n\t\t\tthis.strings.push(s);\n\t\t\tthis.stringIndex.set(s, idx);\n\t\t}\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/**\n\t * Emit a raw numeric operand (0-255) following an opcode, e.g. a\n\t * plugin-function index for `CALL_PLUGIN`, or an argument count. Unlike\n\t * {@link emitOpcode}, this does not go through the `OpCode` enum, so\n\t * package authors use this (not an unsafe cast to `OpCode`) to push\n\t * operands their own opcode handler expects to read positionally.\n\t */\n\temitIndex(idx: number): void {\n\t\tthis.opcodes.push(idx);\n\t}\n\n\t/** Emit a raw byte (0-255), used for fixed small operands like argument counts. */\n\temitByte(b: number): void {\n\t\tthis.opcodes.push(b);\n\t}\n\n\t/** Number of opcodes/operands emitted so far, used to compute jump targets before {@link patchJump}. */\n\tget currentLength(): number {\n\t\treturn this.opcodes.length;\n\t}\n\n\t/**\n\t * Register a compiled user-defined-function body, returning its index\n\t * into this program's `userFunctionBodies` side-table, the caller emits\n\t * that index as `DEFINE_USER_FUNCTION`'s operand via {@link emitIndex}.\n\t * Subject to the same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitNumber}/{@link emitString} (the index itself is a single\n\t * opcode-stream byte), in practice a single line defines at most a\n\t * handful of functions, so this limit is never realistically reached.\n\t *\n\t * @throws If more than 256 function bodies are registered on one program.\n\t */\n\temitUserFunctionBody(name: string, params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.userFunctionBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_FUNCTION_DEFINITIONS\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} function definitions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.userFunctionBodies.push({ name, params, program });\n\t\treturn idx;\n\t}\n\n\t/**\n\t * Register a compiled `map`/`reduce` anonymous transform body, returning\n\t * its index into this program's `anonymousBodies` side-table, the\n\t * caller emits that index as `MAP_INVOKE`/`REDUCE_INVOKE`'s operand via\n\t * {@link emitIndex}. Same {@link MAX_CONSTANT_POOL_INDEX} bound as\n\t * {@link emitUserFunctionBody}.\n\t *\n\t * @throws If more than 256 anonymous bodies are registered on one program.\n\t */\n\temitAnonymousBody(params: string[], program: BytecodeProgram): number {\n\t\tconst idx = this.anonymousBodies.length;\n\t\tif (idx > MAX_CONSTANT_POOL_INDEX) {\n\t\t\tthrow ErrorFactory.parsing(\n\t\t\t\t\"TOO_MANY_ANONYMOUS_BODIES\",\n\t\t\t\t`More than ${MAX_CONSTANT_POOL_INDEX + 1} map/reduce transform expressions on one line, exceeding the bytecode constant pool's limit.`,\n\t\t\t\t{ limit: MAX_CONSTANT_POOL_INDEX + 1 }\n\t\t\t);\n\t\t}\n\t\tthis.anonymousBodies.push({ params, program });\n\t\treturn idx;\n\t}\n\n\t/** Overwrite a previously-emitted placeholder operand at `position` with the real jump `target`, once known. */\n\tpatchJump(position: number, target: number): void {\n\t\tthis.opcodes[position] = target;\n\t}\n\n\t/**\n\t * Build the accumulated opcodes/numbers/strings into a BytecodeProgram.\n\t * Creates new TypedArrays, the builder can be reused after this call.\n\t */\n\tbuild(): BytecodeProgram {\n\t\treturn {\n\t\t\topcodes: new Uint8Array(this.opcodes),\n\t\t\tnumbers: new Float64Array(this.numbers),\n\t\t\t// Defensive copy: .length = 0 in reset() would clear a shared reference.\n\t\t\t// Strings are rare (only UoM/datetime parselets emit them), so the copy\n\t\t\t// cost is negligible.\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\t/**\n\t * Build directly into a pre-allocated buffer for zero-copy VM consumption.\n\t *\n\t * When `buf` is provided and large enough, writes into it and returns\n\t * subarray **views** (not copies), the returned TypedArrays share the\n\t * buffer's underlying ArrayBuffer. The caller MUST NOT mutate the buffer\n\t * until the returned BytecodeProgram is no longer needed.\n\t *\n\t * If the caller intends to cache the result, they must copy the TypedArrays\n\t * (e.g. `new Uint8Array(program.opcodes)`) before reusing the buffer pool.\n\t *\n\t * When `buf` is omitted or too small, allocates fresh TypedArrays.\n\t */\n\tbuildInto(buf?: { opcodes: Uint8Array; numbers: Float64Array }): BytecodeProgram {\n\t\tconst opLen = this.opcodes.length;\n\t\tconst numLen = this.numbers.length;\n\n\t\tconst reuseOpcodes = buf && buf.opcodes.length >= opLen;\n\t\tconst reuseNumbers = buf && buf.numbers.length >= numLen;\n\n\t\t// Subarray views that share the buffer's ArrayBuffer (zero-copy)\n\t\tconst opcodes = reuseOpcodes\n\t\t\t? new Uint8Array(buf!.opcodes.buffer, buf!.opcodes.byteOffset, opLen)\n\t\t\t: new Uint8Array(opLen);\n\t\tconst numbers = reuseNumbers\n\t\t\t? new Float64Array(buf!.numbers.buffer, buf!.numbers.byteOffset, numLen)\n\t\t\t: new Float64Array(numLen);\n\n\t\t// Write data into the views\n\t\tfor (let i = 0; i < opLen; i++) opcodes[i] = this.opcodes[i];\n\t\tfor (let i = 0; i < numLen; i++) numbers[i] = this.numbers[i];\n\n\t\treturn {\n\t\t\topcodes,\n\t\t\tnumbers,\n\t\t\tstrings: [...this.strings],\n\t\t\tconstants: new Map(),\n\t\t\thasAsync: this._hasAsync,\n\t\t\tuserFunctionBodies: this.userFunctionBodies.length > 0 ? [...this.userFunctionBodies] : undefined,\n\t\t\tanonymousBodies: this.anonymousBodies.length > 0 ? [...this.anonymousBodies] : undefined,\n\t\t};\n\t}\n\n\treset(): void {\n\t\t// Retain backing stores with .length = 0 to avoid reallocation on growth.\n\t\t// = [] discards the ArrayBuffer, forcing V8 to reallocate on every push()\n\t\t// threshold (4→8→16→32...). For a 50-opcode expression, that's 3-4 copies.\n\t\tthis.opcodes.length = 0;\n\t\tthis.numbers.length = 0;\n\t\tthis.strings.length = 0;\n\t\tthis.stringIndex.clear();\n\t\tthis._hasAsync = false;\n\t\tthis.userFunctionBodies.length = 0;\n\t\tthis.anonymousBodies.length = 0;\n\t}\n}\n","/**\n * Turning a `123n` literal's source text into the digits `PUSH_BIGINT` stores.\n *\n * The lexer coalesces thousands groups into the number token it is building,\n * accepting both `,` and `.` as the separator regardless of locale (see\n * `lexer/ExpressionLexer.ts`'s \"Thousands separators\" block). For a NUMBER that\n * is fine, because the separators are stripped again when the text is turned\n * into a double. For a BIGINT nothing stripped them: both consumers took the\n * token text, removed the trailing `n`, and handed the rest straight to\n * `BigInt()`.\n *\n * So `1.000n` reached `BigInt(\"1.000\")`, which throws a raw `SyntaxError` that\n * arrived at the host as UNEXPECTED_ERROR/INTERNAL: the engine reporting its\n * own bug for six characters a user typed. `1.01n` and `1.1n` were fine, which\n * is the tell that the `n` suffix was never the problem, the three-digit\n * thousands group was: a dot followed by exactly three digits is what the lexer\n * swallows, and one followed by one or two digits it leaves alone.\n *\n * Written once here rather than inline at both call sites. There are two\n * (`parser/PrecedenceParser.ts`'s Tier-1 switch and\n * `packages/biginteger/parselets/BigIntNumberParselet.ts`), they already held\n * identical copies of the `n`-stripping, and the two tiers disagreeing about a\n * literal is a bug shape this codebase has had before.\n *\n * @module BigIntLiteral\n */\n\nimport { getLocale } from \"@solve-js/constants/locales\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\n\n/**\n * Two or more dot-separated groups of three, e.g. `1.234.567`.\n *\n * Unambiguous in any locale, since no locale writes two decimal points, so this\n * is stripped without consulting one. Same regex and same reasoning as\n * `NumberParselet.ts`'s copy for the NUMBER path.\n */\nconst CHAINED_DOT_THOUSANDS_GROUPS = /^\\d{1,3}(\\.\\d{3}){2,}$/;\n\n/** Digits and nothing else, which is what `BigInt()` can be handed safely. */\nconst DIGITS_ONLY = /^\\d+$/;\n\n/**\n * The digit string behind a bigint literal.\n *\n * A bigint literal has no fractional part by construction: the lexer only emits\n * BIGINT when it saw no decimal point of its own and no exponent, so any `.` or\n * `,` still in the text got there as a thousands group. Which of the two the\n * writer meant is a locale question, and answering it wrongly would silently\n * change the value by three orders of magnitude, so only the separator this\n * locale actually uses for grouping is removed. Anything left over is refused\n * rather than guessed at.\n *\n * @param raw - The token's text, with or without the trailing `n`.\n * @param localeCode - The engine's active locale.\n * @returns A string of digits, ready for `BigInt()`.\n * @throws An `INVALID_NUMBER_LITERAL` parsing error when what is left is not a\n * whole number, e.g. `1.000n` in a locale that writes decimals with a dot.\n */\nexport function bigIntLiteralDigits(raw: string, localeCode: string): string {\n\tconst withoutSuffix = raw.endsWith(\"n\") ? raw.slice(0, -1) : raw;\n\n\t// The common case first: nothing was grouped, so there is nothing to decide.\n\tif (DIGITS_ONLY.test(withoutSuffix)) return withoutSuffix;\n\n\tconst digits = CHAINED_DOT_THOUSANDS_GROUPS.test(withoutSuffix)\n\t\t? withoutSuffix.split(\".\").join(\"\")\n\t\t: stripLocaleGrouping(withoutSuffix, localeCode);\n\n\tif (!DIGITS_ONLY.test(digits)) {\n\t\tconst separator = withoutSuffix.includes(\".\") ? \".\" : withoutSuffix.includes(\",\") ? \",\" : withoutSuffix;\n\t\tthrow ErrorFactory.parsing(\n\t\t\t\"INVALID_NUMBER_LITERAL\",\n\t\t\t`\"${raw}\" is not a whole number: \"${separator}\" separates decimals in the ${localeCode} locale, and a whole number cannot have a fractional part.`,\n\t\t\t{ raw, localeCode, separator },\n\t\t);\n\t}\n\treturn digits;\n}\n\n/**\n * Removes the active locale's own thousands separator and nothing else.\n *\n * @param text - The literal without its `n`.\n * @param localeCode - The engine's active locale.\n * @returns The text with grouping removed, which the caller then re-checks.\n */\nfunction stripLocaleGrouping(text: string, localeCode: string): string {\n\tconst thousandsSeparator = getLocale(localeCode).display.thousandsSeparator;\n\treturn thousandsSeparator ? text.split(thousandsSeparator).join(\"\") : text;\n}\n"]}