roll-parser 3.3.1 → 3.4.0

package/src/evaluator/evaluator.ts

@@ -1598,6 +1598,37 @@ function formatFailCode(operator: CompareOp, value: number): string {
   return operator === '=' ? `f${value}` : `f${operator}${value}`;
 }
 
+/**
+ * The units a success count scores: sub-roll subtotals for a multi-sub group,
+ * the target's own dice otherwise.
+ */
+// ! Releases every die an inner count tagged, `vs` DC dice included, though
+// ! `countSuccesses` spares those. The `stripTallyMarkers` pass below reads
+// ! rendered text and cannot tell a DC die apart, so sparing one here leaves a
+// ! tag whose `**` is already gone and `renderBreakdown` stops reproducing
+// ! `rendered`.
+function clearTallyFlags(rolls: DieResult[]): void {
+  for (const die of rolls) {
+    die.modifiers = stripFlags(die.modifiers, TALLY_FLAGS);
+  }
+}
+
+function countablePool(
+  target: EvalResult,
+  targetCtx: EvalContext,
+  bySubtotal: boolean,
+): DieResult[] {
+  if (!bySubtotal) return targetCtx.rolls;
+
+  return (target.part as Extract<RollPart, { type: 'group' }>).parts.map((sub) => ({
+    sides: 0,
+    result: sub.total,
+    modifiers: [],
+    critical: false,
+    fumble: false,
+  }));
+}
+
 function evalSuccessCount(
   node: SuccessCountNode,
   rng: RNG,
@@ -1657,25 +1688,9 @@ function evalSuccessCount(
   // `ctx.rolls`. Only a direct group target arrives here — the parser refuses
   // every form that would reach the count with the subtotals already gone.
   const bySubtotal = node.target.type === 'Group' && node.target.expressions.length >= 2;
-  const pool: DieResult[] = bySubtotal
-    ? (target.part as Extract<RollPart, { type: 'group' }>).parts.map((sub) => ({
-        sides: 0,
-        result: sub.total,
-        modifiers: [],
-        critical: false,
-        fumble: false,
-      }))
-    : targetCtx.rolls;
-
-  // ! Releases every die an inner count tagged, `vs` DC dice included, though
-  // ! `countSuccesses` spares those. The marker strip below reads rendered text
-  // ! and cannot tell a DC die apart, so sparing one here leaves a tag whose
-  // ! `**` is already gone and `renderBreakdown` stops reproducing `rendered`.
-  if (bySubtotal && poolAlreadyCounted) {
-    for (const die of targetCtx.rolls) {
-      die.modifiers = stripFlags(die.modifiers, TALLY_FLAGS);
-    }
-  }
+  const pool = countablePool(target, targetCtx, bySubtotal);
+
+  if (bySubtotal && poolAlreadyCounted) clearTallyFlags(targetCtx.rolls);
 
   // An empty pool (`0d6>=4`) scores zero of both, so its total is 0 — never
   // `target.total`, which would break `total === successes - failures`.

package/src/evaluator/modifiers/keep-drop.ts

@@ -10,6 +10,29 @@ import { isVersusDc } from './flags.js';
 /** One selectable die: its rolled value and its slot in the original pool. */
 type EligibleDie = { result: number; index: number };
 
+/**
+ * The die at pool slot `index` when it is eligible for keep/drop selection,
+ * `null` otherwise. Marks an ineligible-but-droppable die in `droppedMask` on
+ * the way past.
+ */
+function selectOrMarkDropped(
+  dice: DieResult[],
+  index: number,
+  droppedMask: Uint8Array,
+  hasVersusDc: boolean,
+): DieResult | null {
+  const die = dice[index];
+  if (die == null) return null;
+  if (hasVersusDc && isVersusDc(die)) return null;
+
+  if (die.modifiers.includes('dropped')) {
+    droppedMask[index] = 1;
+    return null;
+  }
+
+  return die;
+}
+
 /**
  * Records into `droppedMask` every pool slot that `kind` / `selector` /
  * `count` drops.
@@ -39,14 +62,8 @@ export function markDroppedIndices(
   const eligible: EligibleDie[] = [];
 
   for (let index = 0; index < dice.length; index++) {
-    const die = dice[index];
+    const die = selectOrMarkDropped(dice, index, droppedMask, hasVersusDc);
     if (die == null) continue;
-    if (hasVersusDc && isVersusDc(die)) continue;
-
-    if (die.modifiers.includes('dropped')) {
-      droppedMask[index] = 1;
-      continue;
-    }
 
     eligible.push({ result: die.result, index });
   }
@@ -64,6 +81,20 @@ export function markDroppedIndices(
     return;
   }
 
+  dropBySelection(eligible, count, isKeep, selector, droppedMask);
+}
+
+/**
+ * Reached only once both whole-pool cases are ruled out, so the selected range
+ * is always a strict subset of `eligible`.
+ */
+function dropBySelection(
+  eligible: EligibleDie[],
+  count: number,
+  isKeep: boolean,
+  selector: KeepDropSpec['selector'],
+  droppedMask: Uint8Array,
+): void {
   // Stable sort — ties resolve by original pool order.
   eligible.sort(
     selector === 'highest' ? (a, b) => b.result - a.result : (a, b) => a.result - b.result,
@@ -95,20 +126,15 @@ function markSingleExtreme(
   hasVersusDc: boolean,
 ): void {
   const isKeep = kind === 'keep';
-  const wantHighest = selector === 'highest';
+  const isMoreExtreme =
+    selector === 'highest' ? (a: number, b: number) => a > b : (a: number, b: number) => a < b;
 
   let extremeIndex = -1;
   let extremeResult = 0;
 
   for (let index = 0; index < dice.length; index++) {
-    const die = dice[index];
+    const die = selectOrMarkDropped(dice, index, droppedMask, hasVersusDc);
     if (die == null) continue;
-    if (hasVersusDc && isVersusDc(die)) continue;
-
-    if (die.modifiers.includes('dropped')) {
-      droppedMask[index] = 1;
-      continue;
-    }
 
     const { result } = die;
 
@@ -118,7 +144,7 @@ function markSingleExtreme(
       continue;
     }
 
-    if (wantHighest ? result > extremeResult : result < extremeResult) {
+    if (isMoreExtreme(result, extremeResult)) {
       // A keep drops the dethroned extreme; a drop keeps everything else.
       if (isKeep) droppedMask[extremeIndex] = 1;
       extremeIndex = index;

package/src/lexer/lexer.ts

@@ -215,6 +215,14 @@ export class Lexer {
       return this.scanAt();
     }
 
+    return this.scanOperator(char, startPos);
+  }
+
+  /**
+   * Single- and two-character operators. The last resort in `nextToken`'s
+   * dispatch, so an unrecognised character can only be a lexer error.
+   */
+  private scanOperator(char: string, startPos: number): Token {
     this.advance();
 
     switch (char) {

package/src/parser/parser.ts

@@ -850,6 +850,41 @@ export class Parser {
     }
   }
 
+  // ! A single-sub-roll Group is the flat-pool escape hatch, so `containsDicePool`
+  // ! deep-walks the arithmetic that `(1d6+5)kh1` rejects outright — but the flat
+  // ! path totals `sumKeptDice`, faces only. `{2d6+3}kh2` and `{2d6-1d4}kh3` are
+  // ! exactly the drop that reject exists to prevent.
+  private rejectSingleSubGroupTarget(target: ASTNode, token: Token): void {
+    const base = unwrapAllTransparent(target);
+    if (base.type !== 'Group' || base.expressions.length !== 1) return;
+
+    const inner = base.expressions[0];
+    if (inner == null) return;
+
+    // Single-sub Groups hide a count from the shallow reject in `parseKeepDrop`,
+    // so peel them to any depth and `{4d6>=5}kh1`, `{{4d6>=5}}kh1`, and
+    // `(4d6>=5)kh1` all report one code. Peeling only picks which error the
+    // caller sees — `sumsToKeptFaces` below refuses a count either way.
+    let innermost = inner;
+    while (true) {
+      const peeled = unwrapGrouped(innermost);
+      if (peeled.type !== 'Group' || peeled.expressions.length !== 1) break;
+      const next = peeled.expressions[0];
+      if (next == null) break;
+      innermost = next;
+    }
+    this.rejectSuccessCountTarget(innermost, token);
+
+    if (!sumsToKeptFaces(inner)) {
+      throw new ParseError(
+        `Keep/drop on a single-sub-roll group requires added dice terms only`,
+        'INVALID_KEEP_DROP_TARGET',
+        token.position,
+        token,
+      );
+    }
+  }
+
   private parseKeepDrop(target: ASTNode, token: Token): KeepDropNode {
     this.rejectSuccessCountTarget(target, token);
     // ! Keep/drop on a Versus target silently drops `degree`/`natural` metadata,
@@ -869,38 +904,7 @@ export class Parser {
       );
     }
 
-    // ! A single-sub-roll Group is the flat-pool escape hatch, so `containsDicePool`
-    // ! deep-walks the arithmetic that `(1d6+5)kh1` rejects outright — but the flat
-    // ! path totals `sumKeptDice`, faces only. `{2d6+3}kh2` and `{2d6-1d4}kh3` are
-    // ! exactly the drop that reject exists to prevent.
-    const base = unwrapAllTransparent(target);
-    if (base.type === 'Group' && base.expressions.length === 1) {
-      const inner = base.expressions[0];
-      if (inner != null) {
-        // Single-sub Groups hide a count from the shallow reject at the top of this
-        // method, so peel them to any depth and `{4d6>=5}kh1`, `{{4d6>=5}}kh1`, and
-        // `(4d6>=5)kh1` all report one code. Peeling only picks which error the
-        // caller sees — `sumsToKeptFaces` below refuses a count either way.
-        let innermost = inner;
-        while (true) {
-          const peeled = unwrapGrouped(innermost);
-          if (peeled.type !== 'Group' || peeled.expressions.length !== 1) break;
-          const next = peeled.expressions[0];
-          if (next == null) break;
-          innermost = next;
-        }
-        this.rejectSuccessCountTarget(innermost, token);
-
-        if (!sumsToKeptFaces(inner)) {
-          throw new ParseError(
-            `Keep/drop on a single-sub-roll group requires added dice terms only`,
-            'INVALID_KEEP_DROP_TARGET',
-            token.position,
-            token,
-          );
-        }
-      }
-    }
+    this.rejectSingleSubGroupTarget(target, token);
 
     const kind =
       token.type === TokenType.KEEP_HIGH || token.type === TokenType.KEEP_LOW ? 'keep' : 'drop';

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by `bun run generate:version` from package.json — do not edit.
-export const version = '3.3.1';
+export const version = '3.4.0';