roll-parser 2.3.2 → 3.0.0-beta.0

package/dist/lexer/lexer.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Dice notation lexer with character-by-character scanning.
+ *
+ * @module lexer/lexer
+ */
+import type { RollParserErrorCode } from '../errors.js';
+import { RollParserError } from '../errors.js';
+import { type Token } from './tokens.js';
+/**
+ * Error thrown when the lexer encounters an invalid character.
+ */
+export declare class LexerError extends RollParserError {
+    readonly position: number;
+    readonly character: string;
+    constructor(message: string, code: RollParserErrorCode, position: number, character: string);
+}
+/**
+ * Lexer for dice notation.
+ *
+ * Produces a stream of tokens from an input string using character-by-character
+ * scanning with maximal munch for multi-character tokens.
+ */
+export declare class Lexer {
+    private pos;
+    private readonly input;
+    constructor(input: string);
+    /**
+     * Tokenize the entire input and return all tokens.
+     */
+    tokenize(): Token[];
+    /**
+     * Get the next token from the input.
+     */
+    nextToken(): Token;
+    private skipWhitespace;
+    private scanNumber;
+    /**
+     * Scans an identifier using full-accumulation: collects all consecutive
+     * alpha characters, then classifies the result against known keywords.
+     *
+     * Special cases run before/after the accumulation loop:
+     * - `dF` / `Df` / `dF` / `DF` produces DICE_FATE. Must be handled BEFORE
+     *   the loop because `F` is alpha and would otherwise be greedily merged
+     *   into identifiers like `dfkh` (from `4dFkh2`) or `dfdf` (from `dFdF`).
+     *   Reserves the `d[fF]` prefix namespace for Fate dice.
+     * - Bare `d` followed by `%` produces DICE_PERCENT. `%` is not alpha so the
+     *   accumulation loop stops naturally and the post-loop check handles it.
+     */
+    private scanIdentifier;
+    /**
+     * Scans a variable reference introduced by `@`.
+     *
+     * Two forms:
+     * - Bare: `@name` where `name` matches `[A-Za-z_][A-Za-z0-9_]*` (case preserved).
+     * - Braced: `@{name}` where `name` is any run of printable characters except
+     *   `}` and newline (permits spaces, hyphens, digits).
+     *
+     * Case is preserved — distinct from `scanIdentifier`, which lowercases the
+     * captured value. The emitted token's `value` is the variable name without
+     * the leading `@` or the surrounding braces.
+     */
+    private scanAt;
+    private peek;
+    private peekNext;
+    private advance;
+    private match;
+    private isAtEnd;
+    private isDigit;
+    private isAlpha;
+    private isIdentifierStart;
+    private isIdentifierPart;
+    private isWhitespace;
+    private createToken;
+    private createTokenAt;
+}
+/**
+ * Tokenize a dice notation string.
+ *
+ * @param input - The dice notation to tokenize
+ * @returns Array of tokens including EOF
+ * @throws {LexerError} If an invalid character is encountered
+ *
+ * @example
+ * ```typescript
+ * const tokens = lex('2d20+5');
+ * // [NUMBER(2), DICE, NUMBER(20), PLUS, NUMBER(5), EOF]
+ * ```
+ */
+export declare function lex(input: string): Token[];
+//# sourceMappingURL=lexer.d.ts.map

package/dist/lexer/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../src/lexer/lexer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,qBAAa,UAAW,SAAQ,eAAe;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAM5F;AA2CD;;;;;GAKG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACH,QAAQ,IAAI,KAAK,EAAE;IAYnB;;OAEG;IACH,SAAS,IAAI,KAAK;IAuFlB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,UAAU;IAoBlB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAqCtB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM;IA+Bd,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAOb,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,aAAa;CAGtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAE1C"}

package/dist/lexer/tokens.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Token type definitions for the dice notation lexer.
+ *
+ * @module lexer/tokens
+ */
+/**
+ * Token types for dice notation.
+ *
+ * Grouped semantically. Numeric values are stable identifiers — the specific
+ * numbers don't matter, but they must be unique.
+ */
+export declare enum TokenType {
+    /** Numeric literal: integer or decimal */
+    NUMBER = 0,
+    /** Dice operator: 'd' or 'D' */
+    DICE = 1,
+    /** Percentile dice operator: 'd%' (alias for d100) */
+    DICE_PERCENT = 2,
+    /** Fate/Fudge dice operator: 'dF' */
+    DICE_FATE = 3,
+    /** Addition operator: '+' */
+    PLUS = 4,
+    /** Subtraction operator: '-' */
+    MINUS = 5,
+    /** Multiplication operator: '*' */
+    MULTIPLY = 6,
+    /** Division operator: '/' */
+    DIVIDE = 7,
+    /** Modulo operator: '%' */
+    MODULO = 8,
+    /** Power operator: '**' or '^' */
+    POWER = 9,
+    /** Greater than: '>' */
+    GREATER = 10,
+    /** Greater than or equal: '>=' */
+    GREATER_EQUAL = 11,
+    /** Less than: '<' */
+    LESS = 12,
+    /** Less than or equal: '<=' */
+    LESS_EQUAL = 13,
+    /** Equal: '=' */
+    EQUAL = 14,
+    /** Left parenthesis: '(' */
+    LPAREN = 15,
+    /** Right parenthesis: ')' */
+    RPAREN = 16,
+    /** Argument separator: ',' */
+    COMMA = 17,
+    /** Keep highest modifier: 'kh' or 'k' */
+    KEEP_HIGH = 18,
+    /** Keep lowest modifier: 'kl' */
+    KEEP_LOW = 19,
+    /** Drop highest modifier: 'dh' */
+    DROP_HIGH = 20,
+    /** Drop lowest modifier: 'dl' */
+    DROP_LOW = 21,
+    /** Standard explode: '!' */
+    EXPLODE = 22,
+    /** Compounding explode: '!!' */
+    EXPLODE_COMPOUND = 23,
+    /** Penetrating explode: '!p' */
+    EXPLODE_PENETRATING = 24,
+    /** Recursive reroll: 'r' */
+    REROLL = 25,
+    /** Reroll once: 'ro' */
+    REROLL_ONCE = 26,
+    /** Fail marker: 'f' */
+    FAIL = 27,
+    /** Math function: 'floor', 'ceil', 'round', 'abs', 'max', 'min' */
+    FUNCTION = 28,
+    /** Versus operator: 'vs' */
+    VS = 29,
+    /** Left brace: '{' */
+    LBRACE = 30,
+    /** Right brace: '}' */
+    RBRACE = 31,
+    /** Variable reference prefix: '@' */
+    AT = 32,
+    /** Ascending sort: 's' or 'sa' */
+    SORT_ASC = 33,
+    /** Descending sort: 'sd' */
+    SORT_DESC = 34,
+    /** Critical success threshold: 'cs' */
+    CRIT_SUCCESS = 35,
+    /** Critical failure threshold: 'cf' */
+    CRIT_FAIL = 36,
+    /** End of input marker */
+    EOF = 37
+}
+/**
+ * A token produced by the lexer.
+ */
+export type Token = {
+    /** The type of this token */
+    type: TokenType;
+    /** The raw string value from input (lowercased for identifiers) */
+    value: string;
+    /** Zero-based start offset in the input string (UTF-16 code units) */
+    position: number;
+    /**
+     * Zero-based end offset (exclusive). Not always `position + value.length` —
+     * braced variables (`@{name}` stores only `name`) and case-normalized
+     * identifiers consume more input than their `value` retains.
+     */
+    end: number;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/dist/lexer/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/lexer/tokens.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,oBAAY,SAAS;IAKnB,0CAA0C;IAC1C,MAAM,IAAI;IAMV,gCAAgC;IAChC,IAAI,IAAI;IACR,sDAAsD;IACtD,YAAY,IAAI;IAChB,qCAAqC;IACrC,SAAS,IAAI;IAMb,6BAA6B;IAC7B,IAAI,IAAI;IACR,gCAAgC;IAChC,KAAK,IAAI;IACT,mCAAmC;IACnC,QAAQ,IAAI;IACZ,6BAA6B;IAC7B,MAAM,IAAI;IACV,2BAA2B;IAC3B,MAAM,IAAI;IACV,kCAAkC;IAClC,KAAK,IAAI;IAMT,wBAAwB;IACxB,OAAO,KAAK;IACZ,kCAAkC;IAClC,aAAa,KAAK;IAClB,qBAAqB;IACrB,IAAI,KAAK;IACT,+BAA+B;IAC/B,UAAU,KAAK;IACf,iBAAiB;IACjB,KAAK,KAAK;IAMV,4BAA4B;IAC5B,MAAM,KAAK;IACX,6BAA6B;IAC7B,MAAM,KAAK;IACX,8BAA8B;IAC9B,KAAK,KAAK;IAMV,yCAAyC;IACzC,SAAS,KAAK;IACd,iCAAiC;IACjC,QAAQ,KAAK;IACb,kCAAkC;IAClC,SAAS,KAAK;IACd,iCAAiC;IACjC,QAAQ,KAAK;IAMb,4BAA4B;IAC5B,OAAO,KAAK;IACZ,gCAAgC;IAChC,gBAAgB,KAAK;IACrB,gCAAgC;IAChC,mBAAmB,KAAK;IAMxB,4BAA4B;IAC5B,MAAM,KAAK;IACX,wBAAwB;IACxB,WAAW,KAAK;IAMhB,uBAAuB;IACvB,IAAI,KAAK;IAMT,mEAAmE;IACnE,QAAQ,KAAK;IAMb,4BAA4B;IAC5B,EAAE,KAAK;IAMP,sBAAsB;IACtB,MAAM,KAAK;IACX,uBAAuB;IACvB,MAAM,KAAK;IAMX,qCAAqC;IACrC,EAAE,KAAK;IAMP,kCAAkC;IAClC,QAAQ,KAAK;IACb,4BAA4B;IAC5B,SAAS,KAAK;IAMd,uCAAuC;IACvC,YAAY,KAAK;IACjB,uCAAuC;IACvC,SAAS,KAAK;IAMd,0BAA0B;IAC1B,GAAG,KAAK;CACT;AAED;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,6BAA6B;IAC7B,IAAI,EAAE,SAAS,CAAC;IAChB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/parser/ast.d.ts

@@ -0,0 +1,368 @@
+/**
+ * AST node type definitions for the dice notation parser.
+ *
+ * @module parser/ast
+ */
+import type { ComparePoint } from '../types.js';
+/**
+ * Source span carried by every AST node.
+ *
+ * `start` is inclusive, `end` exclusive, both in UTF-16 code units into the
+ * original notation string. The parser sets both on every node it produces;
+ * they are typed optional so hand-constructed ASTs (tests, programmatic
+ * consumers) remain valid without positions.
+ */
+export type NodeSpan = {
+    start?: number;
+    end?: number;
+};
+/**
+ * Numeric literal node.
+ */
+export type LiteralNode = NodeSpan & {
+    type: 'Literal';
+    value: number;
+};
+/**
+ * Dice roll node.
+ * Count and sides can be expressions to support computed dice like (1+1)d(3*2).
+ */
+export type DiceNode = NodeSpan & {
+    type: 'Dice';
+    count: ASTNode;
+    sides: ASTNode;
+};
+/**
+ * Fate/Fudge dice node (`dF`).
+ * Each die produces a result in {-1, 0, +1}. No configurable sides.
+ */
+export type FateDiceNode = NodeSpan & {
+    type: 'FateDice';
+    count: ASTNode;
+};
+/**
+ * Binary operation node.
+ */
+export type BinaryOpNode = NodeSpan & {
+    type: 'BinaryOp';
+    operator: '+' | '-' | '*' | '/' | '%' | '**';
+    left: ASTNode;
+    right: ASTNode;
+};
+/**
+ * Unary operation node.
+ */
+export type UnaryOpNode = NodeSpan & {
+    type: 'UnaryOp';
+    operator: '-';
+    operand: ASTNode;
+};
+/**
+ * Keep/drop modifier node.
+ * Wraps a dice expression with keep highest/lowest or drop highest/lowest.
+ */
+export type ModifierNode = NodeSpan & {
+    type: 'Modifier';
+    modifier: 'keep' | 'drop';
+    selector: 'highest' | 'lowest';
+    count: ASTNode;
+    target: ASTNode;
+};
+/**
+ * Exploding dice node (`!`, `!!`, `!p`, `!>Y`).
+ * Wraps a dice expression with a standard, compounding, or penetrating
+ * explosion. An absent `threshold` means "explode on the die's maximum face".
+ */
+export type ExplodeNode = NodeSpan & {
+    type: 'Explode';
+    variant: 'standard' | 'compound' | 'penetrating';
+    threshold?: ComparePoint;
+    target: ASTNode;
+};
+/**
+ * Reroll node (`r<COND>`, `ro<COND>`).
+ * Re-rolls dice that match a comparison condition. `once: true` for `ro`
+ * keeps the second result regardless of match; `once: false` for `r`
+ * re-rolls recursively until the condition no longer matches.
+ */
+export type RerollNode = NodeSpan & {
+    type: 'Reroll';
+    once: boolean;
+    condition: ComparePoint;
+    target: ASTNode;
+};
+/**
+ * Success counting node (`>=T`, `>T`, `<T`, `<=T`, `=T`, with optional `f=F`).
+ *
+ * Transforms a dice pool into a success count: each die meeting `threshold`
+ * adds +1, each die meeting `failThreshold` subtracts 1. Terminal — a
+ * `SuccessCountNode` may not be wrapped by any postfix modifier, binary
+ * operator, unary operator, versus operand, or function argument. The
+ * `failThreshold` accepts any `CompareOp`; bare `fN` defaults to `operator: '='`.
+ */
+export type SuccessCountNode = NodeSpan & {
+    type: 'SuccessCount';
+    target: ASTNode;
+    threshold: ComparePoint;
+    failThreshold?: ComparePoint;
+};
+/**
+ * Versus node (`<roll> vs <dc>`) — PF2e Degrees of Success.
+ *
+ * Both sides are full expressions. The `roll` side is evaluated and compared
+ * against the `dc` side total, producing a `DegreeOfSuccess` with natural
+ * d20 upgrade/downgrade applied when exactly one kept d20 appears on the
+ * roll side. Lowest-precedence operator — chaining (`a vs b vs c`) is
+ * rejected at parse time; nesting via parens (`a vs (b vs c)`) is rejected
+ * at evaluation time.
+ */
+export type VersusNode = NodeSpan & {
+    type: 'Versus';
+    roll: ASTNode;
+    dc: ASTNode;
+};
+/**
+ * Math function call node (`floor(expr)`, `max(a, b, ...)`, etc.).
+ *
+ * Supports the fixed-arity functions `floor`, `ceil`, `round`, `abs`, and the
+ * variadic functions `max`, `min` (minimum 2 args). Arity is validated at
+ * parse time against a static table; by the time the evaluator sees a
+ * `FunctionCallNode`, `args.length` is guaranteed to match the function.
+ */
+export type FunctionCallNode = NodeSpan & {
+    type: 'FunctionCall';
+    name: string;
+    args: ASTNode[];
+};
+/**
+ * Parenthesized group node (`(<expr>)`).
+ *
+ * Preserves explicit grouping typed by the user so that
+ * `RollResult.expression` and `RollResult.rendered` round-trip through
+ * `parse` without losing precedence information. Semantically transparent:
+ * evaluation returns the inner expression's value unchanged.
+ */
+export type GroupedNode = NodeSpan & {
+    type: 'Grouped';
+    expression: ASTNode;
+};
+/**
+ * Variable reference node (`@name` or `@{name with spaces}`).
+ *
+ * Resolves to a numeric value from the evaluator's `context` map at
+ * evaluation time. Names are case-sensitive (`@StrMod` ≠ `@strmod`) — the
+ * lexer preserves case in the `AT` token's `value`, distinct from other
+ * identifier tokens which lowercase. Leaf node — no LED, never wraps a
+ * sub-expression.
+ */
+export type VariableNode = NodeSpan & {
+    type: 'Variable';
+    name: string;
+};
+/**
+ * Grouped-roll node (`{expr}`, `{expr1, expr2, ...}`).
+ *
+ * Distinct from `GroupedNode` (parenthesized wrapper) — a `GroupNode`
+ * collects one or more sub-expressions whose evaluation semantics change
+ * with the sub-roll count. `expressions.length === 1` is a passthrough
+ * (flat-pool when wrapped by keep/drop); `expressions.length >= 2` treats
+ * each sub-roll's subtotal as a compound die for keep/drop selection.
+ */
+export type GroupNode = NodeSpan & {
+    type: 'Group';
+    expressions: ASTNode[];
+};
+/**
+ * Sort modifier node (`s`, `sa`, `sd`).
+ *
+ * Cosmetically reorders the dice produced by `target` in ascending or
+ * descending order. Purely visual — does not affect `total`,
+ * `successes`/`failures`, or any die-level flag (`kept`/`dropped`/
+ * `critical`/`fumble`). Dropped dice retain their `dropped` flag and
+ * appear in sorted position alongside kept dice.
+ */
+export type SortNode = NodeSpan & {
+    type: 'Sort';
+    order: 'ascending' | 'descending';
+    target: ASTNode;
+};
+/**
+ * Sentinel for bare `cs` / `cf` without a ComparePoint. Resolved to
+ * `result === sides` (for critical) or `result === 1` (for fumble) at
+ * evaluation time, using each die's own `sides`.
+ */
+export type CritThreshold = ComparePoint | 'default';
+/**
+ * Critical threshold modifier node (`cs`, `cf`).
+ *
+ * Overrides the default `critical`/`fumble` flag logic for the dice
+ * produced by `target`. Bare `cs`/`cf` uses the `'default'` sentinel
+ * (max face / 1). Custom thresholds accept any ComparePoint. Chaining
+ * collapses into a single node — `1d20cs=20cs=1cf>18` has two success
+ * and one fail threshold. Display-only: does not change `total`,
+ * explosion triggers, or success counting. `cs` and `cf` are independent
+ * overrides — a side with no explicit thresholds keeps the default rule
+ * (the evaluator substitutes the `'default'` sentinel at apply time).
+ */
+export type CritThresholdNode = NodeSpan & {
+    type: 'CritThreshold';
+    successThresholds: CritThreshold[];
+    failThresholds: CritThreshold[];
+    target: ASTNode;
+};
+/**
+ * Union type of all AST nodes.
+ */
+export type ASTNode = LiteralNode | DiceNode | FateDiceNode | BinaryOpNode | UnaryOpNode | ModifierNode | ExplodeNode | RerollNode | SuccessCountNode | VersusNode | FunctionCallNode | GroupedNode | VariableNode | GroupNode | SortNode | CritThresholdNode;
+/**
+ * Type guard for LiteralNode.
+ */
+export declare function isLiteral(node: ASTNode): node is LiteralNode;
+/**
+ * Type guard for DiceNode.
+ */
+export declare function isDice(node: ASTNode): node is DiceNode;
+/**
+ * Type guard for FateDiceNode.
+ */
+export declare function isFateDice(node: ASTNode): node is FateDiceNode;
+/**
+ * Type guard for BinaryOpNode.
+ */
+export declare function isBinaryOp(node: ASTNode): node is BinaryOpNode;
+/**
+ * Type guard for UnaryOpNode.
+ */
+export declare function isUnaryOp(node: ASTNode): node is UnaryOpNode;
+/**
+ * Type guard for ModifierNode.
+ */
+export declare function isModifier(node: ASTNode): node is ModifierNode;
+/**
+ * Type guard for ExplodeNode.
+ */
+export declare function isExplode(node: ASTNode): node is ExplodeNode;
+/**
+ * Type guard for RerollNode.
+ */
+export declare function isReroll(node: ASTNode): node is RerollNode;
+/**
+ * Type guard for SuccessCountNode.
+ */
+export declare function isSuccessCount(node: ASTNode): node is SuccessCountNode;
+/**
+ * Type guard for VersusNode.
+ */
+export declare function isVersus(node: ASTNode): node is VersusNode;
+/**
+ * Type guard for FunctionCallNode.
+ */
+export declare function isFunctionCall(node: ASTNode): node is FunctionCallNode;
+/**
+ * Type guard for GroupedNode.
+ */
+export declare function isGrouped(node: ASTNode): node is GroupedNode;
+/**
+ * Type guard for VariableNode.
+ */
+export declare function isVariable(node: ASTNode): node is VariableNode;
+/**
+ * Type guard for GroupNode.
+ */
+export declare function isGroup(node: ASTNode): node is GroupNode;
+/**
+ * Type guard for SortNode.
+ */
+export declare function isSort(node: ASTNode): node is SortNode;
+/**
+ * Type guard for CritThresholdNode.
+ */
+export declare function isCritThreshold(node: ASTNode): node is CritThresholdNode;
+/**
+ * Wrapper kinds that `unwrapTransparent` can peel.
+ *
+ * "Transparent" is relative to the question being asked. `Modifier`/`Sort`/
+ * `CritThreshold` are transparent for "what is the underlying operand?" when
+ * deciding whether to reject a `Group` target — they preserve `containsDicePool`'s
+ * answer for whatever they wrap. They are NOT transparent for "is this a
+ * `SuccessCount`?" or "is this a `Versus`?", because the parsers that build
+ * those wrappers already reject `SuccessCount`/`Versus` operands upstream.
+ */
+export type TransparentWrapperKind = 'Grouped' | 'Modifier' | 'Sort' | 'CritThreshold';
+/**
+ * Walks `node` while its `.type` is in `kinds`, returning the first descendant
+ * that is not one of the listed wrappers. Each caller picks the subset that
+ * matches its rejection semantics — see `TransparentWrapperKind` for guidance.
+ *
+ * Used by parser reject helpers to look past wrappers when deciding whether
+ * an operand violates a rule (e.g., `Group` cannot be the target of `cs`/`cf`,
+ * even when wrapped in `Modifier` like `{1d6}kh1cs>5`).
+ */
+export declare function unwrapTransparent(node: ASTNode, kinds: readonly TransparentWrapperKind[]): ASTNode;
+/**
+ * Returns `true` only when `node`'s direct result is a dice pool —
+ * `Dice`, `FateDice`, or a chained pool modifier (`Modifier` / `Explode` /
+ * `Reroll`). Does NOT recurse through arithmetic wrappers (`BinaryOp`,
+ * `UnaryOp`, `FunctionCall`), so `(1d6+5)` and `floor(1d6/2)` are rejected.
+ *
+ * Used by the parser to reject postfix pool-modifier targets (kh/kl/dh/dl,
+ * !/!!/!p, r/ro) that wrap a non-pool expression. Operating on the inner
+ * dice pool would silently drop the surrounding arithmetic.
+ */
+export declare function containsDicePool(node: ASTNode): boolean;
+/**
+ * Deeper variant of `containsDicePool` that recurses through arithmetic and
+ * function wrappers. Used from the `Group` case above (ordinary parenthesized
+ * arithmetic `(1d6+5)kh1` must still reject, so the shallow `containsDicePool`
+ * handles those directly) and from the Sort parser guard (sort accepts
+ * `(1d6+2d8)s` per Stage 3 spec).
+ */
+export declare function deepContainsDicePool(node: ASTNode): boolean;
+/**
+ * Returns `true` if the pool this node resolves to is (or wraps) a `FateDice`
+ * pool. Walks through chained pool modifiers (`Modifier` / `Explode` /
+ * `Reroll`) but not arithmetic wrappers — callers should run
+ * `containsDicePool` first to reject those.
+ *
+ * Used by the parser to reject `!`, `!!`, `!p` applied to Fate pools
+ * (`4dF!`, `(4dF)kh2!`, etc.). Fate explosion semantics are undefined, so
+ * parse-time rejection is preferred over a silent evaluator no-op.
+ *
+ * Inside a `Group`, recursion uses `deepContainsFatePool` to mirror
+ * `containsDicePool`'s deep walk through the same case — otherwise
+ * `{4dF+1d6}cf` slips past the bare-Fate guard and the default fumble
+ * check (`result === 1`) flips `+1` faces into fumbles.
+ */
+export declare function containsFatePool(node: ASTNode): boolean;
+/**
+ * Deeper variant of `containsFatePool` that recurses through arithmetic and
+ * function wrappers. Mirrors `deepContainsDicePool`. Used from
+ * `containsFatePool`'s `Group` case so single-sub-roll groups containing
+ * arithmetic-wrapped Fate (`{4dF+1d6}cf`) still trip the bare-Fate guard.
+ *
+ * Outside a `Group`, ordinary parenthesized arithmetic (`(4dF+1d6)cf`) is
+ * already rejected upstream by shallow `containsDicePool`, so this helper
+ * intentionally stays Group-internal.
+ */
+export declare function deepContainsFatePool(node: ASTNode): boolean;
+/**
+ * Deep-walks a node to find any descendant `Group` with two or more
+ * sub-expressions. Used by `rejectGroupTarget`'s single-sub-roll
+ * passthrough so a multi-sub Group buried under arithmetic
+ * (`{{1d6,2d8}+0}cs>5`), function calls (`{abs({1d6,2d8})}cs>5`), or any
+ * other non-transparent wrapper still rejects with the same error code.
+ *
+ * Without this walk, the unwrap inside `rejectGroupTarget` only peels
+ * `Grouped`/`Modifier`/`Sort`/`CritThreshold` — a multi-sub Group cloaked
+ * in a `BinaryOp`/`UnaryOp`/`FunctionCall` revives issue #97.
+ */
+export declare function containsMultiSubGroup(node: ASTNode): boolean;
+/**
+ * Deep-walks a node to find any descendant `Versus`. Used by
+ * `rejectVersusTarget`'s single-sub-roll Group passthrough so a buried
+ * Versus (`{1+(1d20 vs 15)}cs>18`, `{abs(1d20 vs 15)}cs>18`,
+ * `{-(1d20 vs 15)}kh1`) still rejects with `NESTED_VERSUS` instead of
+ * silently dropping `versusMetadata` at the modifier consumer site.
+ */
+export declare function containsVersus(node: ASTNode): boolean;
+//# sourceMappingURL=ast.d.ts.map

package/dist/parser/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/parser/ast.ts"],"names":[],"mappings":"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"}