roll-parser 2.3.2 → 3.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1723 @@
+// src/errors.ts
+var ROLL_PARSER_ERROR_CODES = [
+  "UNEXPECTED_CHARACTER",
+  "UNEXPECTED_IDENTIFIER",
+  "UNEXPECTED_TOKEN",
+  "UNEXPECTED_END",
+  "EXPECTED_TOKEN",
+  "INVALID_DICE_COUNT",
+  "INVALID_DICE_SIDES",
+  "DICE_LIMIT_EXCEEDED",
+  "DIVISION_BY_ZERO",
+  "MODULO_BY_ZERO",
+  "UNKNOWN_OPERATOR",
+  "UNKNOWN_NODE_TYPE",
+  "INVALID_MODIFIER_COUNT",
+  "EXPLODE_LIMIT_EXCEEDED",
+  "INVALID_EXPLODE_TARGET",
+  "REROLL_LIMIT_EXCEEDED",
+  "INVALID_SUCCESS_COUNT_TARGET",
+  "INVALID_THRESHOLD",
+  "NESTED_VERSUS",
+  "INVALID_FUNCTION_ARITY",
+  "UNKNOWN_FUNCTION"
+];
+
+class RollParserError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "RollParserError";
+    this.code = code;
+  }
+}
+var VALID_CODES = new Set(ROLL_PARSER_ERROR_CODES);
+function isRollParserError(value) {
+  if (value instanceof RollParserError)
+    return true;
+  return value instanceof Error && "code" in value && typeof value.code === "string" && VALID_CODES.has(value.code);
+}
+// src/lexer/tokens.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2[TokenType2["NUMBER"] = 0] = "NUMBER";
+  TokenType2[TokenType2["DICE"] = 1] = "DICE";
+  TokenType2[TokenType2["DICE_PERCENT"] = 2] = "DICE_PERCENT";
+  TokenType2[TokenType2["DICE_FATE"] = 3] = "DICE_FATE";
+  TokenType2[TokenType2["PLUS"] = 4] = "PLUS";
+  TokenType2[TokenType2["MINUS"] = 5] = "MINUS";
+  TokenType2[TokenType2["MULTIPLY"] = 6] = "MULTIPLY";
+  TokenType2[TokenType2["DIVIDE"] = 7] = "DIVIDE";
+  TokenType2[TokenType2["MODULO"] = 8] = "MODULO";
+  TokenType2[TokenType2["POWER"] = 9] = "POWER";
+  TokenType2[TokenType2["GREATER"] = 10] = "GREATER";
+  TokenType2[TokenType2["GREATER_EQUAL"] = 11] = "GREATER_EQUAL";
+  TokenType2[TokenType2["LESS"] = 12] = "LESS";
+  TokenType2[TokenType2["LESS_EQUAL"] = 13] = "LESS_EQUAL";
+  TokenType2[TokenType2["EQUAL"] = 14] = "EQUAL";
+  TokenType2[TokenType2["LPAREN"] = 15] = "LPAREN";
+  TokenType2[TokenType2["RPAREN"] = 16] = "RPAREN";
+  TokenType2[TokenType2["COMMA"] = 17] = "COMMA";
+  TokenType2[TokenType2["KEEP_HIGH"] = 18] = "KEEP_HIGH";
+  TokenType2[TokenType2["KEEP_LOW"] = 19] = "KEEP_LOW";
+  TokenType2[TokenType2["DROP_HIGH"] = 20] = "DROP_HIGH";
+  TokenType2[TokenType2["DROP_LOW"] = 21] = "DROP_LOW";
+  TokenType2[TokenType2["EXPLODE"] = 22] = "EXPLODE";
+  TokenType2[TokenType2["EXPLODE_COMPOUND"] = 23] = "EXPLODE_COMPOUND";
+  TokenType2[TokenType2["EXPLODE_PENETRATING"] = 24] = "EXPLODE_PENETRATING";
+  TokenType2[TokenType2["REROLL"] = 25] = "REROLL";
+  TokenType2[TokenType2["REROLL_ONCE"] = 26] = "REROLL_ONCE";
+  TokenType2[TokenType2["FAIL"] = 27] = "FAIL";
+  TokenType2[TokenType2["FUNCTION"] = 28] = "FUNCTION";
+  TokenType2[TokenType2["VS"] = 29] = "VS";
+  TokenType2[TokenType2["EOF"] = 30] = "EOF";
+})(TokenType ||= {});
+
+// src/lexer/lexer.ts
+class LexerError extends RollParserError {
+  position;
+  character;
+  constructor(message, code, position, character) {
+    super(`${message} at position ${position}: '${character}'`, code);
+    this.name = "LexerError";
+    this.position = position;
+    this.character = character;
+  }
+}
+var IDENTIFIER_KEYWORDS = {
+  kh: 18 /* KEEP_HIGH */,
+  kl: 19 /* KEEP_LOW */,
+  k: 18 /* KEEP_HIGH */,
+  dh: 20 /* DROP_HIGH */,
+  dl: 21 /* DROP_LOW */,
+  d: 1 /* DICE */,
+  r: 25 /* REROLL */,
+  ro: 26 /* REROLL_ONCE */,
+  f: 27 /* FAIL */,
+  vs: 29 /* VS */,
+  floor: 28 /* FUNCTION */,
+  ceil: 28 /* FUNCTION */,
+  round: 28 /* FUNCTION */,
+  abs: 28 /* FUNCTION */,
+  max: 28 /* FUNCTION */,
+  min: 28 /* FUNCTION */
+};
+
+class Lexer {
+  pos = 0;
+  input;
+  constructor(input) {
+    this.input = input;
+  }
+  tokenize() {
+    const tokens = [];
+    while (true) {
+      const token = this.nextToken();
+      tokens.push(token);
+      if (token.type === 30 /* EOF */)
+        break;
+    }
+    return tokens;
+  }
+  nextToken() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      return this.createToken(30 /* EOF */, "");
+    }
+    const startPos = this.pos;
+    const char = this.peek();
+    if (this.isDigit(char)) {
+      return this.scanNumber();
+    }
+    if (this.isAlpha(char)) {
+      return this.scanIdentifier();
+    }
+    this.advance();
+    switch (char) {
+      case "+":
+        return this.createTokenAt(4 /* PLUS */, char, startPos);
+      case "-":
+        return this.createTokenAt(5 /* MINUS */, char, startPos);
+      case "*":
+        if (this.match("*")) {
+          return this.createTokenAt(9 /* POWER */, "**", startPos);
+        }
+        return this.createTokenAt(6 /* MULTIPLY */, char, startPos);
+      case "/":
+        return this.createTokenAt(7 /* DIVIDE */, char, startPos);
+      case "%":
+        return this.createTokenAt(8 /* MODULO */, char, startPos);
+      case "^":
+        return this.createTokenAt(9 /* POWER */, char, startPos);
+      case "(":
+        return this.createTokenAt(15 /* LPAREN */, char, startPos);
+      case ")":
+        return this.createTokenAt(16 /* RPAREN */, char, startPos);
+      case ",":
+        return this.createTokenAt(17 /* COMMA */, char, startPos);
+      case ">":
+        if (this.match("=")) {
+          return this.createTokenAt(11 /* GREATER_EQUAL */, ">=", startPos);
+        }
+        return this.createTokenAt(10 /* GREATER */, char, startPos);
+      case "<":
+        if (this.match("=")) {
+          return this.createTokenAt(13 /* LESS_EQUAL */, "<=", startPos);
+        }
+        return this.createTokenAt(12 /* LESS */, char, startPos);
+      case "=":
+        return this.createTokenAt(14 /* EQUAL */, char, startPos);
+      case "!":
+        if (this.match("!")) {
+          return this.createTokenAt(23 /* EXPLODE_COMPOUND */, "!!", startPos);
+        }
+        if (!this.isAtEnd() && this.peek().toLowerCase() === "p") {
+          this.advance();
+          return this.createTokenAt(24 /* EXPLODE_PENETRATING */, "!p", startPos);
+        }
+        return this.createTokenAt(22 /* EXPLODE */, char, startPos);
+      default:
+        throw new LexerError("Unexpected character", "UNEXPECTED_CHARACTER", startPos, char);
+    }
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
+      this.advance();
+    }
+  }
+  scanNumber() {
+    const startPos = this.pos;
+    let value = "";
+    while (!this.isAtEnd() && this.isDigit(this.peek())) {
+      value += this.advance();
+    }
+    if (!this.isAtEnd() && this.peek() === "." && this.isDigit(this.peekNext())) {
+      value += this.advance();
+      while (!this.isAtEnd() && this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+    return this.createTokenAt(0 /* NUMBER */, value, startPos);
+  }
+  scanIdentifier() {
+    const startPos = this.pos;
+    const first = this.peek();
+    const second = this.peekNext();
+    if ((first === "d" || first === "D") && (second === "f" || second === "F")) {
+      this.advance();
+      this.advance();
+      return this.createTokenAt(3 /* DICE_FATE */, "df", startPos);
+    }
+    let value = "";
+    while (!this.isAtEnd() && this.isAlpha(this.peek())) {
+      value += this.advance();
+    }
+    const lower = value.toLowerCase();
+    if (lower === "d" && !this.isAtEnd() && this.peek() === "%") {
+      this.advance();
+      return this.createTokenAt(2 /* DICE_PERCENT */, "d%", startPos);
+    }
+    const tokenType = IDENTIFIER_KEYWORDS[lower];
+    if (tokenType != null) {
+      return this.createTokenAt(tokenType, lower, startPos);
+    }
+    throw new LexerError("Unexpected identifier", "UNEXPECTED_IDENTIFIER", startPos, lower);
+  }
+  peek() {
+    return this.input[this.pos] ?? "";
+  }
+  peekNext() {
+    return this.input[this.pos + 1] ?? "";
+  }
+  advance() {
+    return this.input[this.pos++] ?? "";
+  }
+  match(expected) {
+    if (this.isAtEnd())
+      return false;
+    if (this.input[this.pos] !== expected)
+      return false;
+    this.pos++;
+    return true;
+  }
+  isAtEnd() {
+    return this.pos >= this.input.length;
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isAlpha(char) {
+    const c = char.toLowerCase();
+    return c >= "a" && c <= "z";
+  }
+  isWhitespace(char) {
+    return char === " " || char === "\t" || char === `
+` || char === "\r";
+  }
+  createToken(type, value) {
+    return { type, value, position: this.pos };
+  }
+  createTokenAt(type, value, position) {
+    return { type, value, position };
+  }
+}
+function lex(input) {
+  return new Lexer(input).tokenize();
+}
+// src/parser/ast.ts
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isDice(node) {
+  return node.type === "Dice";
+}
+function isFateDice(node) {
+  return node.type === "FateDice";
+}
+function isBinaryOp(node) {
+  return node.type === "BinaryOp";
+}
+function isUnaryOp(node) {
+  return node.type === "UnaryOp";
+}
+function isModifier(node) {
+  return node.type === "Modifier";
+}
+function isExplode(node) {
+  return node.type === "Explode";
+}
+function isReroll(node) {
+  return node.type === "Reroll";
+}
+function isSuccessCount(node) {
+  return node.type === "SuccessCount";
+}
+function isVersus(node) {
+  return node.type === "Versus";
+}
+function isFunctionCall(node) {
+  return node.type === "FunctionCall";
+}
+function containsDice(node) {
+  switch (node.type) {
+    case "Dice":
+    case "FateDice":
+      return true;
+    case "Literal":
+      return false;
+    case "BinaryOp":
+      return containsDice(node.left) || containsDice(node.right);
+    case "UnaryOp":
+      return containsDice(node.operand);
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "SuccessCount":
+      return containsDice(node.target);
+    case "Versus":
+      return containsDice(node.roll) || containsDice(node.dc);
+    case "FunctionCall":
+      return node.args.some(containsDice);
+  }
+}
+
+// src/parser/parser.ts
+class ParseError extends RollParserError {
+  position;
+  token;
+  constructor(message, code, position, token) {
+    super(`${message} at position ${position}`, code);
+    this.name = "ParseError";
+    this.position = position;
+    this.token = token ?? undefined;
+  }
+}
+var BP = {
+  VS_LEFT: 2,
+  VS_RIGHT: 3,
+  ADD_LEFT: 10,
+  ADD_RIGHT: 11,
+  MUL_LEFT: 20,
+  MUL_RIGHT: 21,
+  UNARY: 25,
+  POW_LEFT: 31,
+  POW_RIGHT: 30,
+  MODIFIER: 35,
+  DICE_LEFT: 40,
+  DICE_RIGHT: 41
+};
+var FUNCTION_ARITY = {
+  floor: { min: 1, max: 1 },
+  ceil: { min: 1, max: 1 },
+  round: { min: 1, max: 1 },
+  abs: { min: 1, max: 1 },
+  max: { min: 2, max: Number.POSITIVE_INFINITY },
+  min: { min: 2, max: Number.POSITIVE_INFINITY }
+};
+
+class Parser {
+  tokens;
+  pos = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    if (this.peek().type === 30 /* EOF */) {
+      throw new ParseError("Unexpected end of input", "UNEXPECTED_END", this.peek().position);
+    }
+    const ast = this.parseExpression(0);
+    if (this.peek().type !== 30 /* EOF */) {
+      const token = this.peek();
+      throw new ParseError(`Unexpected token '${token.value}'`, "UNEXPECTED_TOKEN", token.position, token);
+    }
+    return ast;
+  }
+  parseExpression(minBp) {
+    let left = this.parseNud();
+    while (this.hasTokens()) {
+      const token = this.peek();
+      const leftBp = this.getLeftBp(token);
+      if (leftBp < minBp)
+        break;
+      this.advance();
+      left = this.parseLed(left, token);
+    }
+    return left;
+  }
+  parseNud() {
+    const token = this.advance();
+    switch (token.type) {
+      case 0 /* NUMBER */:
+        return this.parseLiteral(token);
+      case 5 /* MINUS */:
+        return this.parseUnaryMinus();
+      case 1 /* DICE */:
+        return this.parsePrefixDice();
+      case 2 /* DICE_PERCENT */:
+        return this.parsePrefixDicePercent();
+      case 3 /* DICE_FATE */:
+        return this.parsePrefixFateDice();
+      case 15 /* LPAREN */:
+        return this.parseGrouped();
+      case 28 /* FUNCTION */:
+        return this.parseFunctionCall(token);
+      case 30 /* EOF */:
+        throw new ParseError("Unexpected end of input", "UNEXPECTED_END", token.position);
+      default:
+        throw new ParseError(`Unexpected token '${token.value}'`, "UNEXPECTED_TOKEN", token.position, token);
+    }
+  }
+  parseLed(left, token) {
+    switch (token.type) {
+      case 1 /* DICE */:
+        return this.parseInfixDice(left);
+      case 2 /* DICE_PERCENT */:
+        return this.parseInfixDicePercent(left);
+      case 3 /* DICE_FATE */:
+        return this.parseInfixFateDice(left);
+      case 4 /* PLUS */:
+      case 5 /* MINUS */:
+      case 6 /* MULTIPLY */:
+      case 7 /* DIVIDE */:
+      case 8 /* MODULO */:
+      case 9 /* POWER */:
+        return this.parseBinaryOp(left, token);
+      case 18 /* KEEP_HIGH */:
+      case 19 /* KEEP_LOW */:
+      case 20 /* DROP_HIGH */:
+      case 21 /* DROP_LOW */:
+        return this.parseModifier(left, token);
+      case 22 /* EXPLODE */:
+      case 23 /* EXPLODE_COMPOUND */:
+      case 24 /* EXPLODE_PENETRATING */:
+        return this.parseExplode(left, token);
+      case 25 /* REROLL */:
+      case 26 /* REROLL_ONCE */:
+        return this.parseReroll(left, token);
+      case 10 /* GREATER */:
+      case 11 /* GREATER_EQUAL */:
+      case 12 /* LESS */:
+      case 13 /* LESS_EQUAL */:
+      case 14 /* EQUAL */:
+        return this.parseSuccessCount(left, token);
+      case 29 /* VS */:
+        return this.parseVersus(left, token);
+      default:
+        throw new ParseError(`Unexpected infix token '${token.value}'`, "UNEXPECTED_TOKEN", token.position, token);
+    }
+  }
+  parseLiteral(token) {
+    return {
+      type: "Literal",
+      value: Number.parseFloat(token.value)
+    };
+  }
+  parseUnaryMinus() {
+    const operand = this.parseExpression(BP.UNARY);
+    return {
+      type: "UnaryOp",
+      operator: "-",
+      operand
+    };
+  }
+  parsePrefixDice() {
+    const sides = this.parseExpression(BP.DICE_RIGHT);
+    return {
+      type: "Dice",
+      count: { type: "Literal", value: 1 },
+      sides
+    };
+  }
+  parseInfixDice(left) {
+    const sides = this.parseExpression(BP.DICE_RIGHT);
+    return {
+      type: "Dice",
+      count: left,
+      sides
+    };
+  }
+  parsePrefixDicePercent() {
+    return {
+      type: "Dice",
+      count: { type: "Literal", value: 1 },
+      sides: { type: "Literal", value: 100 }
+    };
+  }
+  parseInfixDicePercent(left) {
+    return {
+      type: "Dice",
+      count: left,
+      sides: { type: "Literal", value: 100 }
+    };
+  }
+  parsePrefixFateDice() {
+    return {
+      type: "FateDice",
+      count: { type: "Literal", value: 1 }
+    };
+  }
+  parseInfixFateDice(left) {
+    return {
+      type: "FateDice",
+      count: left
+    };
+  }
+  parseGrouped() {
+    const expr = this.parseExpression(0);
+    this.expect(16 /* RPAREN */);
+    return expr;
+  }
+  parseFunctionCall(token) {
+    this.expect(15 /* LPAREN */);
+    const args = [];
+    if (this.peek().type !== 16 /* RPAREN */) {
+      args.push(this.parseExpression(0));
+      while (this.peek().type === 17 /* COMMA */) {
+        this.advance();
+        args.push(this.parseExpression(0));
+      }
+    }
+    this.expect(16 /* RPAREN */);
+    const arity = FUNCTION_ARITY[token.value];
+    if (arity === undefined) {
+      throw new ParseError(`Unknown function '${token.value}'`, "UNKNOWN_FUNCTION", token.position, token);
+    }
+    if (args.length < arity.min || args.length > arity.max) {
+      const expected = arity.max === Number.POSITIVE_INFINITY ? `at least ${arity.min}` : arity.min === arity.max ? `${arity.min}` : `${arity.min}–${arity.max}`;
+      throw new ParseError(`Function '${token.value}' expects ${expected} argument${arity.min === 1 && arity.max === 1 ? "" : "s"}, got ${args.length}`, "INVALID_FUNCTION_ARITY", token.position, token);
+    }
+    return { type: "FunctionCall", name: token.value, args };
+  }
+  parseBinaryOp(left, token) {
+    const operator = this.getOperatorSymbol(token);
+    const rightBp = this.getRightBp(token);
+    const right = this.parseExpression(rightBp);
+    return {
+      type: "BinaryOp",
+      operator,
+      left,
+      right
+    };
+  }
+  rejectSuccessCountTarget(target, token) {
+    if (isSuccessCount(target)) {
+      throw new ParseError(`Cannot apply modifier after success counting`, "INVALID_SUCCESS_COUNT_TARGET", token.position, token);
+    }
+  }
+  parseModifier(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    const modifier = token.type === 18 /* KEEP_HIGH */ || token.type === 19 /* KEEP_LOW */ ? "keep" : "drop";
+    const selector = token.type === 18 /* KEEP_HIGH */ || token.type === 20 /* DROP_HIGH */ ? "highest" : "lowest";
+    const nextToken = this.peek().type;
+    const count = nextToken === 0 /* NUMBER */ || nextToken === 15 /* LPAREN */ ? this.parseExpression(BP.DICE_LEFT) : { type: "Literal", value: 1 };
+    return {
+      type: "Modifier",
+      modifier,
+      selector,
+      count,
+      target
+    };
+  }
+  parseExplode(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    if (target.type === "Explode") {
+      throw new ParseError(`Cannot chain explode modifiers`, "INVALID_EXPLODE_TARGET", token.position, token);
+    }
+    const variant = token.type === 22 /* EXPLODE */ ? "standard" : token.type === 23 /* EXPLODE_COMPOUND */ ? "compound" : "penetrating";
+    const node = { type: "Explode", variant, target };
+    if (this.isComparePointAhead()) {
+      node.threshold = this.parseComparePoint();
+    }
+    return node;
+  }
+  parseReroll(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    if (!this.isComparePointAhead()) {
+      throw new ParseError(`Expected comparison operator after '${token.value}'`, "EXPECTED_TOKEN", token.position, token);
+    }
+    const once = token.type === 26 /* REROLL_ONCE */;
+    const condition = this.parseComparePoint();
+    return { type: "Reroll", once, condition, target };
+  }
+  parseSuccessCount(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    if (!containsDice(target)) {
+      throw new ParseError(`Success counting requires a dice expression`, "INVALID_SUCCESS_COUNT_TARGET", token.position, token);
+    }
+    const operator = this.getCompareOp(token);
+    const value = this.parseExpression(BP.DICE_LEFT);
+    const node = {
+      type: "SuccessCount",
+      target,
+      threshold: { operator, value }
+    };
+    if (this.peek().type === 27 /* FAIL */) {
+      this.advance();
+      const failValue = this.parseExpression(BP.DICE_LEFT);
+      node.failThreshold = { operator: "=", value: failValue };
+    }
+    return node;
+  }
+  parseVersus(left, token) {
+    if (left.type === "Versus") {
+      throw new ParseError("Cannot chain versus operators", "NESTED_VERSUS", token.position, token);
+    }
+    const dc = this.parseExpression(BP.VS_RIGHT);
+    return { type: "Versus", roll: left, dc };
+  }
+  isComparePointAhead() {
+    const type = this.peek().type;
+    return type === 10 /* GREATER */ || type === 11 /* GREATER_EQUAL */ || type === 12 /* LESS */ || type === 13 /* LESS_EQUAL */ || type === 14 /* EQUAL */;
+  }
+  parseComparePoint() {
+    const token = this.peek();
+    const operator = this.getCompareOp(token);
+    this.advance();
+    const value = this.parseExpression(BP.DICE_LEFT);
+    return { operator, value };
+  }
+  getCompareOp(token) {
+    switch (token.type) {
+      case 10 /* GREATER */:
+        return ">";
+      case 11 /* GREATER_EQUAL */:
+        return ">=";
+      case 12 /* LESS */:
+        return "<";
+      case 13 /* LESS_EQUAL */:
+        return "<=";
+      case 14 /* EQUAL */:
+        return "=";
+      default:
+        throw new ParseError(`Expected comparison operator but got '${token.value}'`, "EXPECTED_TOKEN", token.position, token);
+    }
+  }
+  getOperatorSymbol(token) {
+    switch (token.type) {
+      case 4 /* PLUS */:
+        return "+";
+      case 5 /* MINUS */:
+        return "-";
+      case 6 /* MULTIPLY */:
+        return "*";
+      case 7 /* DIVIDE */:
+        return "/";
+      case 8 /* MODULO */:
+        return "%";
+      case 9 /* POWER */:
+        return "**";
+      default:
+        throw new ParseError(`Unknown operator '${token.value}'`, "UNEXPECTED_TOKEN", token.position, token);
+    }
+  }
+  getLeftBp(token) {
+    switch (token.type) {
+      case 29 /* VS */:
+        return BP.VS_LEFT;
+      case 4 /* PLUS */:
+      case 5 /* MINUS */:
+        return BP.ADD_LEFT;
+      case 6 /* MULTIPLY */:
+      case 7 /* DIVIDE */:
+      case 8 /* MODULO */:
+        return BP.MUL_LEFT;
+      case 9 /* POWER */:
+        return BP.POW_LEFT;
+      case 1 /* DICE */:
+      case 2 /* DICE_PERCENT */:
+      case 3 /* DICE_FATE */:
+        return BP.DICE_LEFT;
+      case 18 /* KEEP_HIGH */:
+      case 19 /* KEEP_LOW */:
+      case 20 /* DROP_HIGH */:
+      case 21 /* DROP_LOW */:
+      case 22 /* EXPLODE */:
+      case 23 /* EXPLODE_COMPOUND */:
+      case 24 /* EXPLODE_PENETRATING */:
+      case 25 /* REROLL */:
+      case 26 /* REROLL_ONCE */:
+      case 10 /* GREATER */:
+      case 11 /* GREATER_EQUAL */:
+      case 12 /* LESS */:
+      case 13 /* LESS_EQUAL */:
+      case 14 /* EQUAL */:
+        return BP.MODIFIER;
+      case 16 /* RPAREN */:
+      case 30 /* EOF */:
+      case 17 /* COMMA */:
+      case 28 /* FUNCTION */:
+        return -1;
+      default:
+        return 0;
+    }
+  }
+  getRightBp(token) {
+    switch (token.type) {
+      case 29 /* VS */:
+        return BP.VS_RIGHT;
+      case 4 /* PLUS */:
+      case 5 /* MINUS */:
+        return BP.ADD_RIGHT;
+      case 6 /* MULTIPLY */:
+      case 7 /* DIVIDE */:
+      case 8 /* MODULO */:
+        return BP.MUL_RIGHT;
+      case 9 /* POWER */:
+        return BP.POW_RIGHT;
+      case 1 /* DICE */:
+        return BP.DICE_RIGHT;
+      default:
+        return 0;
+    }
+  }
+  peek() {
+    return this.tokens[this.pos] ?? { type: 30 /* EOF */, value: "", position: this.pos };
+  }
+  advance() {
+    const token = this.peek();
+    this.pos++;
+    return token;
+  }
+  expect(type) {
+    const token = this.peek();
+    if (token.type !== type) {
+      const expected = TokenType[type];
+      throw new ParseError(`Expected ${expected} but got '${token.value}'`, "EXPECTED_TOKEN", token.position, token);
+    }
+    return this.advance();
+  }
+  hasTokens() {
+    return this.peek().type !== 30 /* EOF */;
+  }
+}
+function parse(notation) {
+  const tokens = lex(notation);
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+// src/rng/seeded.ts
+class SeededRNG {
+  s0;
+  s1;
+  s2;
+  s3;
+  constructor(seed) {
+    this.s0 = 0;
+    this.s1 = 0;
+    this.s2 = 0;
+    this.s3 = 0;
+    this.initState(seed);
+    for (let i = 0;i < 20; i++) {
+      this.nextUint32();
+    }
+  }
+  initState(seed) {
+    const numSeed = seed == null ? (Date.now() ^ Math.random() * 4294967295) >>> 0 : typeof seed === "string" ? this.hashString(seed) : seed >>> 0;
+    let s = numSeed;
+    const state = [];
+    for (let i = 0;i < 4; i++) {
+      s = s + 2654435769 >>> 0;
+      let z = s;
+      z = Math.imul(z ^ z >>> 16, 2246822507) >>> 0;
+      z = Math.imul(z ^ z >>> 13, 3266489909) >>> 0;
+      state.push((z ^ z >>> 16) >>> 0);
+    }
+    this.s0 = state[0] ?? 0;
+    this.s1 = state[1] ?? 0;
+    this.s2 = state[2] ?? 0;
+    this.s3 = state[3] ?? 0;
+    if (this.s0 === 0 && this.s1 === 0 && this.s2 === 0 && this.s3 === 0) {
+      this.s0 = 1;
+    }
+  }
+  hashString(str) {
+    let hash = 5381;
+    for (let i = 0;i < str.length; i++) {
+      hash = (hash << 5) + hash + str.charCodeAt(i) >>> 0;
+    }
+    return hash;
+  }
+  nextUint32() {
+    let t = this.s3;
+    const s = this.s0;
+    this.s3 = this.s2;
+    this.s2 = this.s1;
+    this.s1 = s;
+    t ^= t << 11;
+    t ^= t >>> 8;
+    this.s0 = (t ^ s ^ s >>> 19) >>> 0;
+    return this.s0;
+  }
+  next() {
+    return this.nextUint32() / 4294967296;
+  }
+  nextInt(min, max) {
+    const lo = min > max ? max : min;
+    const hi = min > max ? min : max;
+    const range = hi - lo + 1;
+    if (range <= 1) {
+      return lo;
+    }
+    const threshold = (4294967296 - range) % range;
+    let value;
+    do {
+      value = this.nextUint32();
+    } while (value < threshold);
+    return lo + value % range;
+  }
+}
+// src/types.ts
+var DegreeOfSuccess;
+((DegreeOfSuccess2) => {
+  DegreeOfSuccess2[DegreeOfSuccess2["CriticalFailure"] = 0] = "CriticalFailure";
+  DegreeOfSuccess2[DegreeOfSuccess2["Failure"] = 1] = "Failure";
+  DegreeOfSuccess2[DegreeOfSuccess2["Success"] = 2] = "Success";
+  DegreeOfSuccess2[DegreeOfSuccess2["CriticalSuccess"] = 3] = "CriticalSuccess";
+})(DegreeOfSuccess ||= {});
+
+// src/evaluator/modifiers/explode.ts
+var DEFAULT_MAX_EXPLODE_ITERATIONS = 1000;
+function buildShouldExplode(operator, thresholdValue) {
+  if (operator == null || thresholdValue == null) {
+    return (result, sides) => result === sides;
+  }
+  switch (operator) {
+    case ">":
+      return (result) => result > thresholdValue;
+    case ">=":
+      return (result) => result >= thresholdValue;
+    case "<":
+      return (result) => result < thresholdValue;
+    case "<=":
+      return (result) => result <= thresholdValue;
+    case "=":
+      return (result) => result === thresholdValue;
+  }
+}
+function rollExplosion(sides, rng, env) {
+  if (env.totalDiceRolled + 1 > env.maxDice) {
+    throw new EvaluatorError(`Total dice count ${env.totalDiceRolled + 1} exceeds limit of ${env.maxDice}`, "DICE_LIMIT_EXCEEDED", "Explode");
+  }
+  env.totalDiceRolled += 1;
+  return rng.nextInt(1, sides);
+}
+function explodeLimitError(maxIterations) {
+  return new EvaluatorError(`Explode iteration limit of ${maxIterations} exceeded`, "EXPLODE_LIMIT_EXCEEDED", "Explode");
+}
+function canExplode(die) {
+  if (die.modifiers.includes("dropped"))
+    return false;
+  if (die.sides < 1)
+    return false;
+  return true;
+}
+function applyStandardExplode(pool, shouldExplode, rng, env) {
+  const result = [];
+  for (const original of pool) {
+    result.push(original);
+    if (!canExplode(original))
+      continue;
+    const sides = original.sides;
+    let last = original.result;
+    let iterations = 0;
+    while (shouldExplode(last, sides)) {
+      if (iterations >= env.maxExplodeIterations) {
+        throw explodeLimitError(env.maxExplodeIterations);
+      }
+      const next = rollExplosion(sides, rng, env);
+      result.push({
+        sides,
+        result: next,
+        modifiers: ["exploded", "kept"],
+        critical: next === sides && sides > 1,
+        fumble: next === 1
+      });
+      last = next;
+      iterations += 1;
+    }
+  }
+  return result;
+}
+function applyCompoundExplode(pool, shouldExplode, rng, env) {
+  return pool.map((original) => {
+    if (!canExplode(original))
+      return original;
+    const sides = original.sides;
+    let accumulated = original.result;
+    let last = original.result;
+    let iterations = 0;
+    let exploded = false;
+    while (shouldExplode(last, sides)) {
+      if (iterations >= env.maxExplodeIterations) {
+        throw explodeLimitError(env.maxExplodeIterations);
+      }
+      const next = rollExplosion(sides, rng, env);
+      accumulated += next;
+      last = next;
+      exploded = true;
+      iterations += 1;
+    }
+    if (!exploded)
+      return original;
+    return {
+      sides,
+      result: accumulated,
+      modifiers: original.modifiers.includes("exploded") ? original.modifiers : [...original.modifiers, "exploded"],
+      critical: original.critical,
+      fumble: original.fumble
+    };
+  });
+}
+function applyPenetratingExplode(pool, shouldExplode, rng, env) {
+  const result = [];
+  for (const original of pool) {
+    result.push(original);
+    if (!canExplode(original))
+      continue;
+    const sides = original.sides;
+    let lastRaw = original.result;
+    let iterations = 0;
+    while (shouldExplode(lastRaw, sides)) {
+      if (iterations >= env.maxExplodeIterations) {
+        throw explodeLimitError(env.maxExplodeIterations);
+      }
+      const raw = rollExplosion(sides, rng, env);
+      const stored = raw - 1;
+      result.push({
+        sides,
+        result: stored,
+        modifiers: ["exploded", "kept"],
+        critical: raw === sides && sides > 1,
+        fumble: raw === 1
+      });
+      lastRaw = raw;
+      iterations += 1;
+    }
+  }
+  return result;
+}
+
+// src/evaluator/modifiers/keep-drop.ts
+function markAllKept(dice) {
+  return dice.map((die) => {
+    if (die.modifiers.includes("dropped"))
+      return die;
+    return {
+      ...die,
+      modifiers: die.modifiers.includes("kept") ? die.modifiers : [...die.modifiers, "kept"]
+    };
+  });
+}
+function eligibleIndexed(dice) {
+  return dice.map((die, index) => ({ die, index })).filter(({ die }) => !die.modifiers.includes("dropped"));
+}
+function applySelection(dice, selectionIndices, selectionMarker) {
+  const otherMarker = selectionMarker === "kept" ? "dropped" : "kept";
+  return dice.map((die, index) => {
+    if (die.modifiers.includes("dropped"))
+      return die;
+    const isSelected = selectionIndices.has(index);
+    const marker = isSelected ? selectionMarker : otherMarker;
+    return {
+      ...die,
+      modifiers: [...die.modifiers.filter((m) => m !== "kept" && m !== "dropped"), marker]
+    };
+  });
+}
+function markAllDropped(dice) {
+  return dice.map((die) => {
+    if (die.modifiers.includes("dropped"))
+      return die;
+    return {
+      ...die,
+      modifiers: [...die.modifiers.filter((m) => m !== "kept"), "dropped"]
+    };
+  });
+}
+function applyKeepHighest(dice, count) {
+  const eligible = eligibleIndexed(dice);
+  if (count >= eligible.length)
+    return markAllKept(dice);
+  if (count <= 0)
+    return markAllDropped(dice);
+  const sorted = [...eligible].sort((a, b) => b.die.result - a.die.result);
+  const keptIndices = new Set(sorted.slice(0, count).map((item) => item.index));
+  return applySelection(dice, keptIndices, "kept");
+}
+function applyKeepLowest(dice, count) {
+  const eligible = eligibleIndexed(dice);
+  if (count >= eligible.length)
+    return markAllKept(dice);
+  if (count <= 0)
+    return markAllDropped(dice);
+  const sorted = [...eligible].sort((a, b) => a.die.result - b.die.result);
+  const keptIndices = new Set(sorted.slice(0, count).map((item) => item.index));
+  return applySelection(dice, keptIndices, "kept");
+}
+function applyDropHighest(dice, count) {
+  const eligible = eligibleIndexed(dice);
+  if (count <= 0)
+    return markAllKept(dice);
+  if (count >= eligible.length)
+    return markAllDropped(dice);
+  const sorted = [...eligible].sort((a, b) => b.die.result - a.die.result);
+  const droppedIndices = new Set(sorted.slice(0, count).map((item) => item.index));
+  return applySelection(dice, droppedIndices, "dropped");
+}
+function applyDropLowest(dice, count) {
+  const eligible = eligibleIndexed(dice);
+  if (count <= 0)
+    return markAllKept(dice);
+  if (count >= eligible.length)
+    return markAllDropped(dice);
+  const sorted = [...eligible].sort((a, b) => a.die.result - b.die.result);
+  const droppedIndices = new Set(sorted.slice(0, count).map((item) => item.index));
+  return applySelection(dice, droppedIndices, "dropped");
+}
+function sumKeptDice(dice) {
+  return dice.filter((die) => !die.modifiers.includes("dropped")).reduce((sum, die) => sum + die.result, 0);
+}
+
+// src/evaluator/modifiers/compare.ts
+function matchesCondition(result, operator, value) {
+  switch (operator) {
+    case ">":
+      return result > value;
+    case ">=":
+      return result >= value;
+    case "<":
+      return result < value;
+    case "<=":
+      return result <= value;
+    case "=":
+      return result === value;
+  }
+}
+
+// src/evaluator/modifiers/reroll.ts
+var DEFAULT_MAX_REROLL_ITERATIONS = 1000;
+function rollReplacement(sides, rng, env) {
+  if (env.totalDiceRolled + 1 > env.maxDice) {
+    throw new EvaluatorError(`Total dice count ${env.totalDiceRolled + 1} exceeds limit of ${env.maxDice}`, "DICE_LIMIT_EXCEEDED", "Reroll");
+  }
+  env.totalDiceRolled += 1;
+  if (sides === 0) {
+    const result2 = rng.nextInt(-1, 1);
+    return {
+      sides: 0,
+      result: result2,
+      modifiers: [],
+      critical: false,
+      fumble: false
+    };
+  }
+  const result = rng.nextInt(1, sides);
+  return {
+    sides,
+    result,
+    modifiers: [],
+    critical: result === sides && sides > 1,
+    fumble: result === 1
+  };
+}
+function rerollLimitError(maxIterations) {
+  return new EvaluatorError(`Reroll iteration limit of ${maxIterations} exceeded`, "REROLL_LIMIT_EXCEEDED", "Reroll");
+}
+function canReroll(die) {
+  return !die.modifiers.includes("dropped");
+}
+function stripSlotFlags(modifiers) {
+  return modifiers.filter((m) => m !== "kept" && m !== "dropped" && m !== "rerolled");
+}
+function applyRecursiveReroll(pool, operator, value, rng, env) {
+  const result = [];
+  for (const original of pool) {
+    if (!canReroll(original)) {
+      result.push(original);
+      continue;
+    }
+    let current = original;
+    let iterations = 0;
+    while (matchesCondition(current.result, operator, value)) {
+      if (iterations >= env.maxRerollIterations) {
+        throw rerollLimitError(env.maxRerollIterations);
+      }
+      result.push({
+        ...current,
+        modifiers: [...stripSlotFlags(current.modifiers), "rerolled", "dropped"]
+      });
+      current = rollReplacement(current.sides, rng, env);
+      iterations += 1;
+    }
+    result.push({
+      ...current,
+      modifiers: [...stripSlotFlags(current.modifiers), "kept"]
+    });
+  }
+  return result;
+}
+function applyRerollOnce(pool, operator, value, rng, env) {
+  const result = [];
+  for (const original of pool) {
+    if (!canReroll(original)) {
+      result.push(original);
+      continue;
+    }
+    if (!matchesCondition(original.result, operator, value)) {
+      result.push({
+        ...original,
+        modifiers: [...stripSlotFlags(original.modifiers), "kept"]
+      });
+      continue;
+    }
+    result.push({
+      ...original,
+      modifiers: [...stripSlotFlags(original.modifiers), "rerolled", "dropped"]
+    });
+    const replacement = rollReplacement(original.sides, rng, env);
+    result.push({
+      ...replacement,
+      modifiers: [...stripSlotFlags(replacement.modifiers), "kept"]
+    });
+  }
+  return result;
+}
+
+// src/evaluator/modifiers/success-count.ts
+function countSuccesses(dice, threshold, failThreshold) {
+  let successes = 0;
+  let failures = 0;
+  for (const die of dice) {
+    if (die.modifiers.includes("dropped"))
+      continue;
+    if (matchesCondition(die.result, threshold.operator, threshold.value)) {
+      die.modifiers.push("success");
+      successes += 1;
+      continue;
+    }
+    if (failThreshold != null && matchesCondition(die.result, failThreshold.operator, failThreshold.value)) {
+      die.modifiers.push("failure");
+      failures += 1;
+    }
+  }
+  return { total: successes - failures, successes, failures };
+}
+
+// src/evaluator/evaluator.ts
+class EvaluatorError extends RollParserError {
+  nodeType;
+  constructor(message, code, nodeType) {
+    super(message, code);
+    this.name = "EvaluatorError";
+    this.nodeType = nodeType ?? undefined;
+  }
+}
+var DEFAULT_MAX_DICE = 1e4;
+function createDieResult(sides, result) {
+  return {
+    sides,
+    result,
+    modifiers: [],
+    critical: result === sides && sides > 1,
+    fumble: result === 1
+  };
+}
+function createFateDieResult(result) {
+  return {
+    sides: 0,
+    result,
+    modifiers: [],
+    critical: false,
+    fumble: false
+  };
+}
+function renderDice(dice) {
+  const parts = dice.map((die) => {
+    if (die.modifiers.includes("dropped")) {
+      return `~~${die.result}~~`;
+    }
+    if (die.modifiers.includes("success")) {
+      return `**${die.result}**`;
+    }
+    if (die.modifiers.includes("failure")) {
+      return `__${die.result}__`;
+    }
+    return String(die.result);
+  });
+  return `[${parts.join(", ")}]`;
+}
+function evalNode(node, rng, ctx, env) {
+  switch (node.type) {
+    case "Literal":
+      return evalLiteral(node.value, ctx);
+    case "Dice":
+      return evalDice(node, rng, ctx, env);
+    case "FateDice":
+      return evalFateDice(node, rng, ctx, env);
+    case "BinaryOp":
+      return evalBinaryOp(node, rng, ctx, env);
+    case "UnaryOp":
+      return evalUnaryOp(node, rng, ctx, env);
+    case "Modifier":
+      return evalModifier(node, rng, ctx, env);
+    case "Explode":
+      return evalExplode(node, rng, ctx, env);
+    case "Reroll":
+      return evalReroll(node, rng, ctx, env);
+    case "SuccessCount":
+      return evalSuccessCount(node, rng, ctx, env);
+    case "Versus":
+      return evalVersus(node, rng, ctx, env);
+    case "FunctionCall":
+      return evalFunctionCall(node, rng, ctx, env);
+    default: {
+      const exhaustive = node;
+      throw new EvaluatorError(`Unknown node type: ${exhaustive.type}`, "UNKNOWN_NODE_TYPE", exhaustive.type);
+    }
+  }
+}
+function evalLiteral(value, ctx) {
+  ctx.expressionParts.push(String(value));
+  ctx.renderedParts.push(String(value));
+  return value;
+}
+function evalDice(node, rng, ctx, env) {
+  const count = evalNode(node.count, rng, { rolls: [], expressionParts: [], renderedParts: [] }, env);
+  const sides = evalNode(node.sides, rng, { rolls: [], expressionParts: [], renderedParts: [] }, env);
+  if (!Number.isInteger(count) || count < 0) {
+    throw new EvaluatorError(`Invalid dice count: ${count}`, "INVALID_DICE_COUNT", "Dice");
+  }
+  if (!Number.isInteger(sides) || sides < 1) {
+    throw new EvaluatorError(`Invalid dice sides: ${sides}`, "INVALID_DICE_SIDES", "Dice");
+  }
+  if (env.totalDiceRolled + count > env.maxDice) {
+    throw new EvaluatorError(`Total dice count ${env.totalDiceRolled + count} exceeds limit of ${env.maxDice}`, "DICE_LIMIT_EXCEEDED", "Dice");
+  }
+  env.totalDiceRolled += count;
+  const dice = [];
+  for (let i = 0;i < count; i++) {
+    const result = rng.nextInt(1, sides);
+    dice.push(createDieResult(sides, result));
+  }
+  const markedDice = markAllKept(dice);
+  ctx.rolls.push(...markedDice);
+  const total = sumKeptDice(markedDice);
+  const notation = `${count}d${sides}`;
+  ctx.expressionParts.push(notation);
+  ctx.renderedParts.push(`${notation}${renderDice(markedDice)}`);
+  return total;
+}
+function evalFateDice(node, rng, ctx, env) {
+  const count = evalNode(node.count, rng, { rolls: [], expressionParts: [], renderedParts: [] }, env);
+  if (!Number.isInteger(count) || count < 0) {
+    throw new EvaluatorError(`Invalid dice count: ${count}`, "INVALID_DICE_COUNT", "FateDice");
+  }
+  if (env.totalDiceRolled + count > env.maxDice) {
+    throw new EvaluatorError(`Total dice count ${env.totalDiceRolled + count} exceeds limit of ${env.maxDice}`, "DICE_LIMIT_EXCEEDED", "FateDice");
+  }
+  env.totalDiceRolled += count;
+  const dice = [];
+  for (let i = 0;i < count; i++) {
+    const result = rng.nextInt(-1, 1);
+    dice.push(createFateDieResult(result));
+  }
+  const markedDice = markAllKept(dice);
+  ctx.rolls.push(...markedDice);
+  const total = sumKeptDice(markedDice);
+  const notation = `${count}dF`;
+  ctx.expressionParts.push(notation);
+  ctx.renderedParts.push(`${notation}${renderDice(markedDice)}`);
+  return total;
+}
+function evalBinaryOp(node, rng, ctx, env) {
+  const leftCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const rightCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const left = evalNode(node.left, rng, leftCtx, env);
+  const right = evalNode(node.right, rng, rightCtx, env);
+  ctx.rolls.push(...leftCtx.rolls, ...rightCtx.rolls);
+  const leftExpr = leftCtx.expressionParts.join("");
+  const rightExpr = rightCtx.expressionParts.join("");
+  const leftRendered = leftCtx.renderedParts.join("");
+  const rightRendered = rightCtx.renderedParts.join("");
+  ctx.expressionParts.push(`${leftExpr} ${node.operator} ${rightExpr}`);
+  ctx.renderedParts.push(`${leftRendered} ${node.operator} ${rightRendered}`);
+  switch (node.operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      if (right === 0) {
+        throw new EvaluatorError("Division by zero", "DIVISION_BY_ZERO", "BinaryOp");
+      }
+      return left / right;
+    case "%":
+      if (right === 0) {
+        throw new EvaluatorError("Modulo by zero", "MODULO_BY_ZERO", "BinaryOp");
+      }
+      return left % right;
+    case "**":
+      return left ** right;
+    default: {
+      const exhaustive = node.operator;
+      throw new EvaluatorError(`Unknown operator: ${exhaustive}`, "UNKNOWN_OPERATOR", "BinaryOp");
+    }
+  }
+}
+function evalUnaryOp(node, rng, ctx, env) {
+  const innerCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const value = evalNode(node.operand, rng, innerCtx, env);
+  ctx.rolls.push(...innerCtx.rolls);
+  const innerExpr = innerCtx.expressionParts.join("");
+  const innerRendered = innerCtx.renderedParts.join("");
+  ctx.expressionParts.push(`-${innerExpr}`);
+  ctx.renderedParts.push(`-${innerRendered}`);
+  return -value;
+}
+function evalFunctionCall(node, rng, ctx, env) {
+  const argCtxs = [];
+  const values = [];
+  for (const arg of node.args) {
+    const argCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    values.push(evalNode(arg, rng, argCtx, env));
+    argCtxs.push(argCtx);
+  }
+  for (const argCtx of argCtxs) {
+    ctx.rolls.push(...argCtx.rolls);
+  }
+  const argExprs = argCtxs.map((c) => c.expressionParts.join(""));
+  const argRendereds = argCtxs.map((c) => c.renderedParts.join(""));
+  ctx.expressionParts.push(`${node.name}(${argExprs.join(", ")})`);
+  ctx.renderedParts.push(`${node.name}(${argRendereds.join(", ")})`);
+  return applyFunction(node.name, values);
+}
+function applyFunction(name, values) {
+  switch (name) {
+    case "floor":
+      return Math.floor(requireUnaryArg(name, values));
+    case "ceil":
+      return Math.ceil(requireUnaryArg(name, values));
+    case "round":
+      return Math.round(requireUnaryArg(name, values));
+    case "abs":
+      return Math.abs(requireUnaryArg(name, values));
+    case "max":
+      return Math.max(...values);
+    case "min":
+      return Math.min(...values);
+    default:
+      throw new EvaluatorError(`Unknown function: ${name}`, "UNKNOWN_FUNCTION", "FunctionCall");
+  }
+}
+function requireUnaryArg(name, values) {
+  const [x] = values;
+  if (x === undefined) {
+    throw new EvaluatorError(`Function '${name}' requires an argument`, "UNKNOWN_FUNCTION", "FunctionCall");
+  }
+  return x;
+}
+function flattenModifierChain(node, rng, env) {
+  const specs = [];
+  let current = node;
+  while (isModifier(current)) {
+    const countCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const modCount = evalNode(current.count, rng, countCtx, env);
+    if (!Number.isInteger(modCount) || modCount < 0) {
+      throw new EvaluatorError(`Invalid modifier count: ${modCount}`, "INVALID_MODIFIER_COUNT", "Modifier");
+    }
+    const code = current.modifier === "keep" ? current.selector === "highest" ? "kh" : "kl" : current.selector === "highest" ? "dh" : "dl";
+    specs.push({ modifier: current.modifier, selector: current.selector, count: modCount, code });
+    current = current.target;
+  }
+  specs.reverse();
+  return { specs, baseTarget: current };
+}
+function applyModifierSpec(dice, spec) {
+  if (spec.modifier === "keep") {
+    return spec.selector === "highest" ? applyKeepHighest(dice, spec.count) : applyKeepLowest(dice, spec.count);
+  }
+  return spec.selector === "highest" ? applyDropHighest(dice, spec.count) : applyDropLowest(dice, spec.count);
+}
+function mergeDropSets(baseDice, specs) {
+  const droppedIndices = new Set;
+  for (const spec of specs) {
+    const result = applyModifierSpec(baseDice, spec);
+    for (let i = 0;i < result.length; i++) {
+      if (result[i]?.modifiers.includes("dropped")) {
+        droppedIndices.add(i);
+      }
+    }
+  }
+  return baseDice.map((die, index) => ({
+    ...die,
+    modifiers: droppedIndices.has(index) ? [...die.modifiers.filter((m) => m !== "kept" && m !== "dropped"), "dropped"] : [...die.modifiers.filter((m) => m !== "dropped" && m !== "kept"), "kept"]
+  }));
+}
+function formatExplodeCode(variant, threshold, thresholdValue) {
+  const marker = variant === "standard" ? "!" : variant === "compound" ? "!!" : "!p";
+  if (threshold == null || thresholdValue == null)
+    return marker;
+  return `${marker}${threshold.operator}${thresholdValue}`;
+}
+function evalExplode(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const targetValue = evalNode(node.target, rng, targetCtx, env);
+  const targetExpr = targetCtx.expressionParts.join("");
+  let thresholdValue;
+  if (node.threshold != null) {
+    const thresholdCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    thresholdValue = evalNode(node.threshold.value, rng, thresholdCtx, env);
+  }
+  const code = formatExplodeCode(node.variant, node.threshold, thresholdValue);
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    return targetValue;
+  }
+  const shouldExplode = buildShouldExplode(node.threshold?.operator, thresholdValue);
+  const expanded = node.variant === "standard" ? applyStandardExplode(targetCtx.rolls, shouldExplode, rng, env) : node.variant === "compound" ? applyCompoundExplode(targetCtx.rolls, shouldExplode, rng, env) : applyPenetratingExplode(targetCtx.rolls, shouldExplode, rng, env);
+  ctx.rolls.push(...expanded);
+  ctx.expressionParts.push(`${targetExpr}${code}`);
+  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(expanded)}`);
+  return sumKeptDice(expanded);
+}
+function evalReroll(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  evalNode(node.target, rng, targetCtx, env);
+  const targetExpr = targetCtx.expressionParts.join("");
+  const thresholdCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const thresholdValue = evalNode(node.condition.value, rng, thresholdCtx, env);
+  const code = `${node.once ? "ro" : "r"}${node.condition.operator}${thresholdValue}`;
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    return sumKeptDice(targetCtx.rolls);
+  }
+  const pool = node.once ? applyRerollOnce(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env) : applyRecursiveReroll(targetCtx.rolls, node.condition.operator, thresholdValue, rng, env);
+  ctx.rolls.push(...pool);
+  ctx.expressionParts.push(`${targetExpr}${code}`);
+  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(pool)}`);
+  return sumKeptDice(pool);
+}
+function evalModifier(node, rng, ctx, env) {
+  const { specs, baseTarget } = flattenModifierChain(node, rng, env);
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  evalNode(baseTarget, rng, targetCtx, env);
+  const mergedDice = mergeDropSets(targetCtx.rolls, specs);
+  ctx.rolls.push(...mergedDice);
+  const total = sumKeptDice(mergedDice);
+  const targetExpr = targetCtx.expressionParts.join("");
+  const modifierCodes = specs.map((s) => `${s.code}${s.count}`).join("");
+  ctx.expressionParts.push(`${targetExpr}${modifierCodes}`);
+  ctx.renderedParts.push(`${targetExpr}${renderDice(mergedDice)}`);
+  return total;
+}
+function resolveThreshold(value, rng, env, role) {
+  const thresholdCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const resolved = evalNode(value, rng, thresholdCtx, env);
+  if (!Number.isFinite(resolved)) {
+    throw new EvaluatorError(`Invalid ${role}: ${resolved}`, "INVALID_THRESHOLD", "SuccessCount");
+  }
+  return resolved;
+}
+function evalSuccessCount(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const targetValue = evalNode(node.target, rng, targetCtx, env);
+  const targetExpr = targetCtx.expressionParts.join("");
+  const thresholdValue = resolveThreshold(node.threshold.value, rng, env, "threshold");
+  const failValue = node.failThreshold != null ? resolveThreshold(node.failThreshold.value, rng, env, "fail threshold") : undefined;
+  const code = `${node.threshold.operator}${thresholdValue}${failValue != null ? `f${failValue}` : ""}`;
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    return targetValue;
+  }
+  const result = countSuccesses(targetCtx.rolls, { operator: node.threshold.operator, value: thresholdValue }, failValue != null && node.failThreshold != null ? { operator: node.failThreshold.operator, value: failValue } : undefined);
+  env.hasSuccessCount = true;
+  ctx.rolls.push(...targetCtx.rolls);
+  ctx.expressionParts.push(`${targetExpr}${code}`);
+  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+  return result.total;
+}
+function extractNatural(rolls) {
+  const keptD20s = rolls.filter((d) => d.sides === 20 && !d.modifiers.includes("dropped") && !d.modifiers.includes("rerolled"));
+  return keptD20s.length === 1 ? keptD20s[0]?.result : undefined;
+}
+function calculateDegree(total, dc, natural) {
+  let degree;
+  if (total >= dc + 10)
+    degree = 3 /* CriticalSuccess */;
+  else if (total >= dc)
+    degree = 2 /* Success */;
+  else if (total > dc - 10)
+    degree = 1 /* Failure */;
+  else
+    degree = 0 /* CriticalFailure */;
+  if (natural === 20 && degree < 3 /* CriticalSuccess */)
+    degree++;
+  if (natural === 1 && degree > 0 /* CriticalFailure */)
+    degree--;
+  return degree;
+}
+function degreeLabel(degree) {
+  switch (degree) {
+    case 0 /* CriticalFailure */:
+      return "Critical Failure";
+    case 1 /* Failure */:
+      return "Failure";
+    case 2 /* Success */:
+      return "Success";
+    case 3 /* CriticalSuccess */:
+      return "Critical Success";
+  }
+}
+function evalVersus(node, rng, ctx, env) {
+  if (env.insideVersus) {
+    throw new EvaluatorError("Cannot nest versus operators", "NESTED_VERSUS", "Versus");
+  }
+  env.insideVersus = true;
+  try {
+    const rollCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const rollTotal = evalNode(node.roll, rng, rollCtx, env);
+    const natural = extractNatural(rollCtx.rolls);
+    const dcCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const dcTotal = evalNode(node.dc, rng, dcCtx, env);
+    const degree = calculateDegree(rollTotal, dcTotal, natural);
+    ctx.rolls.push(...rollCtx.rolls, ...dcCtx.rolls);
+    const rollExpr = rollCtx.expressionParts.join("");
+    const dcExpr = dcCtx.expressionParts.join("");
+    const rollRendered = rollCtx.renderedParts.join("");
+    const dcRendered = dcCtx.renderedParts.join("");
+    ctx.expressionParts.push(`${rollExpr} vs ${dcExpr}`);
+    ctx.renderedParts.push(`${rollRendered} vs ${dcRendered}`);
+    ctx.versusMetadata = { degree, natural, dcTotal };
+    return rollTotal;
+  } finally {
+    env.insideVersus = false;
+  }
+}
+function evaluate(ast, rng, options = {}) {
+  const maxDice = options.maxDice != null && Number.isFinite(options.maxDice) && options.maxDice > 0 ? Math.floor(options.maxDice) : DEFAULT_MAX_DICE;
+  const maxExplodeIterations = options.maxExplodeIterations != null && Number.isFinite(options.maxExplodeIterations) && options.maxExplodeIterations >= 0 ? Math.floor(options.maxExplodeIterations) : DEFAULT_MAX_EXPLODE_ITERATIONS;
+  const maxRerollIterations = options.maxRerollIterations != null && Number.isFinite(options.maxRerollIterations) && options.maxRerollIterations >= 0 ? Math.floor(options.maxRerollIterations) : DEFAULT_MAX_REROLL_ITERATIONS;
+  const env = {
+    maxDice,
+    maxExplodeIterations,
+    maxRerollIterations,
+    totalDiceRolled: 0,
+    hasSuccessCount: false,
+    insideVersus: false
+  };
+  const ctx = {
+    rolls: [],
+    expressionParts: [],
+    renderedParts: []
+  };
+  const total = evalNode(ast, rng, ctx, env);
+  const expression = ctx.expressionParts.join("");
+  const trailing = ctx.versusMetadata ? degreeLabel(ctx.versusMetadata.degree) : String(total);
+  const rendered = `${ctx.renderedParts.join("")} = ${trailing}`;
+  const result = {
+    total,
+    notation: options.notation ?? expression,
+    expression,
+    rendered,
+    rolls: ctx.rolls
+  };
+  if (env.hasSuccessCount) {
+    let successes = 0;
+    let failures = 0;
+    for (const die of ctx.rolls) {
+      if (die.modifiers.includes("success"))
+        successes += 1;
+      else if (die.modifiers.includes("failure"))
+        failures += 1;
+    }
+    result.successes = successes;
+    result.failures = failures;
+  }
+  if (ctx.versusMetadata) {
+    result.degree = ctx.versusMetadata.degree;
+    if (ctx.versusMetadata.natural !== undefined) {
+      result.natural = ctx.versusMetadata.natural;
+    }
+  }
+  return result;
+}
+// src/roll.ts
+function roll(notation, options = {}) {
+  const rng = options.rng ?? new SeededRNG(options.seed);
+  const tokens = lex(notation);
+  const ast = new Parser(tokens).parse();
+  const evalOptions = { notation };
+  if (options.maxDice != null)
+    evalOptions.maxDice = options.maxDice;
+  if (options.maxExplodeIterations != null) {
+    evalOptions.maxExplodeIterations = options.maxExplodeIterations;
+  }
+  if (options.maxRerollIterations != null) {
+    evalOptions.maxRerollIterations = options.maxRerollIterations;
+  }
+  return evaluate(ast, rng, evalOptions);
+}
+// package.json
+var package_default = {
+  name: "roll-parser",
+  version: "3.0.0-alpha.0",
+  description: "High-performance dice notation parser for tabletop RPGs. TypeScript-first, Bun-optimized.",
+  type: "module",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  bin: { "roll-parser": "./dist/cli.js" },
+  sideEffects: false,
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./testing": {
+      types: "./dist/testing.d.ts",
+      import: "./dist/testing.mjs",
+      require: "./dist/testing.js"
+    }
+  },
+  files: [
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  keywords: [
+    "parser",
+    "dice",
+    "roll",
+    "rpg",
+    "dnd",
+    "d20",
+    "pratt-parser",
+    "typescript",
+    "bun"
+  ],
+  homepage: "https://github.com/edloidas/roll-parser#readme",
+  bugs: {
+    url: "https://github.com/edloidas/roll-parser/issues"
+  },
+  license: "MIT",
+  author: "Mikita Taukachou <edloidas@gmail.com> (https://edloidas.com)",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/edloidas/roll-parser.git"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    typecheck: "tsc --noEmit",
+    lint: "biome lint .",
+    "lint:fix": "biome lint --write .",
+    format: "biome format --write .",
+    "format:check": "biome format .",
+    check: "bun typecheck && bun lint && bun format:check",
+    "check:fix": "bun typecheck && bun lint:fix && bun format",
+    "check:version": "bun scripts/check-version.ts",
+    "check:changelog": "bun scripts/check-changelog.ts",
+    clean: "rm -rf dist coverage",
+    build: "bun run clean && bun run build:esm && bun run build:cjs && bun run build:esm:testing && bun run build:cjs:testing && bun run build:cli && bun run build:types",
+    "build:esm": "bun build src/index.ts --outfile dist/index.mjs --target bun",
+    "build:cjs": "bun build src/index.ts --outfile dist/index.js --target node",
+    "build:esm:testing": "bun build src/testing.ts --outfile dist/testing.mjs --target bun",
+    "build:cjs:testing": "bun build src/testing.ts --outfile dist/testing.js --target node",
+    "build:cli": "bun build src/cli/index.ts --outfile dist/cli.js --target node",
+    "build:types": "tsc --emitDeclarationOnly -p tsconfig.build.json",
+    test: "bun test",
+    "test:node": `node -e "import('./dist/index.mjs').then(m => { const r = m.roll('1d6'); if (!(r.total >= 1 && r.total <= 6)) throw new Error('ESM smoke failed: total=' + r.total); console.log('Node.js ESM smoke: ok'); })" && node -e "const m = require('./dist/index.js'); const r = m.roll('1d6'); if (!(r.total >= 1 && r.total <= 6)) throw new Error('CJS smoke failed: total=' + r.total); console.log('Node.js CJS smoke: ok');"`,
+    "test:watch": "bun test --watch",
+    "test:ci": "bun test --bail",
+    validate: "bun run check && bun run build && bun test:ci",
+    coverage: "bun test --coverage",
+    "release:dry": "bun run check:version && bun run check:changelog && bun run check && bun run build && bun test",
+    prepublishOnly: "bun run release:dry"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.9",
+    "@types/bun": "^1.3.0",
+    "fast-check": "^4.6.0",
+    typescript: "^6.0.2"
+  },
+  engines: {
+    node: ">= 22.0.0"
+  }
+};
+
+// src/index.ts
+var VERSION = package_default.version;
+export {
+  roll,
+  parse,
+  isVersus,
+  isUnaryOp,
+  isSuccessCount,
+  isRollParserError,
+  isReroll,
+  isModifier,
+  isLiteral,
+  isFunctionCall,
+  isFateDice,
+  isExplode,
+  isDice,
+  isBinaryOp,
+  evaluate,
+  VERSION,
+  SeededRNG,
+  RollParserError,
+  ParseError,
+  LexerError,
+  EvaluatorError,
+  DegreeOfSuccess,
+  DEFAULT_MAX_REROLL_ITERATIONS,
+  DEFAULT_MAX_EXPLODE_ITERATIONS,
+  DEFAULT_MAX_DICE
+};