roll-parser 3.0.0-alpha.0 → 3.0.0

package/dist/parser/ast.d.ts

@@ -3,95 +3,196 @@
  *
  * @module parser/ast
  */
-import type { ComparePoint } from '../types';
+import type { ComparePoint } from '../types.js';
 /**
- * Numeric literal node.
+ * 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.
+ *
+ * `notation.slice(start, end)` recovers the source text of any parsed node,
+ * which is how the CLI underlines the failing sub-expression.
+ *
+ * @category AST
  */
-export type LiteralNode = {
-    type: 'Literal';
-    value: number;
+export type NodeSpan = {
+    readonly start?: number;
+    readonly end?: number;
 };
 /**
- * Dice roll node.
- * Count and sides can be expressions to support computed dice like (1+1)d(3*2).
+ * Numeric literal node — an integer or decimal written directly in the
+ * notation (`3`, `2.5`). Leaf node.
+ *
+ * Decimals are accepted and carried through arithmetic exactly as written;
+ * only dice counts and sides are required to resolve to integers.
+ *
+ * @category AST
  */
-export type DiceNode = {
-    type: 'Dice';
-    count: ASTNode;
-    sides: ASTNode;
+export type LiteralNode = NodeSpan & {
+    readonly type: 'Literal';
+    readonly value: number;
+};
+/**
+ * Dice roll node (`NdX`, `dX`, `d%`).
+ *
+ * `count` and `sides` are full sub-expressions, not numbers, which is what
+ * makes computed dice like `(1+1)d(3*2)` and `(1d4)d6` expressible. Both are
+ * evaluated first and must resolve to integers; `d%` desugars to a `sides`
+ * literal of `100`, and an omitted count to a `count` literal of `1`.
+ *
+ * Dice rolled by the `count`/`sides` sub-expressions are meta-expression dice
+ * — they land in `RollResult.rolls` tagged `'meta'` and belong to no pool.
+ *
+ * @category AST
+ */
+export type DiceNode = NodeSpan & {
+    readonly type: 'Dice';
+    readonly count: ASTNode;
+    readonly sides: ASTNode;
 };
 /**
  * Fate/Fudge dice node (`dF`).
  * Each die produces a result in {-1, 0, +1}. No configurable sides.
+ *
+ * Fate dice carry `sides: 0` as a sentinel in their `DieResult`, and are
+ * never `critical` or `fumble` — there is no maximum face to hit.
+ *
+ * @category AST
  */
-export type FateDiceNode = {
-    type: 'FateDice';
-    count: ASTNode;
+export type FateDiceNode = NodeSpan & {
+    readonly type: 'FateDice';
+    readonly count: ASTNode;
 };
 /**
- * Binary operation node.
+ * Binary operation node — the arithmetic backbone of an expression.
+ *
+ * | Operator | Meaning | Precedence | Associativity |
+ * |----------|---------|-----------:|---------------|
+ * | `+` `-` | add, subtract | 10 | left |
+ * | `*` `/` `%` | multiply, divide, modulo | 20 | left |
+ * | `**` | power (also spelled `^`) | 30 | right |
+ *
+ * Dice bind tighter than all of them (40), and postfix modifiers sit at 35,
+ * so `2d6+3` is `(2d6)+3` and `4d6kh3*2` is `(4d6kh3)*2`. The `vs` operator
+ * binds loosest of all (2) and has its own {@link VersusNode}.
+ *
+ * `/` and `%` throw `DIVISION_BY_ZERO` / `MODULO_BY_ZERO` on a zero right
+ * side; any operator producing a non-finite total throws `NON_FINITE_RESULT`.
+ * Division is not rounded — wrap it in `floor()` if you need an integer.
+ *
+ * @category AST
  */
-export type BinaryOpNode = {
-    type: 'BinaryOp';
-    operator: '+' | '-' | '*' | '/' | '%' | '**';
-    left: ASTNode;
-    right: ASTNode;
+export type BinaryOpNode = NodeSpan & {
+    readonly type: 'BinaryOp';
+    readonly operator: '+' | '-' | '*' | '/' | '%' | '**';
+    readonly left: ASTNode;
+    readonly right: ASTNode;
 };
 /**
- * Unary operation node.
+ * Unary operation node — prefix negation, the only unary operator.
+ *
+ * Binding power 25 sits between multiplication and power, so `-1d4` is
+ * `-(1d4)` (negate the roll) rather than `(-1)d4`, while `-2**2` is `-(2**2)`.
+ *
+ * @category AST
  */
-export type UnaryOpNode = {
-    type: 'UnaryOp';
-    operator: '-';
-    operand: ASTNode;
+export type UnaryOpNode = NodeSpan & {
+    readonly type: 'UnaryOp';
+    readonly operator: '-';
+    readonly operand: ASTNode;
 };
 /**
- * Keep/drop modifier node.
+ * Keep/drop modifier node (`khN`, `klN`, `dhN`, `dlN`, and the `kN`
+ * shorthand for `khN`).
+ *
  * Wraps a dice expression with keep highest/lowest or drop highest/lowest.
+ * An omitted count defaults to 1, so `4d6kh` is `4d6kh1`. `count` is a full
+ * sub-expression, so `4d6kh(1d2)` is legal — and its dice are drawn *before*
+ * the pool.
+ *
+ * Chained modifiers (`4d6kh3dl1`) do not nest: the evaluator flattens the
+ * chain and applies each spec independently to the same pool, unioning the
+ * dropped sets, which is the Roll20 rule.
+ *
+ * @category AST
  */
-export type ModifierNode = {
-    type: 'Modifier';
-    modifier: 'keep' | 'drop';
-    selector: 'highest' | 'lowest';
-    count: ASTNode;
-    target: ASTNode;
+export type KeepDropNode = NodeSpan & {
+    readonly type: 'KeepDrop';
+    readonly kind: 'keep' | 'drop';
+    readonly selector: 'highest' | 'lowest';
+    readonly count: ASTNode;
+    readonly 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".
+ *
+ * Thresholds accept any comparator. In notation like `1d10!=10` (the
+ * Storyteller "10-again" rule) the `!` is the explode marker and `=10` the
+ * equality threshold — there is no `!=` comparator. Per-die explosion count
+ * is capped by `EvaluationOptions.maxExplodeIterations`.
+ *
+ * @category AST
  */
-export type ExplodeNode = {
-    type: 'Explode';
-    variant: 'standard' | 'compound' | 'penetrating';
-    threshold?: ComparePoint;
-    target: ASTNode;
+export type ExplodeNode = NodeSpan & {
+    readonly type: 'Explode';
+    readonly variant: 'standard' | 'compound' | 'penetrating';
+    readonly threshold?: ComparePoint;
+    readonly 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.
+ * re-rolls recursively until the condition no longer matches, bounded by
+ * `EvaluationOptions.maxRerollIterations`.
+ *
+ * @category AST
+ */
+export type RerollNode = NodeSpan & {
+    readonly type: 'Reroll';
+    readonly once: boolean;
+    readonly condition: ComparePoint;
+    readonly target: ASTNode;
+};
+/**
+ * Per-die clamp node (`minN`, `maxN`).
+ * `4d6min2` raises every die below 2 to 2; `4d6max5` lowers every die above
+ * 5 to 5. The clamp rewrites `DieResult.result` (preserving the raw face in
+ * `initialResult`) and re-sums the pool; `critical`/`fumble` keep reflecting
+ * the natural face. The bound is a full sub-expression (`4d6min(1d2)`),
+ * drawn *after* the pool like other threshold arguments.
+ *
+ * Chained bounds nest and apply left to right: `4d6min2max5` clamps into
+ * [2, 5].
+ *
+ * @category AST
  */
-export type RerollNode = {
-    type: 'Reroll';
-    once: boolean;
-    condition: ComparePoint;
+export type DieBoundNode = NodeSpan & {
+    type: 'DieBound';
+    bound: 'min' | 'max';
+    value: ASTNode;
     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 — no further
- * postfix modifiers may wrap a `SuccessCountNode`. The `failThreshold`
- * operator is always `=` (fail on an exact value).
+ * 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: '='`.
+ *
+ * @category AST
  */
-export type SuccessCountNode = {
-    type: 'SuccessCount';
-    target: ASTNode;
-    threshold: ComparePoint;
-    failThreshold?: ComparePoint;
+export type SuccessCountNode = NodeSpan & {
+    readonly type: 'SuccessCount';
+    readonly target: ASTNode;
+    readonly threshold: ComparePoint;
+    readonly failThreshold?: ComparePoint;
 };
 /**
  * Versus node (`<roll> vs <dc>`) — PF2e Degrees of Success.
@@ -102,11 +203,13 @@ export type SuccessCountNode = {
  * 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.
+ *
+ * @category AST
  */
-export type VersusNode = {
-    type: 'Versus';
-    roll: ASTNode;
-    dc: ASTNode;
+export type VersusNode = NodeSpan & {
+    readonly type: 'Versus';
+    readonly roll: ASTNode;
+    readonly dc: ASTNode;
 };
 /**
  * Math function call node (`floor(expr)`, `max(a, b, ...)`, etc.).
@@ -115,69 +218,305 @@ export type VersusNode = {
  * 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.
+ *
+ * `max`/`min` are variadic with no upper bound, so `max(1d20, 1d20, 1d20)`
+ * is a valid three-way advantage roll.
+ *
+ * @category AST
+ */
+export type FunctionCallNode = NodeSpan & {
+    readonly type: 'FunctionCall';
+    readonly name: string;
+    readonly args: readonly 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.
+ *
+ * @category AST
+ */
+export type GroupedNode = NodeSpan & {
+    readonly type: 'Grouped';
+    readonly 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.
+ *
+ * A name missing from `context` throws `UNDEFINED_VARIABLE` unless
+ * `onMissingVariable: 'zero'` is set.
+ *
+ * @category AST
+ */
+export type VariableNode = NodeSpan & {
+    readonly type: 'Variable';
+    readonly 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.
+ *
+ * @category AST
+ */
+export type GroupNode = NodeSpan & {
+    readonly type: 'Group';
+    readonly expressions: readonly 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.
+ *
+ * `s` and `sa` both mean ascending; `sd` is descending.
+ *
+ * @category AST
  */
-export type FunctionCallNode = {
-    type: 'FunctionCall';
-    name: string;
-    args: ASTNode[];
+export type SortNode = NodeSpan & {
+    readonly type: 'Sort';
+    readonly order: 'ascending' | 'descending';
+    readonly target: ASTNode;
 };
 /**
- * Union type of all AST nodes.
+ * 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`.
+ *
+ * @category AST
  */
-export type ASTNode = LiteralNode | DiceNode | FateDiceNode | BinaryOpNode | UnaryOpNode | ModifierNode | ExplodeNode | RerollNode | SuccessCountNode | VersusNode | FunctionCallNode;
+export type CritThreshold = ComparePoint | 'default';
 /**
- * Type guard for LiteralNode.
+ * 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).
+ *
+ * @category AST
+ */
+export type CritThresholdNode = NodeSpan & {
+    readonly type: 'CritThreshold';
+    readonly successThresholds: readonly CritThreshold[];
+    readonly failThresholds: readonly CritThreshold[];
+    readonly target: ASTNode;
+};
+/**
+ * Discriminated union of all 17 AST node types — what {@link parse} returns
+ * and what {@link evaluate} consumes.
+ *
+ * Narrow it either by switching on `node.type` (PascalCase discriminants, as
+ * opposed to the camelCase ones on {@link RollPart}) or with the exported
+ * type guards: {@link isLiteral}, {@link isDice}, {@link isFateDice},
+ * {@link isBinaryOp}, {@link isUnaryOp}, {@link isKeepDrop},
+ * {@link isExplode}, {@link isReroll}, {@link isDieBound},
+ * {@link isSuccessCount}, {@link isVersus}, {@link isFunctionCall},
+ * {@link isGrouped}, {@link isVariable}, {@link isGroup}, {@link isSort},
+ * {@link isCritThreshold}.
+ *
+ * Nodes are plain data with no methods, so they are structurally clonable and
+ * safe to cache. Every parser-produced node carries a {@link NodeSpan}.
+ *
+ * @example A guard-based walker — count the dice an expression can roll
+ * ```typescript
+ * import {
+ *   type ASTNode, isBinaryOp, isDice, isFateDice, isGroup, isGrouped,
+ *   isFunctionCall, isLiteral, isUnaryOp, isVersus, parse,
+ * } from 'roll-parser';
+ *
+ * function countPools(node: ASTNode): number {
+ *   if (isDice(node) || isFateDice(node)) return 1;
+ *   if (isLiteral(node)) return 0;
+ *   if (isBinaryOp(node)) return countPools(node.left) + countPools(node.right);
+ *   if (isUnaryOp(node)) return countPools(node.operand);
+ *   if (isGrouped(node)) return countPools(node.expression);
+ *   if (isVersus(node)) return countPools(node.roll) + countPools(node.dc);
+ *   if (isGroup(node)) return node.expressions.reduce((n, e) => n + countPools(e), 0);
+ *   if (isFunctionCall(node)) return node.args.reduce((n, a) => n + countPools(a), 0);
+ *   // Every remaining variant is a postfix modifier wrapping `target`.
+ *   return 'target' in node ? countPools(node.target) : 0;
+ * }
+ *
+ * countPools(parse('2d6+3')); // 1
+ * countPools(parse('{2d20kh1+5, 3d8!}kh1')); // 2
+ * countPools(parse('1+2')); // 0
+ * ```
+ *
+ * @category AST
+ */
+export type ASTNode = LiteralNode | DiceNode | FateDiceNode | BinaryOpNode | UnaryOpNode | KeepDropNode | ExplodeNode | RerollNode | DieBoundNode | SuccessCountNode | VersusNode | FunctionCallNode | GroupedNode | VariableNode | GroupNode | SortNode | CritThresholdNode;
+/**
+ * Narrows an {@link ASTNode} to a numeric literal (`3`, `2.5`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link LiteralNode}
+ *
+ * @category AST
  */
 export declare function isLiteral(node: ASTNode): node is LiteralNode;
 /**
- * Type guard for DiceNode.
+ * Narrows an {@link ASTNode} to a dice pool (`2d6`, `d%`, `(1d4)d6`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link DiceNode}
+ *
+ * @category AST
  */
 export declare function isDice(node: ASTNode): node is DiceNode;
 /**
- * Type guard for FateDiceNode.
+ * Narrows an {@link ASTNode} to a Fate/Fudge pool (`4dF`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link FateDiceNode}
+ *
+ * @category AST
  */
 export declare function isFateDice(node: ASTNode): node is FateDiceNode;
 /**
- * Type guard for BinaryOpNode.
+ * Narrows an {@link ASTNode} to an arithmetic operation (`+ - * / % **`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link BinaryOpNode}
+ *
+ * @category AST
  */
 export declare function isBinaryOp(node: ASTNode): node is BinaryOpNode;
 /**
- * Type guard for UnaryOpNode.
+ * Narrows an {@link ASTNode} to a prefix negation (`-1d4`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link UnaryOpNode}
+ *
+ * @category AST
  */
 export declare function isUnaryOp(node: ASTNode): node is UnaryOpNode;
 /**
- * Type guard for ModifierNode.
+ * Narrows an {@link ASTNode} to a keep/drop modifier (`kh`, `kl`, `dh`, `dl`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link KeepDropNode}
+ *
+ * @category AST
  */
-export declare function isModifier(node: ASTNode): node is ModifierNode;
+export declare function isKeepDrop(node: ASTNode): node is KeepDropNode;
 /**
- * Type guard for ExplodeNode.
+ * Narrows an {@link ASTNode} to an explosion (`!`, `!!`, `!p`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link ExplodeNode}
+ *
+ * @category AST
  */
 export declare function isExplode(node: ASTNode): node is ExplodeNode;
 /**
- * Type guard for RerollNode.
+ * Narrows an {@link ASTNode} to a reroll (`r`, `ro`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link RerollNode}
+ *
+ * @category AST
  */
 export declare function isReroll(node: ASTNode): node is RerollNode;
 /**
- * Type guard for SuccessCountNode.
+ * Narrows an {@link ASTNode} to a success count (`>=6`, with optional `f1`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link SuccessCountNode}
+ *
+ * @category AST
  */
 export declare function isSuccessCount(node: ASTNode): node is SuccessCountNode;
 /**
- * Type guard for VersusNode.
+ * Narrows an {@link ASTNode} to a PF2e degree-of-success check (`vs`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link VersusNode}
+ *
+ * @category AST
  */
 export declare function isVersus(node: ASTNode): node is VersusNode;
 /**
- * Type guard for FunctionCallNode.
+ * Narrows an {@link ASTNode} to a math function call (`floor`, `max`, …).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link FunctionCallNode}
+ *
+ * @category AST
  */
 export declare function isFunctionCall(node: ASTNode): node is FunctionCallNode;
 /**
- * Returns `true` if the AST contains a `Dice` or `FateDice` node reachable
- * through structural composition (BinaryOp, UnaryOp, keep/drop, explode,
- * reroll, success-count wrappers). Meta-expressions — dice count/sides,
- * modifier counts, and ComparePoint values — are treated as leaves and
- * never recursed into.
+ * Narrows an {@link ASTNode} to a parenthesized group (`(1d6+2)`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link GroupedNode}
+ *
+ * @category AST
+ */
+export declare function isGrouped(node: ASTNode): node is GroupedNode;
+/**
+ * Narrows an {@link ASTNode} to a variable reference (`@str`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link VariableNode}
+ *
+ * @category AST
+ */
+export declare function isVariable(node: ASTNode): node is VariableNode;
+/**
+ * Narrows an {@link ASTNode} to a braced grouped roll (`{1d8, 1d10}`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link GroupNode}
+ *
+ * @category AST
+ */
+export declare function isGroup(node: ASTNode): node is GroupNode;
+/**
+ * Narrows an {@link ASTNode} to a sort modifier (`s`, `sa`, `sd`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link SortNode}
+ *
+ * @category AST
+ */
+export declare function isSort(node: ASTNode): node is SortNode;
+/**
+ * Narrows an {@link ASTNode} to a crit-threshold override (`cs`, `cf`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link CritThresholdNode}
+ *
+ * @category AST
+ */
+export declare function isCritThreshold(node: ASTNode): node is CritThresholdNode;
+/**
+ * Narrows an {@link ASTNode} to a per-die clamp (`min2`, `max5`).
+ *
+ * @param node - Any AST node
+ * @returns `true` when `node` is a {@link DieBoundNode}
  *
- * Used by the parser to reject success-counting targets that don't actually
- * roll any dice (e.g. `1>=3`, `(1+2)>=3`).
+ * @category AST
  */
-export declare function containsDice(node: ASTNode): boolean;
+export declare function isDieBound(node: ASTNode): node is DieBoundNode;
 //# sourceMappingURL=ast.d.ts.map

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

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

package/dist/parser/ast.js

@@ -0,0 +1,52 @@
+export function isLiteral(node) {
+    return node.type === 'Literal';
+}
+export function isDice(node) {
+    return node.type === 'Dice';
+}
+export function isFateDice(node) {
+    return node.type === 'FateDice';
+}
+export function isBinaryOp(node) {
+    return node.type === 'BinaryOp';
+}
+export function isUnaryOp(node) {
+    return node.type === 'UnaryOp';
+}
+export function isKeepDrop(node) {
+    return node.type === 'KeepDrop';
+}
+export function isExplode(node) {
+    return node.type === 'Explode';
+}
+export function isReroll(node) {
+    return node.type === 'Reroll';
+}
+export function isSuccessCount(node) {
+    return node.type === 'SuccessCount';
+}
+export function isVersus(node) {
+    return node.type === 'Versus';
+}
+export function isFunctionCall(node) {
+    return node.type === 'FunctionCall';
+}
+export function isGrouped(node) {
+    return node.type === 'Grouped';
+}
+export function isVariable(node) {
+    return node.type === 'Variable';
+}
+export function isGroup(node) {
+    return node.type === 'Group';
+}
+export function isSort(node) {
+    return node.type === 'Sort';
+}
+export function isCritThreshold(node) {
+    return node.type === 'CritThreshold';
+}
+export function isDieBound(node) {
+    return node.type === 'DieBound';
+}
+//# sourceMappingURL=ast.js.map

package/dist/parser/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../src/parser/ast.ts"],"names":[],"mappings":"AA+ZA,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC;AAUD,MAAM,UAAU,MAAM,CAAC,IAAa;IAClC,OAAO,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC;AAC9B,CAAC;AAUD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC;AAClC,CAAC;AAUD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC;AAClC,CAAC;AAUD,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC;AAUD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC;AAClC,CAAC;AAUD,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC;AAUD,MAAM,UAAU,QAAQ,CAAC,IAAa;IACpC,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;AAChC,CAAC;AAUD,MAAM,UAAU,cAAc,CAAC,IAAa;IAC1C,OAAO,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC;AACtC,CAAC;AAUD,MAAM,UAAU,QAAQ,CAAC,IAAa;IACpC,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;AAChC,CAAC;AAUD,MAAM,UAAU,cAAc,CAAC,IAAa;IAC1C,OAAO,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC;AACtC,CAAC;AAUD,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC;AAUD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC;AAClC,CAAC;AAUD,MAAM,UAAU,OAAO,CAAC,IAAa;IACnC,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC;AAC/B,CAAC;AAUD,MAAM,UAAU,MAAM,CAAC,IAAa;IAClC,OAAO,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC;AAC9B,CAAC;AAUD,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,OAAO,IAAI,CAAC,IAAI,KAAK,eAAe,CAAC;AACvC,CAAC;AAUD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC;AAClC,CAAC"}