roll-parser 3.3.0 → 3.4.0

package/src/evaluator/modifiers/flags.ts

@@ -68,11 +68,27 @@ export function stripFlags(
   return modifiers.filter((modifier) => !excluded.includes(modifier));
 }
 
-/** Returns `modifiers` with `excluded` removed and `added` appended, in order. */
+/**
+ * Returns `modifiers` with `excluded` removed and `added` appended, in order.
+ *
+ * ! Always a fresh array. `mergeMetaRolls` clones a die as
+ * ! `{ ...die, modifiers: rewriteFlags(...) }`, so returning the input when it
+ * ! already matches would leave clone and original sharing mutated flags.
+ */
 export function rewriteFlags(
   modifiers: readonly DieModifier[],
   excluded: readonly DieModifier[],
   ...added: DieModifier[]
 ): DieModifier[] {
-  return [...stripFlags(modifiers, excluded), ...added];
+  // One array, not `stripFlags`'s filter plus a spread — this runs per die.
+  const rewritten: DieModifier[] = [];
+
+  for (const modifier of modifiers) {
+    if (!excluded.includes(modifier)) rewritten.push(modifier);
+  }
+  for (const flag of added) {
+    rewritten.push(flag);
+  }
+
+  return rewritten;
 }

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/render.ts

@@ -342,8 +342,9 @@ function renderGroup(
   plain: boolean,
 ): string {
   const { keptIndices } = part;
+  const kept = keptIndices == null ? null : new Set(keptIndices);
   const subRolls = part.parts.map((sub, index) => {
-    if (keptIndices == null || keptIndices.includes(index)) {
+    if (kept == null || kept.has(index)) {
       return renderPart(sub, marks, plain);
     }
     const inner = renderPart(sub, marks, true);

package/src/rng/seeded.ts

@@ -246,6 +246,10 @@ export class SeededRNG implements RNG {
    */
   private toSeedString(seed?: string | number): string {
     // ! The library's one permitted `Math.random()` site — both draws stay here.
+    // ! Decimal double-to-string is a JIT fast path and other radixes are not, so
+    // ! every shorter encoding measured slower despite the shorter `hashSeed` loop.
+    // ! Only truncating each draw to a uint32 beats it, at 64 draw bits against the
+    // ! ~100 documented above. A faster auto-seed must skip the string, not shorten it.
     if (seed == null) return `${Date.now()}-${Math.random()}-${Math.random()}`;
     return String(seed);
   }

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.0';
+export const version = '3.4.0';