roll-parser 2.3.2 → 3.0.0-beta.0

package/dist/cli.js

@@ -0,0 +1,2608 @@
+#!/usr/bin/env node
+
+// 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",
+  "INVALID_MODIFIER_TARGET",
+  "EXPLODE_LIMIT_EXCEEDED",
+  "INVALID_EXPLODE_TARGET",
+  "REROLL_LIMIT_EXCEEDED",
+  "INVALID_REROLL_TARGET",
+  "INVALID_SUCCESS_COUNT_TARGET",
+  "INVALID_SORT_TARGET",
+  "INVALID_CRIT_THRESHOLD_TARGET",
+  "INVALID_THRESHOLD",
+  "NESTED_VERSUS",
+  "INVALID_FUNCTION_ARITY",
+  "UNKNOWN_FUNCTION",
+  "UNDEFINED_VARIABLE",
+  "INVALID_VARIABLE_VALUE",
+  "AMBIGUOUS_DICE_CHAIN",
+  "MAX_DEPTH_EXCEEDED",
+  "NON_FINITE_RESULT"
+];
+
+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["LBRACE"] = 30] = "LBRACE";
+  TokenType2[TokenType2["RBRACE"] = 31] = "RBRACE";
+  TokenType2[TokenType2["AT"] = 32] = "AT";
+  TokenType2[TokenType2["SORT_ASC"] = 33] = "SORT_ASC";
+  TokenType2[TokenType2["SORT_DESC"] = 34] = "SORT_DESC";
+  TokenType2[TokenType2["CRIT_SUCCESS"] = 35] = "CRIT_SUCCESS";
+  TokenType2[TokenType2["CRIT_FAIL"] = 36] = "CRIT_FAIL";
+  TokenType2[TokenType2["EOF"] = 37] = "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 */,
+  s: 33 /* SORT_ASC */,
+  sa: 33 /* SORT_ASC */,
+  sd: 34 /* SORT_DESC */,
+  cs: 35 /* CRIT_SUCCESS */,
+  cf: 36 /* CRIT_FAIL */
+};
+function buildIdentifierHint(identifier) {
+  for (let length = identifier.length - 1;length >= 1; length--) {
+    const prefix = identifier.slice(0, length);
+    if (IDENTIFIER_KEYWORDS[prefix] == null)
+      continue;
+    const rest = identifier.slice(length);
+    return ` (did you mean '${prefix}' followed by '${rest}'? separate modifiers with a count or space, e.g. '${prefix}1${rest}')`;
+  }
+  return "";
+}
+
+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 === 37 /* EOF */)
+        break;
+    }
+    return tokens;
+  }
+  nextToken() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      return this.createToken(37 /* EOF */, "");
+    }
+    const startPos = this.pos;
+    const char = this.peek();
+    if (this.isDigit(char)) {
+      return this.scanNumber();
+    }
+    if (this.isAlpha(char)) {
+      return this.scanIdentifier();
+    }
+    if (char === "@") {
+      return this.scanAt();
+    }
+    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 "{":
+        return this.createTokenAt(30 /* LBRACE */, char, startPos);
+      case "}":
+        return this.createTokenAt(31 /* RBRACE */, 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: {
+        const codePoint = this.input.codePointAt(startPos);
+        const display = codePoint == null ? char : String.fromCodePoint(codePoint);
+        throw new LexerError("Unexpected character", "UNEXPECTED_CHARACTER", startPos, display);
+      }
+    }
+  }
+  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${buildIdentifierHint(lower)}`, "UNEXPECTED_IDENTIFIER", startPos, lower);
+  }
+  scanAt() {
+    const startPos = this.pos;
+    this.advance();
+    let name;
+    if (!this.isAtEnd() && this.peek() === "{") {
+      this.advance();
+      const nameStart = this.pos;
+      while (!this.isAtEnd() && this.peek() !== "}" && this.peek() !== `
+`) {
+        this.advance();
+      }
+      if (this.isAtEnd() || this.peek() !== "}") {
+        throw new LexerError("Unterminated @{...} variable", "UNEXPECTED_CHARACTER", startPos, "@");
+      }
+      name = this.input.slice(nameStart, this.pos);
+      this.advance();
+    } else {
+      const nameStart = this.pos;
+      if (this.isAtEnd() || !this.isIdentifierStart(this.peek())) {
+        throw new LexerError("Empty @ variable name", "UNEXPECTED_CHARACTER", startPos, "@");
+      }
+      this.advance();
+      while (!this.isAtEnd() && this.isIdentifierPart(this.peek())) {
+        this.advance();
+      }
+      name = this.input.slice(nameStart, this.pos);
+    }
+    return this.createTokenAt(32 /* AT */, name, startPos);
+  }
+  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";
+  }
+  isIdentifierStart(char) {
+    return this.isAlpha(char) || char === "_";
+  }
+  isIdentifierPart(char) {
+    return this.isAlpha(char) || this.isDigit(char) || char === "_";
+  }
+  isWhitespace(char) {
+    return char === " " || char === "\t" || char === `
+` || char === "\r";
+  }
+  createToken(type, value) {
+    return { type, value, position: this.pos, end: this.pos };
+  }
+  createTokenAt(type, value, position) {
+    return { type, value, position, end: this.pos };
+  }
+}
+function lex(input) {
+  return new Lexer(input).tokenize();
+}
+
+// src/parser/ast.ts
+function isModifier(node) {
+  return node.type === "Modifier";
+}
+function isSuccessCount(node) {
+  return node.type === "SuccessCount";
+}
+function isCritThreshold(node) {
+  return node.type === "CritThreshold";
+}
+function unwrapTransparent(node, kinds) {
+  let current = node;
+  while (true) {
+    switch (current.type) {
+      case "Grouped":
+        if (!kinds.includes("Grouped"))
+          return current;
+        current = current.expression;
+        break;
+      case "Modifier":
+        if (!kinds.includes("Modifier"))
+          return current;
+        current = current.target;
+        break;
+      case "Sort":
+        if (!kinds.includes("Sort"))
+          return current;
+        current = current.target;
+        break;
+      case "CritThreshold":
+        if (!kinds.includes("CritThreshold"))
+          return current;
+        current = current.target;
+        break;
+      default:
+        return current;
+    }
+  }
+}
+function containsDicePool(node) {
+  switch (node.type) {
+    case "Dice":
+    case "FateDice":
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+      return true;
+    case "Sort":
+    case "CritThreshold":
+      return containsDicePool(node.target);
+    case "Grouped":
+      return containsDicePool(node.expression);
+    case "Group":
+      return node.expressions.length >= 2 || node.expressions.some(deepContainsDicePool);
+    default:
+      return false;
+  }
+}
+function deepContainsDicePool(node) {
+  switch (node.type) {
+    case "Dice":
+    case "FateDice":
+      return true;
+    case "BinaryOp":
+      return deepContainsDicePool(node.left) || deepContainsDicePool(node.right);
+    case "UnaryOp":
+      return deepContainsDicePool(node.operand);
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "SuccessCount":
+    case "Sort":
+    case "CritThreshold":
+      return deepContainsDicePool(node.target);
+    case "Versus":
+      return deepContainsDicePool(node.roll) || deepContainsDicePool(node.dc);
+    case "FunctionCall":
+      return node.args.some(deepContainsDicePool);
+    case "Grouped":
+      return deepContainsDicePool(node.expression);
+    case "Group":
+      return node.expressions.length >= 2 || node.expressions.some(deepContainsDicePool);
+    default:
+      return false;
+  }
+}
+function containsFatePool(node) {
+  switch (node.type) {
+    case "FateDice":
+      return true;
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "Sort":
+    case "CritThreshold":
+      return containsFatePool(node.target);
+    case "Grouped":
+      return containsFatePool(node.expression);
+    case "Group":
+      return node.expressions.some(deepContainsFatePool);
+    default:
+      return false;
+  }
+}
+function deepContainsFatePool(node) {
+  switch (node.type) {
+    case "FateDice":
+      return true;
+    case "BinaryOp":
+      return deepContainsFatePool(node.left) || deepContainsFatePool(node.right);
+    case "UnaryOp":
+      return deepContainsFatePool(node.operand);
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "SuccessCount":
+    case "Sort":
+    case "CritThreshold":
+      return deepContainsFatePool(node.target);
+    case "Versus":
+      return deepContainsFatePool(node.roll) || deepContainsFatePool(node.dc);
+    case "FunctionCall":
+      return node.args.some(deepContainsFatePool);
+    case "Grouped":
+      return deepContainsFatePool(node.expression);
+    case "Group":
+      return node.expressions.some(deepContainsFatePool);
+    default:
+      return false;
+  }
+}
+function containsMultiSubGroup(node) {
+  switch (node.type) {
+    case "Group":
+      return node.expressions.length >= 2 || node.expressions.some(containsMultiSubGroup);
+    case "BinaryOp":
+      return containsMultiSubGroup(node.left) || containsMultiSubGroup(node.right);
+    case "UnaryOp":
+      return containsMultiSubGroup(node.operand);
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "SuccessCount":
+    case "Sort":
+    case "CritThreshold":
+      return containsMultiSubGroup(node.target);
+    case "Versus":
+      return containsMultiSubGroup(node.roll) || containsMultiSubGroup(node.dc);
+    case "FunctionCall":
+      return node.args.some(containsMultiSubGroup);
+    case "Grouped":
+      return containsMultiSubGroup(node.expression);
+    default:
+      return false;
+  }
+}
+function containsVersus(node) {
+  switch (node.type) {
+    case "Versus":
+      return true;
+    case "BinaryOp":
+      return containsVersus(node.left) || containsVersus(node.right);
+    case "UnaryOp":
+      return containsVersus(node.operand);
+    case "Modifier":
+    case "Explode":
+    case "Reroll":
+    case "SuccessCount":
+    case "Sort":
+    case "CritThreshold":
+      return containsVersus(node.target);
+    case "FunctionCall":
+      return node.args.some(containsVersus);
+    case "Grouped":
+      return containsVersus(node.expression);
+    case "Group":
+      return node.expressions.some(containsVersus);
+    default:
+      return false;
+  }
+}
+
+// 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,
+  COMPARE: 8,
+  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 MAX_PARSE_DEPTH = 128;
+var TOKEN_DISPLAY = {
+  [15 /* LPAREN */]: `'('`,
+  [16 /* RPAREN */]: `')'`,
+  [30 /* LBRACE */]: `'{'`,
+  [31 /* RBRACE */]: `'}'`,
+  [17 /* COMMA */]: `','`
+};
+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;
+  depth = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  parse() {
+    if (this.peek().type === 37 /* EOF */) {
+      throw new ParseError("Unexpected end of input", "UNEXPECTED_END", this.peek().position);
+    }
+    const ast = this.parseExpression(0);
+    if (this.peek().type !== 37 /* EOF */) {
+      const token = this.peek();
+      throw new ParseError(`Unexpected token '${token.value}'`, "UNEXPECTED_TOKEN", token.position, token);
+    }
+    return ast;
+  }
+  parseExpression(minBp) {
+    this.depth += 1;
+    if (this.depth > MAX_PARSE_DEPTH) {
+      throw new ParseError(`Expression nesting exceeds the maximum depth of ${MAX_PARSE_DEPTH}`, "MAX_DEPTH_EXCEEDED", this.peek().position, this.peek());
+    }
+    try {
+      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;
+    } finally {
+      this.depth -= 1;
+    }
+  }
+  parseNud() {
+    const token = this.advance();
+    switch (token.type) {
+      case 0 /* NUMBER */:
+        return this.parseLiteral(token);
+      case 5 /* MINUS */:
+        return this.parseUnaryMinus(token);
+      case 1 /* DICE */:
+        return this.parsePrefixDice(token);
+      case 2 /* DICE_PERCENT */:
+        return this.parsePrefixDicePercent(token);
+      case 3 /* DICE_FATE */:
+        return this.parsePrefixFateDice(token);
+      case 15 /* LPAREN */:
+        return this.parseGrouped(token);
+      case 30 /* LBRACE */:
+        return this.parseGroup(token);
+      case 28 /* FUNCTION */:
+        return this.parseFunctionCall(token);
+      case 32 /* AT */:
+        return this.parseVariable(token);
+      case 37 /* 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, token);
+      case 2 /* DICE_PERCENT */:
+        return this.parseInfixDicePercent(left, token);
+      case 3 /* DICE_FATE */:
+        return this.parseInfixFateDice(left, token);
+      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 33 /* SORT_ASC */:
+      case 34 /* SORT_DESC */:
+        return this.parseSort(left, token);
+      case 35 /* CRIT_SUCCESS */:
+      case 36 /* CRIT_FAIL */:
+        return this.parseCritThreshold(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);
+    }
+  }
+  static syntheticLiteral(value, token) {
+    return { type: "Literal", value, start: token.position, end: token.position };
+  }
+  parseLiteral(token) {
+    return {
+      type: "Literal",
+      value: Number.parseFloat(token.value),
+      start: token.position,
+      end: token.end
+    };
+  }
+  parseUnaryMinus(token) {
+    const operand = this.parseExpression(BP.UNARY);
+    this.rejectSuccessCountTarget(operand, token);
+    return {
+      type: "UnaryOp",
+      operator: "-",
+      operand,
+      start: token.position,
+      end: operand.end ?? token.end
+    };
+  }
+  parsePrefixDice(token) {
+    const sides = this.parseExpression(BP.DICE_RIGHT);
+    this.rejectSuccessCountTarget(sides, token);
+    this.rejectVersusTarget(sides, token);
+    return {
+      type: "Dice",
+      count: Parser.syntheticLiteral(1, token),
+      sides,
+      start: token.position,
+      end: sides.end ?? token.end
+    };
+  }
+  parseInfixDice(left, token) {
+    this.rejectSuccessCountTarget(left, token);
+    this.rejectVersusTarget(left, token);
+    this.rejectBareDiceChain(left, token);
+    const sides = this.parseExpression(BP.DICE_RIGHT);
+    this.rejectSuccessCountTarget(sides, token);
+    this.rejectVersusTarget(sides, token);
+    return {
+      type: "Dice",
+      count: left,
+      sides,
+      start: left.start ?? token.position,
+      end: sides.end ?? token.end
+    };
+  }
+  parsePrefixDicePercent(token) {
+    return {
+      type: "Dice",
+      count: Parser.syntheticLiteral(1, token),
+      sides: Parser.syntheticLiteral(100, token),
+      start: token.position,
+      end: token.end
+    };
+  }
+  parseInfixDicePercent(left, token) {
+    this.rejectSuccessCountTarget(left, token);
+    this.rejectVersusTarget(left, token);
+    this.rejectBareDiceChain(left, token);
+    return {
+      type: "Dice",
+      count: left,
+      sides: Parser.syntheticLiteral(100, token),
+      start: left.start ?? token.position,
+      end: token.end
+    };
+  }
+  parsePrefixFateDice(token) {
+    return {
+      type: "FateDice",
+      count: Parser.syntheticLiteral(1, token),
+      start: token.position,
+      end: token.end
+    };
+  }
+  parseInfixFateDice(left, token) {
+    this.rejectSuccessCountTarget(left, token);
+    this.rejectVersusTarget(left, token);
+    this.rejectBareDiceChain(left, token);
+    return {
+      type: "FateDice",
+      count: left,
+      start: left.start ?? token.position,
+      end: token.end
+    };
+  }
+  parseGrouped(token) {
+    const expression = this.parseExpression(0);
+    const close = this.expect(16 /* RPAREN */);
+    return { type: "Grouped", expression, start: token.position, end: close.end };
+  }
+  parseGroup(startToken) {
+    if (this.peek().type === 31 /* RBRACE */) {
+      throw new ParseError("Empty group", "UNEXPECTED_TOKEN", startToken.position, startToken);
+    }
+    const expressions = [this.parseExpression(0)];
+    while (this.peek().type === 17 /* COMMA */) {
+      this.advance();
+      expressions.push(this.parseExpression(0));
+    }
+    if (this.peek().type !== 31 /* RBRACE */) {
+      const unterminated = this.peek();
+      throw new ParseError(`Unterminated group: expected '}' or ','`, "EXPECTED_TOKEN", unterminated.position, unterminated);
+    }
+    const close = this.advance();
+    return { type: "Group", expressions, start: startToken.position, end: close.end };
+  }
+  parseVariable(token) {
+    return { type: "Variable", name: token.value, start: token.position, end: token.end };
+  }
+  parseFunctionCall(token) {
+    this.expect(15 /* LPAREN */);
+    const args = [];
+    if (this.peek().type !== 16 /* RPAREN */) {
+      const first = this.parseExpression(0);
+      this.rejectSuccessCountTarget(first, token);
+      args.push(first);
+      while (this.peek().type === 17 /* COMMA */) {
+        this.advance();
+        const next = this.parseExpression(0);
+        this.rejectSuccessCountTarget(next, token);
+        args.push(next);
+      }
+    }
+    const close = 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,
+      start: token.position,
+      end: close.end
+    };
+  }
+  parseBinaryOp(left, token) {
+    this.rejectSuccessCountTarget(left, token);
+    const operator = this.getOperatorSymbol(token);
+    const rightBp = this.getRightBp(token);
+    const right = this.parseExpression(rightBp);
+    this.rejectSuccessCountTarget(right, token);
+    return {
+      type: "BinaryOp",
+      operator,
+      left,
+      right,
+      start: left.start ?? token.position,
+      end: right.end ?? token.end
+    };
+  }
+  rejectBareDiceChain(left, token) {
+    switch (left.type) {
+      case "Dice":
+      case "FateDice":
+      case "Explode":
+      case "Reroll":
+      case "Modifier":
+      case "Sort":
+      case "CritThreshold":
+        throw new ParseError(`Ambiguous dice chain: use 'dl'/'dh' to drop dice (4d6dl1) or parentheses for nested dice ((4d6)d1)`, "AMBIGUOUS_DICE_CHAIN", token.position, token);
+      default:
+        return;
+    }
+  }
+  rejectSuccessCountTarget(target, token) {
+    const node = unwrapTransparent(target, ["Grouped"]);
+    if (isSuccessCount(node)) {
+      throw new ParseError(`Cannot apply modifier after success counting`, "INVALID_SUCCESS_COUNT_TARGET", token.position, token);
+    }
+  }
+  rejectGroupTarget(target, token, action, code, singleSubRollPasses = false) {
+    const node = unwrapTransparent(target, ["Grouped", "Modifier", "Sort", "CritThreshold"]);
+    if (node.type !== "Group")
+      return;
+    if (singleSubRollPasses && node.expressions.length === 1) {
+      const inner = node.expressions[0];
+      if (inner != null && containsMultiSubGroup(inner)) {
+        throw new ParseError(`Cannot ${action} a group`, code, token.position, token);
+      }
+      return;
+    }
+    throw new ParseError(`Cannot ${action} a group`, code, token.position, token);
+  }
+  rejectVersusTarget(target, token) {
+    const node = unwrapTransparent(target, ["Grouped"]);
+    if (node.type === "Versus") {
+      throw new ParseError(`Versus cannot be used as a meta-expression`, "NESTED_VERSUS", token.position, token);
+    }
+    if (node.type === "Group" && node.expressions.length === 1) {
+      const inner = node.expressions[0];
+      if (inner != null && containsVersus(inner)) {
+        throw new ParseError(`Versus cannot be used as a meta-expression`, "NESTED_VERSUS", token.position, token);
+      }
+    }
+  }
+  parseModifier(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    this.rejectVersusTarget(target, token);
+    if (!containsDicePool(target)) {
+      throw new ParseError(`Keep/drop modifiers require a dice pool target`, "INVALID_MODIFIER_TARGET", token.position, 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 hasExplicitCount = nextToken === 0 /* NUMBER */ || nextToken === 15 /* LPAREN */ || nextToken === 32 /* AT */;
+    const count = hasExplicitCount ? this.parseExpression(BP.DICE_LEFT) : Parser.syntheticLiteral(1, token);
+    this.rejectSuccessCountTarget(count, token);
+    this.rejectVersusTarget(count, token);
+    return {
+      type: "Modifier",
+      modifier,
+      selector,
+      count,
+      target,
+      start: target.start ?? token.position,
+      end: hasExplicitCount ? count.end ?? token.end : token.end
+    };
+  }
+  parseExplode(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    this.rejectGroupTarget(target, token, "explode", "INVALID_EXPLODE_TARGET");
+    if (!containsDicePool(target)) {
+      throw new ParseError(`Explode modifier requires a dice pool target`, "INVALID_EXPLODE_TARGET", token.position, token);
+    }
+    if (containsFatePool(target)) {
+      throw new ParseError(`Fate dice cannot explode`, "INVALID_EXPLODE_TARGET", token.position, 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,
+      start: target.start ?? token.position,
+      end: token.end
+    };
+    if (this.isComparePointAhead()) {
+      node.threshold = this.parseComparePoint();
+      node.end = node.threshold.value.end ?? token.end;
+    }
+    return node;
+  }
+  parseReroll(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    this.rejectGroupTarget(target, token, "reroll", "INVALID_REROLL_TARGET");
+    if (!containsDicePool(target)) {
+      throw new ParseError(`Reroll modifier requires a dice pool target`, "INVALID_REROLL_TARGET", token.position, 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,
+      start: target.start ?? token.position,
+      end: condition.value.end ?? token.end
+    };
+  }
+  parseSort(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    this.rejectVersusTarget(target, token);
+    if (!deepContainsDicePool(target)) {
+      throw new ParseError(`Sort modifier requires a dice pool target`, "INVALID_SORT_TARGET", token.position, token);
+    }
+    const base = unwrapTransparent(target, ["Grouped", "Modifier", "Sort", "CritThreshold"]);
+    if (base.type === "Group" && base.expressions.length >= 2) {
+      throw new ParseError(`Sort modifier does not yet support multi-sub-roll groups`, "INVALID_SORT_TARGET", token.position, token);
+    }
+    const order = token.type === 33 /* SORT_ASC */ ? "ascending" : "descending";
+    return {
+      type: "Sort",
+      order,
+      target,
+      start: target.start ?? token.position,
+      end: token.end
+    };
+  }
+  parseCritThreshold(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    this.rejectVersusTarget(target, token);
+    this.rejectGroupTarget(target, token, "apply crit threshold to", "INVALID_CRIT_THRESHOLD_TARGET", true);
+    if (!containsDicePool(target)) {
+      throw new ParseError(`Crit threshold modifier requires a dice pool target`, "INVALID_CRIT_THRESHOLD_TARGET", token.position, token);
+    }
+    if (!this.isComparePointAhead() && containsFatePool(target)) {
+      throw new ParseError(`Bare cs/cf cannot apply to Fate dice`, "INVALID_CRIT_THRESHOLD_TARGET", token.position, token);
+    }
+    const threshold = this.isComparePointAhead() ? this.parseComparePoint() : "default";
+    const end = threshold === "default" ? token.end : threshold.value.end ?? token.end;
+    let chainTarget = target;
+    while (chainTarget.type === "Grouped") {
+      chainTarget = chainTarget.expression;
+    }
+    if (isCritThreshold(chainTarget)) {
+      if (token.type === 35 /* CRIT_SUCCESS */) {
+        chainTarget.successThresholds.push(threshold);
+      } else {
+        chainTarget.failThresholds.push(threshold);
+      }
+      chainTarget.end = end;
+      return chainTarget;
+    }
+    return {
+      type: "CritThreshold",
+      successThresholds: token.type === 35 /* CRIT_SUCCESS */ ? [threshold] : [],
+      failThresholds: token.type === 36 /* CRIT_FAIL */ ? [threshold] : [],
+      target,
+      start: target.start ?? token.position,
+      end
+    };
+  }
+  parseSuccessCount(target, token) {
+    this.rejectSuccessCountTarget(target, token);
+    if (!containsDicePool(target)) {
+      throw new ParseError(`Success counting requires a dice pool target`, "INVALID_SUCCESS_COUNT_TARGET", token.position, token);
+    }
+    const operator = this.getCompareOp(token);
+    const value = this.parseExpression(BP.DICE_LEFT);
+    this.rejectSuccessCountTarget(value, token);
+    this.rejectVersusTarget(value, token);
+    const node = {
+      type: "SuccessCount",
+      target,
+      threshold: { operator, value },
+      start: target.start ?? token.position,
+      end: value.end ?? token.end
+    };
+    if (this.peek().type === 27 /* FAIL */) {
+      this.advance();
+      if (this.isComparePointAhead()) {
+        node.failThreshold = this.parseComparePoint();
+      } else {
+        const failValue = this.parseExpression(BP.DICE_LEFT);
+        this.rejectSuccessCountTarget(failValue, token);
+        this.rejectVersusTarget(failValue, token);
+        node.failThreshold = { operator: "=", value: failValue };
+      }
+      node.end = node.failThreshold.value.end ?? node.end ?? token.end;
+    }
+    return node;
+  }
+  parseVersus(left, token) {
+    this.rejectSuccessCountTarget(left, token);
+    let leftChain = left;
+    while (leftChain.type === "Grouped") {
+      leftChain = leftChain.expression;
+    }
+    if (leftChain.type === "Versus") {
+      throw new ParseError("Cannot chain versus operators", "NESTED_VERSUS", token.position, token);
+    }
+    const dc = this.parseExpression(BP.VS_RIGHT);
+    this.rejectSuccessCountTarget(dc, token);
+    return {
+      type: "Versus",
+      roll: left,
+      dc,
+      start: left.start ?? token.position,
+      end: dc.end ?? token.end
+    };
+  }
+  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);
+    this.rejectSuccessCountTarget(value, token);
+    this.rejectVersusTarget(value, token);
+    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 33 /* SORT_ASC */:
+      case 34 /* SORT_DESC */:
+      case 35 /* CRIT_SUCCESS */:
+      case 36 /* CRIT_FAIL */:
+        return BP.MODIFIER;
+      case 10 /* GREATER */:
+      case 11 /* GREATER_EQUAL */:
+      case 12 /* LESS */:
+      case 13 /* LESS_EQUAL */:
+      case 14 /* EQUAL */:
+        return BP.COMPARE;
+      case 16 /* RPAREN */:
+      case 37 /* EOF */:
+      case 17 /* COMMA */:
+      case 28 /* FUNCTION */:
+      case 30 /* LBRACE */:
+      case 31 /* RBRACE */:
+        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: 37 /* EOF */, value: "", position: this.pos, end: this.pos };
+  }
+  advance() {
+    const token = this.peek();
+    this.pos++;
+    return token;
+  }
+  expect(type) {
+    const token = this.peek();
+    if (token.type !== type) {
+      const expected = TOKEN_DISPLAY[type] ?? TokenType[type];
+      const got = token.type === 37 /* EOF */ ? "end of input" : `'${token.value}'`;
+      throw new ParseError(`Expected ${expected} but got ${got}`, "EXPECTED_TOKEN", token.position, token);
+    }
+    return this.advance();
+  }
+  hasTokens() {
+    return this.peek().type !== 37 /* EOF */;
+  }
+}
+
+// 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;
+    }
+    if (range > 4294967296) {
+      return lo + this.nextBoundedWide(range);
+    }
+    const threshold = (4294967296 - range) % range;
+    let value;
+    do {
+      value = this.nextUint32();
+    } while (value < threshold);
+    return lo + value % range;
+  }
+  nextBoundedWide(range) {
+    const MAX_53 = 2 ** 53;
+    if (range > MAX_53) {
+      throw new RangeError(`nextInt range ${range} exceeds 2^53 and cannot be sampled exactly`);
+    }
+    const limit = Math.floor(MAX_53 / range) * range;
+    let value;
+    do {
+      value = this.nextUint32() * 2097152 + (this.nextUint32() >>> 11);
+    } while (value >= limit);
+    return value % range;
+  }
+}
+
+// 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/crit-threshold.ts
+function applyCritThresholds(dice, successThresholds, failThresholds) {
+  for (const die of dice) {
+    if (die.modifiers.includes("meta"))
+      continue;
+    die.critical = successThresholds.some((t) => matchesCrit(t, die));
+    die.fumble = failThresholds.some((t) => matchesFumble(t, die));
+  }
+}
+function matchesCrit(threshold, die) {
+  if (threshold === "default") {
+    return die.result === die.sides && die.sides > 1;
+  }
+  return matchesCondition(die.result, threshold.operator, threshold.value);
+}
+function matchesFumble(threshold, die) {
+  if (threshold === "default") {
+    return die.result === 1 && die.sides > 1;
+  }
+  return matchesCondition(die.result, threshold.operator, threshold.value);
+}
+
+// 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 && sides > 1
+      });
+      last = next;
+      iterations += 1;
+    }
+  }
+  return result;
+}
+function applyCompoundExplode(pool, shouldExplode, rng, env) {
+  for (const original of pool) {
+    if (!canExplode(original))
+      continue;
+    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)
+      continue;
+    original.initialResult = original.result;
+    original.result = accumulated;
+    if (!original.modifiers.includes("exploded")) {
+      original.modifiers = [...original.modifiers, "exploded"];
+    }
+  }
+  return pool;
+}
+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 && sides > 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/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 && sides > 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);
+      }
+      current.modifiers = [...stripSlotFlags(current.modifiers), "rerolled", "dropped"];
+      result.push(current);
+      current = rollReplacement(current.sides, rng, env);
+      iterations += 1;
+    }
+    current.modifiers = [...stripSlotFlags(current.modifiers), "kept"];
+    result.push(current);
+  }
+  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)) {
+      original.modifiers = [...stripSlotFlags(original.modifiers), "kept"];
+      result.push(original);
+      continue;
+    }
+    original.modifiers = [...stripSlotFlags(original.modifiers), "rerolled", "dropped"];
+    result.push(original);
+    const replacement = rollReplacement(original.sides, rng, env);
+    replacement.modifiers = [...stripSlotFlags(replacement.modifiers), "kept"];
+    result.push(replacement);
+  }
+  return result;
+}
+
+// src/evaluator/modifiers/sort.ts
+function sortDice(dice, order) {
+  const cmp = order === "ascending" ? (a, b) => a.result - b.result : (a, b) => b.result - a.result;
+  return [...dice].sort(cmp);
+}
+
+// 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;
+  start;
+  end;
+  constructor(message, code, nodeType) {
+    super(message, code);
+    this.name = "EvaluatorError";
+    this.nodeType = nodeType ?? undefined;
+    this.start = undefined;
+    this.end = undefined;
+  }
+}
+var DEFAULT_MAX_DICE = 1e4;
+function partSpan(node) {
+  if (node.start === undefined || node.end === undefined)
+    return {};
+  return { start: node.start, end: node.end };
+}
+function toPublicSpecs(specs) {
+  return specs.map((spec) => ({ kind: spec.modifier, selector: spec.selector, count: spec.count }));
+}
+function createDieResult(sides, result) {
+  return {
+    sides,
+    result,
+    modifiers: [],
+    critical: result === sides && sides > 1,
+    fumble: result === 1 && sides > 1
+  };
+}
+function createFateDieResult(result) {
+  return {
+    sides: 0,
+    result,
+    modifiers: [],
+    critical: false,
+    fumble: false
+  };
+}
+function renderDice(dice) {
+  const parts = dice.filter((die) => !die.modifiers.includes("meta")).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 mergeMetaRolls(parent, source) {
+  for (const die of source.rolls) {
+    parent.rolls.push({
+      ...die,
+      modifiers: [
+        ...die.modifiers.filter((m) => m !== "kept" && m !== "dropped" && m !== "success" && m !== "failure"),
+        "meta",
+        "dropped"
+      ]
+    });
+  }
+}
+function evalNode(node, rng, ctx, env) {
+  try {
+    return evalNodeInner(node, rng, ctx, env);
+  } catch (error) {
+    if (error instanceof EvaluatorError && error.start === undefined && node.start !== undefined) {
+      error.start = node.start;
+      error.end = node.end;
+    }
+    throw error;
+  }
+}
+function evalNodeInner(node, rng, ctx, env) {
+  switch (node.type) {
+    case "Literal":
+      return evalLiteral(node, 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);
+    case "Grouped":
+      return evalGrouped(node, rng, ctx, env);
+    case "Group":
+      return evalGroup(node, rng, ctx, env);
+    case "Sort":
+      return evalSort(node, rng, ctx, env);
+    case "CritThreshold":
+      return evalCritThreshold(node, rng, ctx, env);
+    case "Variable":
+      return evalVariable(node, ctx, env);
+    default: {
+      const exhaustive = node;
+      throw new EvaluatorError(`Unknown node type: ${exhaustive.type}`, "UNKNOWN_NODE_TYPE", exhaustive.type);
+    }
+  }
+}
+function evalLiteral(node, ctx) {
+  const { value } = node;
+  ctx.expressionParts.push(String(value));
+  ctx.renderedParts.push(String(value));
+  return { total: value, part: { type: "literal", value, total: value, ...partSpan(node) } };
+}
+function variableNeedsBraces(name) {
+  return !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function evalVariable(node, ctx, env) {
+  const present = Object.hasOwn(env.context, node.name);
+  if (!present) {
+    if (env.onMissingVariable === "throw") {
+      throw new EvaluatorError(`Undefined variable: ${node.name}`, "UNDEFINED_VARIABLE", "Variable");
+    }
+    const display2 = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
+    ctx.expressionParts.push("0");
+    ctx.renderedParts.push(`${display2}[0]`);
+    return {
+      total: 0,
+      part: { type: "variable", name: node.name, value: 0, total: 0, ...partSpan(node) }
+    };
+  }
+  const value = env.context[node.name];
+  if (!Number.isFinite(value)) {
+    throw new EvaluatorError(`Invalid variable value: ${node.name} = ${value}`, "INVALID_VARIABLE_VALUE", "Variable");
+  }
+  const display = variableNeedsBraces(node.name) ? `@{${node.name}}` : `@${node.name}`;
+  ctx.expressionParts.push(String(value));
+  ctx.renderedParts.push(`${display}[${value}]`);
+  return {
+    total: value,
+    part: { type: "variable", name: node.name, value, total: value, ...partSpan(node) }
+  };
+}
+function evalDice(node, rng, ctx, env) {
+  const countCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const count = evalNode(node.count, rng, countCtx, env).total;
+  mergeMetaRolls(ctx, countCtx);
+  const sidesCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const sides = evalNode(node.sides, rng, sidesCtx, env).total;
+  mergeMetaRolls(ctx, sidesCtx);
+  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,
+    part: { type: "dice", count, sides, rolls: markedDice, total, ...partSpan(node) }
+  };
+}
+function evalFateDice(node, rng, ctx, env) {
+  const countCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const count = evalNode(node.count, rng, countCtx, env).total;
+  mergeMetaRolls(ctx, countCtx);
+  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,
+    part: { type: "fateDice", count, rolls: markedDice, total, ...partSpan(node) }
+  };
+}
+function propagateMetadata(parent, metadata) {
+  if (!metadata)
+    return;
+  if (parent.versusMetadata) {
+    throw new EvaluatorError("Multiple versus operators in the same expression", "NESTED_VERSUS", "Versus");
+  }
+  parent.versusMetadata = metadata;
+}
+function mergeContext(parent, child) {
+  parent.rolls.push(...child.rolls);
+  propagateMetadata(parent, child.versusMetadata);
+}
+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);
+  mergeContext(ctx, leftCtx);
+  mergeContext(ctx, rightCtx);
+  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}`);
+  const total = applyBinaryOperator(node.operator, left.total, right.total);
+  return {
+    total,
+    part: {
+      type: "binaryOp",
+      operator: node.operator,
+      left: left.part,
+      right: right.part,
+      total,
+      ...partSpan(node)
+    }
+  };
+}
+function applyBinaryOperator(operator, left, right) {
+  switch (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 = operator;
+      throw new EvaluatorError(`Unknown operator: ${exhaustive}`, "UNKNOWN_OPERATOR", "BinaryOp");
+    }
+  }
+}
+function evalUnaryOp(node, rng, ctx, env) {
+  const innerCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const inner = evalNode(node.operand, rng, innerCtx, env);
+  mergeContext(ctx, innerCtx);
+  const innerExpr = innerCtx.expressionParts.join("");
+  const innerRendered = innerCtx.renderedParts.join("");
+  ctx.expressionParts.push(`-${innerExpr}`);
+  ctx.renderedParts.push(`-${innerRendered}`);
+  const total = -inner.total;
+  return {
+    total,
+    part: { type: "unaryOp", operator: "-", operand: inner.part, total, ...partSpan(node) }
+  };
+}
+function evalGrouped(node, rng, ctx, env) {
+  const innerCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const inner = evalNode(node.expression, rng, innerCtx, env);
+  mergeContext(ctx, innerCtx);
+  ctx.expressionParts.push(`(${innerCtx.expressionParts.join("")})`);
+  ctx.renderedParts.push(`(${innerCtx.renderedParts.join("")})`);
+  return {
+    total: inner.total,
+    part: { type: "grouped", inner: inner.part, total: inner.total, ...partSpan(node) }
+  };
+}
+function evalGroup(node, rng, ctx, env) {
+  const subExprs = [];
+  const subRendered = [];
+  const subParts = [];
+  let total = 0;
+  for (const expr of node.expressions) {
+    const subCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const sub = evalNode(expr, rng, subCtx, env);
+    mergeContext(ctx, subCtx);
+    subExprs.push(subCtx.expressionParts.join(""));
+    subRendered.push(subCtx.renderedParts.join(""));
+    subParts.push(sub.part);
+    total += sub.total;
+  }
+  ctx.expressionParts.push(`{${subExprs.join(", ")}}`);
+  ctx.renderedParts.push(`{${subRendered.join(", ")}}`);
+  return { total, part: { type: "group", parts: subParts, total, ...partSpan(node) } };
+}
+function evalFunctionCall(node, rng, ctx, env) {
+  const argCtxs = [];
+  const argResults = [];
+  for (const arg of node.args) {
+    const argCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    argResults.push(evalNode(arg, rng, argCtx, env));
+    argCtxs.push(argCtx);
+  }
+  for (const argCtx of argCtxs) {
+    mergeContext(ctx, argCtx);
+  }
+  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(", ")})`);
+  const total = applyFunction(node.name, argResults.map((r) => r.total));
+  return {
+    total,
+    part: {
+      type: "functionCall",
+      name: node.name,
+      args: argResults.map((r) => r.part),
+      total,
+      ...partSpan(node)
+    }
+  };
+}
+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, ctx, env) {
+  const specs = [];
+  let current = node;
+  while (isModifier(current)) {
+    const countCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const modCount = evalNode(current.count, rng, countCtx, env).total;
+    mergeMetaRolls(ctx, countCtx);
+    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);
+      }
+    }
+  }
+  baseDice.forEach((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"];
+  });
+  return baseDice;
+}
+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 target = 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).total;
+    mergeMetaRolls(ctx, thresholdCtx);
+  }
+  const code = formatExplodeCode(node.variant, node.threshold, thresholdValue);
+  const buildPart = (total2) => {
+    const part = {
+      type: "explode",
+      variant: node.variant,
+      target: target.part,
+      total: total2,
+      ...partSpan(node)
+    };
+    if (node.threshold != null && thresholdValue !== undefined) {
+      part.threshold = { operator: node.threshold.operator, value: thresholdValue };
+    }
+    return part;
+  };
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    return { total: target.total, part: buildPart(target.total) };
+  }
+  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)}`);
+  const total = sumKeptDice(expanded);
+  return { total, part: buildPart(total) };
+}
+function evalReroll(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const target = 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).total;
+  mergeMetaRolls(ctx, thresholdCtx);
+  const code = `${node.once ? "ro" : "r"}${node.condition.operator}${thresholdValue}`;
+  const condition = {
+    operator: node.condition.operator,
+    value: thresholdValue
+  };
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    const total2 = sumKeptDice(targetCtx.rolls);
+    return {
+      total: total2,
+      part: {
+        type: "reroll",
+        once: node.once,
+        condition,
+        target: target.part,
+        total: total2,
+        ...partSpan(node)
+      }
+    };
+  }
+  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)}`);
+  const total = sumKeptDice(pool);
+  return {
+    total,
+    part: {
+      type: "reroll",
+      once: node.once,
+      condition,
+      target: target.part,
+      total,
+      ...partSpan(node)
+    }
+  };
+}
+function evalSort(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const target = evalNode(node.target, rng, targetCtx, env);
+  const sortedRolls = sortDice(targetCtx.rolls, node.order);
+  ctx.rolls.push(...sortedRolls);
+  propagateMetadata(ctx, targetCtx.versusMetadata);
+  const code = node.order === "ascending" ? "s" : "sd";
+  const targetExpr = targetCtx.expressionParts.join("");
+  ctx.expressionParts.push(`${targetExpr}${code}`);
+  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(sortedRolls)}`);
+  return {
+    total: target.total,
+    part: {
+      type: "sort",
+      order: node.order,
+      target: target.part,
+      total: target.total,
+      ...partSpan(node)
+    }
+  };
+}
+function evalCritThreshold(node, rng, ctx, env) {
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const target = evalNode(node.target, rng, targetCtx, env);
+  const successResolved = node.successThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
+  const failResolved = node.failThresholds.map((t) => resolveCritThreshold(t, rng, ctx, env));
+  const successApplied = successResolved.length > 0 ? successResolved : ["default"];
+  const failApplied = failResolved.length > 0 ? failResolved : ["default"];
+  applyCritThresholds(targetCtx.rolls, successApplied, failApplied);
+  ctx.rolls.push(...targetCtx.rolls);
+  propagateMetadata(ctx, targetCtx.versusMetadata);
+  const targetExpr = targetCtx.expressionParts.join("");
+  const codes = [
+    ...successResolved.map((t) => t === "default" ? "cs" : `cs${t.operator}${t.value}`),
+    ...failResolved.map((t) => t === "default" ? "cf" : `cf${t.operator}${t.value}`)
+  ].join("");
+  ctx.expressionParts.push(`${targetExpr}${codes}`);
+  ctx.renderedParts.push(`${targetExpr}${codes}${renderDice(targetCtx.rolls)}`);
+  return {
+    total: target.total,
+    part: {
+      type: "critThreshold",
+      successThresholds: successResolved,
+      failThresholds: failResolved,
+      target: target.part,
+      total: target.total,
+      ...partSpan(node)
+    }
+  };
+}
+function resolveCritThreshold(threshold, rng, ctx, env) {
+  if (threshold === "default")
+    return "default";
+  const thresholdCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const resolved = evalNode(threshold.value, rng, thresholdCtx, env).total;
+  mergeMetaRolls(ctx, thresholdCtx);
+  if (!Number.isFinite(resolved)) {
+    throw new EvaluatorError(`Invalid crit threshold: ${resolved}`, "INVALID_THRESHOLD", "CritThreshold");
+  }
+  return { operator: threshold.operator, value: resolved };
+}
+function evalModifier(node, rng, ctx, env) {
+  const { specs, baseTarget } = flattenModifierChain(node, rng, ctx, env);
+  if (baseTarget.type === "Group" && baseTarget.expressions.length >= 2) {
+    return evalGroupModifier(node, baseTarget, specs, rng, ctx, env);
+  }
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const target = 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,
+    part: {
+      type: "modifier",
+      specs: toPublicSpecs(specs),
+      target: target.part,
+      total,
+      ...partSpan(node)
+    }
+  };
+}
+function stripInnerMarkers(rendered) {
+  return rendered.replace(/\*\*(-?\d+)\*\*/g, "$1").replace(/__(-?\d+)__/g, "$1").replace(/~~(-?\d+)~~/g, "$1");
+}
+function evalGroupModifier(node, group, specs, rng, ctx, env) {
+  const subRolls = group.expressions.map((expr) => {
+    const subCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const sub = evalNode(expr, rng, subCtx, env);
+    return {
+      subtotal: sub.total,
+      part: sub.part,
+      rolls: subCtx.rolls,
+      expr: subCtx.expressionParts.join(""),
+      rendered: subCtx.renderedParts.join(""),
+      versusMetadata: subCtx.versusMetadata
+    };
+  });
+  const syntheticDice = subRolls.map((sub) => ({
+    sides: 0,
+    result: sub.subtotal,
+    modifiers: [],
+    critical: false,
+    fumble: false
+  }));
+  const mergedSynthetic = mergeDropSets(syntheticDice, specs);
+  const outerRendered = [];
+  const keptIndices = [];
+  let total = 0;
+  for (let i = 0;i < subRolls.length; i++) {
+    const sub = subRolls[i];
+    const synth = mergedSynthetic[i];
+    const isDropped = synth.modifiers.includes("dropped");
+    if (isDropped) {
+      for (const die of sub.rolls) {
+        die.modifiers = [
+          ...die.modifiers.filter((m) => m !== "kept" && m !== "dropped" && m !== "success" && m !== "failure"),
+          "dropped"
+        ];
+      }
+      ctx.rolls.push(...sub.rolls);
+      outerRendered.push(`~~${stripInnerMarkers(sub.rendered)}~~`);
+    } else {
+      keptIndices.push(i);
+      ctx.rolls.push(...sub.rolls);
+      outerRendered.push(sub.rendered);
+      total += sub.subtotal;
+    }
+    if (!isDropped) {
+      propagateMetadata(ctx, sub.versusMetadata);
+    }
+  }
+  const subExprStrs = subRolls.map((s) => s.expr);
+  const modifierCodes = specs.map((s) => `${s.code}${s.count}`).join("");
+  ctx.expressionParts.push(`{${subExprStrs.join(", ")}}${modifierCodes}`);
+  ctx.renderedParts.push(`{${outerRendered.join(", ")}}`);
+  const groupPart = {
+    type: "group",
+    parts: subRolls.map((s) => s.part),
+    keptIndices,
+    total,
+    ...partSpan(group)
+  };
+  return {
+    total,
+    part: {
+      type: "modifier",
+      specs: toPublicSpecs(specs),
+      target: groupPart,
+      total,
+      ...partSpan(node)
+    }
+  };
+}
+function resolveThreshold(value, rng, ctx, env, role) {
+  const thresholdCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const resolved = evalNode(value, rng, thresholdCtx, env).total;
+  mergeMetaRolls(ctx, thresholdCtx);
+  if (!Number.isFinite(resolved)) {
+    throw new EvaluatorError(`Invalid ${role}: ${resolved}`, "INVALID_THRESHOLD", "SuccessCount");
+  }
+  return resolved;
+}
+function evalSuccessCount(node, rng, ctx, env) {
+  env.hasSuccessCount = true;
+  const targetCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+  const target = evalNode(node.target, rng, targetCtx, env);
+  const targetExpr = targetCtx.expressionParts.join("");
+  const thresholdValue = resolveThreshold(node.threshold.value, rng, ctx, env, "threshold");
+  const failValue = node.failThreshold != null ? resolveThreshold(node.failThreshold.value, rng, ctx, env, "fail threshold") : undefined;
+  const code = `${node.threshold.operator}${thresholdValue}${failValue != null ? `f${failValue}` : ""}`;
+  const buildPart = (total, successes, failures) => {
+    const part = {
+      type: "successCount",
+      threshold: { operator: node.threshold.operator, value: thresholdValue },
+      target: target.part,
+      successes,
+      failures,
+      total,
+      ...partSpan(node)
+    };
+    if (failValue != null && node.failThreshold != null) {
+      part.failThreshold = { operator: node.failThreshold.operator, value: failValue };
+    }
+    return part;
+  };
+  if (targetCtx.rolls.length === 0) {
+    ctx.expressionParts.push(`${targetExpr}${code}`);
+    ctx.renderedParts.push(`${targetExpr}${code}`);
+    return { total: target.total, part: buildPart(target.total, 0, 0) };
+  }
+  const result = countSuccesses(targetCtx.rolls, { operator: node.threshold.operator, value: thresholdValue }, failValue != null && node.failThreshold != null ? { operator: node.failThreshold.operator, value: failValue } : undefined);
+  ctx.rolls.push(...targetCtx.rolls);
+  ctx.expressionParts.push(`${targetExpr}${code}`);
+  ctx.renderedParts.push(`${targetExpr}${code}${renderDice(targetCtx.rolls)}`);
+  return {
+    total: result.total,
+    part: buildPart(result.total, result.successes, result.failures)
+  };
+}
+function extractNatural(rolls) {
+  const primaries = rolls.filter((d) => d.sides === 20 && !d.modifiers.includes("dropped") && !(d.modifiers.includes("exploded") && d.initialResult === undefined));
+  if (primaries.length !== 1)
+    return;
+  const die = primaries[0];
+  return die?.initialResult ?? die?.result;
+}
+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 rollResult = evalNode(node.roll, rng, rollCtx, env);
+    const natural = extractNatural(rollCtx.rolls);
+    const dcCtx = { rolls: [], expressionParts: [], renderedParts: [] };
+    const dcResult = evalNode(node.dc, rng, dcCtx, env);
+    const degree = calculateDegree(rollResult.total, dcResult.total, 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: dcResult.total };
+    return {
+      total: rollResult.total,
+      part: {
+        type: "versus",
+        roll: rollResult.part,
+        dc: dcResult.part,
+        degree,
+        total: rollResult.total,
+        ...partSpan(node)
+      }
+    };
+  } 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 context = options.context ?? {};
+  const onMissingVariable = options.onMissingVariable ?? "throw";
+  const env = {
+    maxDice,
+    maxExplodeIterations,
+    maxRerollIterations,
+    totalDiceRolled: 0,
+    hasSuccessCount: false,
+    insideVersus: false,
+    context,
+    onMissingVariable
+  };
+  const ctx = {
+    rolls: [],
+    expressionParts: [],
+    renderedParts: []
+  };
+  const { total, part } = evalNode(ast, rng, ctx, env);
+  if (!Number.isFinite(total)) {
+    throw new EvaluatorError(`Result is not a finite number: ${total}`, "NON_FINITE_RESULT", ast.type);
+  }
+  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,
+    parts: part
+  };
+  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;
+  }
+  if (options.context != null)
+    evalOptions.context = options.context;
+  if (options.onMissingVariable != null) {
+    evalOptions.onMissingVariable = options.onMissingVariable;
+  }
+  return evaluate(ast, rng, evalOptions);
+}
+// package.json
+var version = "3.0.0-beta.0";
+
+// src/index.ts
+var VERSION = version;
+
+// src/cli/args.ts
+function parseArgs(argv) {
+  let verbose = false;
+  let seed;
+  let showHelp = false;
+  let showVersion = false;
+  const positional = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      showHelp = true;
+    } else if (arg === "--version") {
+      showVersion = true;
+    } else if (arg === "--verbose" || arg === "-v") {
+      verbose = true;
+    } else if (arg === "--seed") {
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("-") && !/^-\d/.test(next)) {
+        return { ok: false, error: "Missing value for --seed" };
+      }
+      seed = next;
+      i++;
+    } else if (arg.startsWith("--seed=")) {
+      const value = arg.slice("--seed=".length);
+      if (value === "") {
+        return { ok: false, error: "Missing value for --seed" };
+      }
+      seed = value;
+    } else if (arg.startsWith("--")) {
+      return { ok: false, error: `Unknown option: ${arg}` };
+    } else if (arg.startsWith("-") && arg.length > 1 && !/^[\ddD(]/.test(arg.slice(1))) {
+      return { ok: false, error: `Unknown option: ${arg}` };
+    } else {
+      positional.push(arg);
+    }
+  }
+  const notation = positional.length > 0 ? positional.join(" ") : undefined;
+  return { ok: true, args: { notation, verbose, seed, showHelp, showVersion } };
+}
+
+// src/cli/format.ts
+function formatResult(result, verbose) {
+  if (!verbose) {
+    return String(result.total);
+  }
+  return formatRendered(result.rendered);
+}
+function formatRendered(rendered) {
+  return rendered.replace(/\*\*(-?\d+)\*\*/g, "[$1]").replace(/__(-?\d+)__/g, "{$1}").replace(/~~([^~]+)~~/g, "($1)");
+}
+
+// src/cli/index.ts
+var HELP_TEXT = `roll-parser v${VERSION}
+
+Usage: roll-parser <notation> [options]
+
+Options:
+  -h, --help       Show this help message
+  --version        Show version number
+  -v, --verbose    Show detailed roll breakdown
+  --seed <value>   Use seed for reproducible rolls
+
+Examples:
+  roll-parser 2d6+3
+  roll-parser 4d6kh3 --verbose
+  roll-parser 4d6dl1 --seed "character-str"
+`;
+function writeErrorContext(notation, error) {
+  const position = "position" in error ? error.position : ("start" in error) ? error.start : undefined;
+  if (typeof position !== "number" || !Number.isInteger(position))
+    return;
+  if (notation.includes(`
+`) || position < 0 || position > notation.length)
+    return;
+  process.stderr.write(`  ${notation}
+`);
+  process.stderr.write(`  ${" ".repeat(position)}^
+`);
+}
+function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (!parsed.ok) {
+    process.stderr.write(`Error: ${parsed.error}
+`);
+    process.stderr.write(`Run "roll-parser --help" for usage.
+`);
+    process.exitCode = 2;
+    return;
+  }
+  const { args } = parsed;
+  if (args.showHelp) {
+    process.stdout.write(HELP_TEXT);
+    return;
+  }
+  if (args.showVersion) {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  if (args.notation == null) {
+    process.stderr.write(`Error: No dice notation provided.
+`);
+    process.stderr.write(`Run "roll-parser --help" for usage.
+`);
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const options = args.seed != null ? { seed: args.seed } : {};
+    const result = roll(args.notation, options);
+    const output = formatResult(result, args.verbose);
+    process.stdout.write(`${output}
+`);
+  } catch (error) {
+    if (isRollParserError(error)) {
+      process.stderr.write(`Error: ${error.message}
+`);
+      writeErrorContext(args.notation, error);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+}
+main();
+
+//# debugId=E5D058E5C568B60B64756E2164756E21
+//# sourceMappingURL=cli.js.map