roll-parser 3.0.0-beta.0 → 3.0.0

package/dist/parser/parser.js

@@ -0,0 +1,751 @@
+import { RollParserError } from '../errors.js';
+import { lex } from '../lexer/lexer.js';
+import { TokenType } from '../lexer/tokens.js';
+import { isCritThreshold, isSuccessCount } from './ast.js';
+import { containsDicePool, containsFatePool, containsMultiSubGroup, containsVersus, deepContainsDicePool, unwrapAllTransparent, unwrapGrouped, } from './guards.js';
+export class ParseError extends RollParserError {
+    position;
+    token;
+    constructor(message, code, position, token, options) {
+        super(message, code, options);
+        this.name = 'ParseError';
+        this.position = position;
+        this.token = token;
+    }
+}
+const 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,
+};
+export const MAX_PARSE_DEPTH = 128;
+const TOKEN_DISPLAY = {
+    [TokenType.LPAREN]: `'('`,
+    [TokenType.RPAREN]: `')'`,
+    [TokenType.LBRACE]: `'{'`,
+    [TokenType.RBRACE]: `'}'`,
+    [TokenType.COMMA]: `','`,
+};
+const FUNCTION_ARITY = {
+    floor: { min: 1, max: 1 },
+    ceil: { min: 1, max: 1 },
+    round: { min: 1, max: 1 },
+    abs: { min: 1, max: 1 },
+    sqrt: { min: 1, max: 1 },
+    pow: { min: 2, max: 2 },
+    max: { min: 2, max: Number.POSITIVE_INFINITY },
+    min: { min: 2, max: Number.POSITIVE_INFINITY },
+};
+function formatArity(arity) {
+    if (arity.max === Number.POSITIVE_INFINITY)
+        return `at least ${arity.min}`;
+    if (arity.min === arity.max)
+        return `${arity.min}`;
+    return `${arity.min}–${arity.max}`;
+}
+const EXPLODE_VARIANTS = {
+    [TokenType.EXPLODE]: 'standard',
+    [TokenType.EXPLODE_COMPOUND]: 'compound',
+    [TokenType.EXPLODE_PENETRATING]: 'penetrating',
+};
+export class Parser {
+    tokens;
+    pos = 0;
+    depth = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        if (this.peek().type === TokenType.EOF) {
+            throw new ParseError('Unexpected end of input', 'UNEXPECTED_END', this.peek().position);
+        }
+        const ast = this.parseExpression(0);
+        if (this.peek().type !== TokenType.EOF) {
+            const token = this.peek();
+            throw new ParseError(`Unexpected token '${token.value}'`, 'UNEXPECTED_TOKEN', token.position, token);
+        }
+        return ast;
+    }
+    parseExpression(minBp) {
+        const entryDepth = this.depth;
+        this.depth += 1;
+        this.guardDepth();
+        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);
+                this.depth += 1;
+                this.guardDepth();
+            }
+            return left;
+        }
+        finally {
+            this.depth = entryDepth;
+        }
+    }
+    guardDepth() {
+        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());
+        }
+    }
+    parseNud() {
+        const token = this.advance();
+        switch (token.type) {
+            case TokenType.NUMBER:
+                return this.parseLiteral(token);
+            case TokenType.MINUS:
+                return this.parseUnaryMinus(token);
+            case TokenType.DICE:
+                return this.parsePrefixDice(token);
+            case TokenType.DICE_PERCENT:
+                return this.parsePrefixDicePercent(token);
+            case TokenType.DICE_FATE:
+                return this.parsePrefixFateDice(token);
+            case TokenType.LPAREN:
+                return this.parseGrouped(token);
+            case TokenType.LBRACE:
+                return this.parseGroup(token);
+            case TokenType.FUNCTION:
+                return this.parseFunctionCall(token);
+            case TokenType.AT:
+                return this.parseVariable(token);
+            case TokenType.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 TokenType.DICE:
+                return this.parseInfixDice(left, token);
+            case TokenType.DICE_PERCENT:
+                return this.parseInfixDicePercent(left, token);
+            case TokenType.DICE_FATE:
+                return this.parseInfixFateDice(left, token);
+            case TokenType.PLUS:
+            case TokenType.MINUS:
+            case TokenType.MULTIPLY:
+            case TokenType.DIVIDE:
+            case TokenType.MODULO:
+            case TokenType.POWER:
+                return this.parseBinaryOp(left, token);
+            case TokenType.KEEP_HIGH:
+            case TokenType.KEEP_LOW:
+            case TokenType.DROP_HIGH:
+            case TokenType.DROP_LOW:
+                return this.parseKeepDrop(left, token);
+            case TokenType.EXPLODE:
+            case TokenType.EXPLODE_COMPOUND:
+            case TokenType.EXPLODE_PENETRATING:
+                return this.parseExplode(left, token);
+            case TokenType.REROLL:
+            case TokenType.REROLL_ONCE:
+                return this.parseReroll(left, token);
+            case TokenType.SORT_ASC:
+            case TokenType.SORT_DESC:
+                return this.parseSort(left, token);
+            case TokenType.CRIT_SUCCESS:
+            case TokenType.CRIT_FAIL:
+                return this.parseCritThreshold(left, token);
+            case TokenType.FUNCTION:
+                return this.parseDieBound(left, token);
+            case TokenType.GREATER:
+            case TokenType.GREATER_EQUAL:
+            case TokenType.LESS:
+            case TokenType.LESS_EQUAL:
+            case TokenType.EQUAL:
+                return this.parseSuccessCount(left, token);
+            case TokenType.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.rejectVersusMetaOperand(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.rejectVersusMetaOperand(left, token);
+        this.rejectBareDiceChain(left, token);
+        const sides = this.parseExpression(BP.DICE_RIGHT);
+        this.rejectSuccessCountTarget(sides, token);
+        this.rejectVersusMetaOperand(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.rejectVersusMetaOperand(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.rejectVersusMetaOperand(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(TokenType.RPAREN);
+        return { type: 'Grouped', expression, start: token.position, end: close.end };
+    }
+    parseGroup(startToken) {
+        if (this.peek().type === TokenType.RBRACE) {
+            throw new ParseError('Empty group', 'UNEXPECTED_TOKEN', startToken.position, startToken);
+        }
+        const expressions = [this.parseExpression(0)];
+        while (this.peek().type === TokenType.COMMA) {
+            this.advance();
+            expressions.push(this.parseExpression(0));
+        }
+        if (this.peek().type !== TokenType.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(TokenType.LPAREN);
+        const args = [];
+        if (this.peek().type !== TokenType.RPAREN) {
+            const first = this.parseExpression(0);
+            this.rejectSuccessCountTarget(first, token);
+            args.push(first);
+            while (this.peek().type === TokenType.COMMA) {
+                this.advance();
+                const next = this.parseExpression(0);
+                this.rejectSuccessCountTarget(next, token);
+                args.push(next);
+            }
+        }
+        const close = this.expect(TokenType.RPAREN);
+        const arity = FUNCTION_ARITY[token.value];
+        if (arity == null) {
+            throw new ParseError(`Unknown function '${token.value}'`, 'UNKNOWN_FUNCTION', token.position, token);
+        }
+        if (args.length < arity.min || args.length > arity.max) {
+            const expected = formatArity(arity);
+            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 'DieBound':
+            case 'KeepDrop':
+            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 = unwrapGrouped(target);
+        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 = unwrapAllTransparent(target);
+        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);
+    }
+    rejectVersusMetaOperand(operand, token) {
+        if (containsVersus(operand))
+            Parser.throwVersusMetaExpression(token);
+    }
+    static throwVersusMetaExpression(token) {
+        throw new ParseError(`Versus cannot be used as a meta-expression`, 'NESTED_VERSUS', token.position, token);
+    }
+    rejectVersusTarget(target, token) {
+        const node = unwrapGrouped(target);
+        if (node.type === 'Versus')
+            Parser.throwVersusMetaExpression(token);
+        if (node.type === 'Group' && node.expressions.length === 1) {
+            const inner = node.expressions[0];
+            if (inner != null && containsVersus(inner))
+                Parser.throwVersusMetaExpression(token);
+        }
+    }
+    parseKeepDrop(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_KEEP_DROP_TARGET', token.position, token);
+        }
+        const kind = token.type === TokenType.KEEP_HIGH || token.type === TokenType.KEEP_LOW ? 'keep' : 'drop';
+        const selector = token.type === TokenType.KEEP_HIGH || token.type === TokenType.DROP_HIGH
+            ? 'highest'
+            : 'lowest';
+        const nextToken = this.peek().type;
+        const hasExplicitCount = nextToken === TokenType.NUMBER ||
+            nextToken === TokenType.LPAREN ||
+            nextToken === TokenType.AT;
+        const count = hasExplicitCount
+            ? this.parseExpression(BP.DICE_LEFT)
+            : Parser.syntheticLiteral(1, token);
+        this.rejectSuccessCountTarget(count, token);
+        this.rejectVersusMetaOperand(count, token);
+        return {
+            type: 'KeepDrop',
+            kind,
+            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 = EXPLODE_VARIANTS[token.type] ?? 'penetrating';
+        const start = target.start ?? token.position;
+        if (!this.isComparePointAhead()) {
+            return { type: 'Explode', variant, target, start, end: token.end };
+        }
+        const threshold = this.parseComparePoint();
+        return {
+            type: 'Explode',
+            variant,
+            target,
+            threshold,
+            start,
+            end: threshold.value.end ?? token.end,
+        };
+    }
+    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 === TokenType.REROLL_ONCE;
+        const condition = this.parseComparePoint();
+        return {
+            type: 'Reroll',
+            once,
+            condition,
+            target,
+            start: target.start ?? token.position,
+            end: condition.value.end ?? token.end,
+        };
+    }
+    parseDieBound(target, token) {
+        this.rejectSuccessCountTarget(target, token);
+        this.rejectVersusTarget(target, token);
+        this.rejectGroupTarget(target, token, `apply '${token.value}' to`, 'INVALID_DIE_BOUND_TARGET');
+        if (!containsDicePool(target)) {
+            throw new ParseError(`Die bound modifier requires a dice pool target`, 'INVALID_DIE_BOUND_TARGET', token.position, token);
+        }
+        if (containsFatePool(target)) {
+            throw new ParseError(`Fate dice cannot be clamped`, 'INVALID_DIE_BOUND_TARGET', token.position, token);
+        }
+        const nextToken = this.peek().type;
+        const hasExplicitValue = nextToken === TokenType.NUMBER ||
+            nextToken === TokenType.LPAREN ||
+            nextToken === TokenType.AT;
+        if (!hasExplicitValue) {
+            throw new ParseError(`Expected value after '${token.value}'`, 'EXPECTED_TOKEN', token.position, token);
+        }
+        const value = this.parseExpression(BP.DICE_LEFT);
+        this.rejectSuccessCountTarget(value, token);
+        this.rejectVersusMetaOperand(value, token);
+        return {
+            type: 'DieBound',
+            bound: token.value === 'min' ? 'min' : 'max',
+            value,
+            target,
+            start: target.start ?? token.position,
+            end: 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 = unwrapAllTransparent(target);
+        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 === TokenType.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)) {
+            const isSuccess = token.type === TokenType.CRIT_SUCCESS;
+            return {
+                ...chainTarget,
+                successThresholds: isSuccess
+                    ? [...chainTarget.successThresholds, threshold]
+                    : chainTarget.successThresholds,
+                failThresholds: isSuccess
+                    ? chainTarget.failThresholds
+                    : [...chainTarget.failThresholds, threshold],
+                end,
+            };
+        }
+        return {
+            type: 'CritThreshold',
+            successThresholds: token.type === TokenType.CRIT_SUCCESS ? [threshold] : [],
+            failThresholds: token.type === TokenType.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.rejectVersusMetaOperand(value, token);
+        const start = target.start ?? token.position;
+        const end = value.end ?? token.end;
+        if (this.peek().type !== TokenType.FAIL) {
+            return { type: 'SuccessCount', target, threshold: { operator, value }, start, end };
+        }
+        this.advance();
+        const failThreshold = this.parseFailThreshold(token);
+        return {
+            type: 'SuccessCount',
+            target,
+            threshold: { operator, value },
+            failThreshold,
+            start,
+            end: failThreshold.value.end ?? end,
+        };
+    }
+    parseFailThreshold(token) {
+        if (this.isComparePointAhead())
+            return this.parseComparePoint();
+        const failValue = this.parseExpression(BP.DICE_LEFT);
+        this.rejectSuccessCountTarget(failValue, token);
+        this.rejectVersusMetaOperand(failValue, token);
+        return { operator: '=', value: failValue };
+    }
+    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 === TokenType.GREATER ||
+            type === TokenType.GREATER_EQUAL ||
+            type === TokenType.LESS ||
+            type === TokenType.LESS_EQUAL ||
+            type === TokenType.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.rejectVersusMetaOperand(value, token);
+        return { operator, value };
+    }
+    getCompareOp(token) {
+        switch (token.type) {
+            case TokenType.GREATER:
+                return '>';
+            case TokenType.GREATER_EQUAL:
+                return '>=';
+            case TokenType.LESS:
+                return '<';
+            case TokenType.LESS_EQUAL:
+                return '<=';
+            case TokenType.EQUAL:
+                return '=';
+            default:
+                throw new ParseError(`Expected comparison operator but got '${token.value}'`, 'EXPECTED_TOKEN', token.position, token);
+        }
+    }
+    getOperatorSymbol(token) {
+        switch (token.type) {
+            case TokenType.PLUS:
+                return '+';
+            case TokenType.MINUS:
+                return '-';
+            case TokenType.MULTIPLY:
+                return '*';
+            case TokenType.DIVIDE:
+                return '/';
+            case TokenType.MODULO:
+                return '%';
+            case TokenType.POWER:
+                return '**';
+            default:
+                throw new ParseError(`Unknown operator '${token.value}'`, 'UNEXPECTED_TOKEN', token.position, token);
+        }
+    }
+    getLeftBp(token) {
+        switch (token.type) {
+            case TokenType.VS:
+                return BP.VS_LEFT;
+            case TokenType.PLUS:
+            case TokenType.MINUS:
+                return BP.ADD_LEFT;
+            case TokenType.MULTIPLY:
+            case TokenType.DIVIDE:
+            case TokenType.MODULO:
+                return BP.MUL_LEFT;
+            case TokenType.POWER:
+                return BP.POW_LEFT;
+            case TokenType.DICE:
+            case TokenType.DICE_PERCENT:
+            case TokenType.DICE_FATE:
+                return BP.DICE_LEFT;
+            case TokenType.KEEP_HIGH:
+            case TokenType.KEEP_LOW:
+            case TokenType.DROP_HIGH:
+            case TokenType.DROP_LOW:
+            case TokenType.EXPLODE:
+            case TokenType.EXPLODE_COMPOUND:
+            case TokenType.EXPLODE_PENETRATING:
+            case TokenType.REROLL:
+            case TokenType.REROLL_ONCE:
+            case TokenType.SORT_ASC:
+            case TokenType.SORT_DESC:
+            case TokenType.CRIT_SUCCESS:
+            case TokenType.CRIT_FAIL:
+                return BP.MODIFIER;
+            case TokenType.GREATER:
+            case TokenType.GREATER_EQUAL:
+            case TokenType.LESS:
+            case TokenType.LESS_EQUAL:
+            case TokenType.EQUAL:
+                return BP.COMPARE;
+            case TokenType.FUNCTION:
+                return token.value === 'min' || token.value === 'max' ? BP.MODIFIER : -1;
+            case TokenType.RPAREN:
+            case TokenType.EOF:
+            case TokenType.COMMA:
+            case TokenType.LBRACE:
+            case TokenType.RBRACE:
+                return -1;
+            default:
+                return 0;
+        }
+    }
+    getRightBp(token) {
+        switch (token.type) {
+            case TokenType.VS:
+                return BP.VS_RIGHT;
+            case TokenType.PLUS:
+            case TokenType.MINUS:
+                return BP.ADD_RIGHT;
+            case TokenType.MULTIPLY:
+            case TokenType.DIVIDE:
+            case TokenType.MODULO:
+                return BP.MUL_RIGHT;
+            case TokenType.POWER:
+                return BP.POW_RIGHT;
+            case TokenType.DICE:
+                return BP.DICE_RIGHT;
+            default:
+                return 0;
+        }
+    }
+    peek() {
+        return (this.tokens[this.pos] ?? { type: TokenType.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];
+            const got = token.type === TokenType.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 !== TokenType.EOF;
+    }
+}
+export function parse(notation) {
+    const tokens = lex(notation);
+    const parser = new Parser(tokens);
+    return parser.parse();
+}
+//# sourceMappingURL=parser.js.map