@yipe/dice 0.1.0

package/dist/index.js

@@ -0,0 +1,2944 @@
+// src/lru-cache.ts
+var LRUCache = class {
+  constructor(maxSize = 1e3) {
+    this.maxSize = maxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value === void 0) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return this;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  values() {
+    return this.cache.values();
+  }
+};
+
+// src/types.ts
+var COMPUTATIONAL_EPS = 1e-40;
+var TEST_EPS = 1e-10;
+
+// src/query.ts
+var _DiceQuery = class _DiceQuery {
+  constructor(singles, combined) {
+    this.singles = Array.isArray(singles) ? singles : [singles];
+    const c = combined ?? PMF.convolveMany(this.singles);
+    this.combined = Math.abs(c.mass() - 1) <= 1e-12 ? c : c.normalize();
+    if (this.singles.some((s) => s === void 0)) {
+      throw new Error("DiceQuery contains undefined singles");
+    }
+  }
+  /**
+   * Returns the expected damage across all possible outcomes.
+   *
+   * Example: `query.mean()` → 12.5
+   * Use case: "What's my average damage per round?"
+   */
+  mean() {
+    let totalSum = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      totalSum += damageValue * probabilityBin.p;
+    }
+    return totalSum;
+  }
+  /**
+   * Returns the variance of the damage distribution.
+   *
+   * Example: `query.variance()` → 45.2
+   * Use case: "How much does my damage vary from the average?"
+   * High variance means higher risk/reward. Lower variance means more consistent damage.
+   */
+  variance() {
+    const meanValue = this.mean();
+    let varianceSum = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      const deviationFromMean = damageValue - meanValue;
+      varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;
+    }
+    return varianceSum;
+  }
+  /**
+   * Returns the standard deviation of the damage distribution.
+   *
+   * Example: `query.stdev()` → 6.7
+   * Use case: "What's the typical spread around my average damage?"
+   * Used to determine how consistent the damage is.
+   */
+  stddev() {
+    return Math.sqrt(this.variance());
+  }
+  /**
+   * Returns the Cumulative Distribution Function.
+   */
+  cdf(x) {
+    return this.probTotalAtMost(x);
+  }
+  /**
+   * Returns the probability of dealing X damage or less.
+   * In statistics, this is called the cumulative distribution function (CDF).
+   * Example: `query.cdf(20)` → 0.75
+   * Use case: "What's the chance I deal 20 damage or less?"
+   */
+  probTotalAtMost(x) {
+    let cumulativeProbability = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      if (damageValue <= x) {
+        cumulativeProbability += probabilityBin.p;
+      }
+    }
+    return cumulativeProbability;
+  }
+  /**
+   * Returns the Complementary Cumulative Distribution Function.
+   */
+  ccdf(x) {
+    return this.probTotalAtLeast(x);
+  }
+  /**
+   * Returns the probability of dealing at least X damage.
+   *
+   * Example: `query.probTotalAtLeast(25)` → 0.35
+   * Use case: "What's the chance I deal at least 25 damage to finish the enemy?"
+   */
+  probTotalAtLeast(threshold) {
+    let probabilitySum = 0;
+    for (const [damageValue, probabilityBin] of this.combined) {
+      if (damageValue >= threshold) {
+        probabilitySum += probabilityBin.p;
+      }
+    }
+    return probabilitySum;
+  }
+  /**
+   * Returns damage values at specific percentiles.
+   *
+   * Example: `query.percentiles([0.25, 0.5, 0.75])` → [8, 12, 18]
+   * Use case: "What are my 25th, 50th, and 75th percentile damage values?"
+   */
+  percentiles(percentileValues) {
+    const sortedDamageValues = this.combined.support();
+    if (sortedDamageValues.length === 0) return percentileValues.map(() => 0);
+    const cumulativeProbabilities = [];
+    let runningProbabilitySum = 0;
+    for (const damageValue of sortedDamageValues) {
+      runningProbabilitySum += this.combined.map.get(damageValue).p;
+      cumulativeProbabilities.push(runningProbabilitySum);
+    }
+    return percentileValues.map((targetPercentile) => {
+      let leftBound = 0;
+      let rightBound = cumulativeProbabilities.length - 1;
+      while (leftBound <= rightBound) {
+        const middleIndex = Math.floor((leftBound + rightBound) / 2);
+        if (cumulativeProbabilities[middleIndex] >= targetPercentile) {
+          rightBound = middleIndex - 1;
+        } else {
+          leftBound = middleIndex + 1;
+        }
+      }
+      return leftBound < sortedDamageValues.length ? sortedDamageValues[leftBound] : sortedDamageValues[sortedDamageValues.length - 1];
+    });
+  }
+  /**
+   * Returns the minimum possible damage.
+   *
+   * Example: `query.min()` → 0
+   * Use case: "What's the worst-case damage if everything misses?"
+   */
+  min() {
+    return this.combined.min();
+  }
+  /**
+   * Returns the maximum possible damage.
+   *
+   * Example: `query.max()` → 56
+   * Use case: "What's the best-case damage if everything crits and rolls max?"
+   */
+  max() {
+    return this.combined.max();
+  }
+  singleProb(diceIndex, label) {
+    let probabilitySum = 0;
+    for (const [, probabilityBin] of this.singles[diceIndex]) {
+      probabilitySum += probabilityBin.count[label] || 0;
+    }
+    return probabilitySum;
+  }
+  probAtLeastK(labels, k) {
+    const L = Array.isArray(labels) ? [...new Set(labels)] : [labels];
+    const n = this.singles.length;
+    if (k <= 0) return 1;
+    if (k > n) return 0;
+    let tail = 0;
+    for (let i = k; i <= n; i++) {
+      tail += this.probExactlyK(L, i);
+    }
+    if (tail < 0) return 0;
+    if (tail > 1) return 1;
+    return tail;
+  }
+  /**
+   * Returns the probability that at least one attack has the specified outcome(s).
+   * - This is the complement of probAtMostK(labels, 0)
+   *
+   * Examples:
+   * - `query.probAtLeastOne('hit')` → 0.88 (88% chance at least one attack hits)
+   * - `query.probAtLeastOne(['hit', 'crit'])` → 0.96 (96% chance at least one succeeds)
+   *
+   * Use cases:
+   * - "What's the chance at least one of my attacks connects?"
+   *
+   * Note:
+   *
+   * - You have to pass in an array of labels to avoid double-counting if you are
+   *   using multiple labels. You cannot just add them.
+   */
+  probAtLeastOne(labels) {
+    if (typeof labels === "string") {
+      labels = [labels];
+    }
+    let productOfNonOccurrence = 1;
+    for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {
+      let combinedProbability = 0;
+      for (const label of labels) {
+        combinedProbability += this.singleProb(diceIndex, label);
+      }
+      productOfNonOccurrence *= 1 - combinedProbability;
+    }
+    return 1 - productOfNonOccurrence;
+  }
+  /**
+   * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.
+   *
+   * Uses dynamic programming to efficiently calculate the probability distribution
+   * of how many attacks will have the specified outcome, accounting for different
+   * success probabilities across individual attacks.
+   *
+   * Example: For 3 attacks with 50% hit chance each, returns:
+   * [0.125, 0.375, 0.375, 0.125] = [P(0 hits), P(1 hit), P(2 hits), P(3 hits)]
+   *
+   * @param label - The outcome type to count
+   * @param maxK - Maximum number of occurrences to calculate (usually number of attacks)
+   * @returns Array where index K contains P(exactly K attacks have the label)
+   */
+  computeBinomialProbabilities(label, maxK) {
+    const individualProbabilities = this.singles.map(
+      (_, diceIndex) => this.singleProb(diceIndex, label)
+    );
+    const binomialProbs = new Array(maxK + 1).fill(0);
+    binomialProbs[0] = 1;
+    for (const singleProbability of individualProbabilities) {
+      for (let outcomeCount = maxK; outcomeCount >= 1; outcomeCount--) {
+        binomialProbs[outcomeCount] = binomialProbs[outcomeCount] * (1 - singleProbability) + binomialProbs[outcomeCount - 1] * singleProbability;
+      }
+      binomialProbs[0] *= 1 - singleProbability;
+    }
+    return binomialProbs;
+  }
+  /**
+   * Returns the probability that exactly K attacks result in the specified outcome(s).
+   *
+   * Single label examples:
+   * - probExactlyK('hit', 2) = probability exactly 2 attacks hit
+   * - probExactlyK('crit', 1) = probability exactly 1 attack crits
+   * - probExactlyK('crit', 0) = probability no attacks crit
+   *
+   * Array examples:
+   * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed
+   * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds
+   * - probExactlyK(['miss', 'missNone'], 0) = probability no attacks miss
+   *
+   * Use cases:
+   * - "What's the chance exactly one of my attacks hits?"
+   * - "How likely am I to get exactly 2 successes out of 3 attacks?"
+   * - "What's the probability that exactly half my attacks succeed?"
+   *
+   * Note: For arrays, an attack counts as a "success" if it has any of the specified labels.
+   * This is different from probAtMostK, which counts an attack as a "success" if it has ALL of the specified labels.
+   */
+  probExactlyK(labels, k) {
+    if (typeof labels === "string") {
+      const probabilityArray = this.computeBinomialProbabilities(labels, k);
+      return probabilityArray[k];
+    }
+    const successProbabilities = this.singles.map((single) => {
+      const singleQuery = new _DiceQuery([single]);
+      return singleQuery.probabilityOf(labels);
+    });
+    const binomialProbs = new Array(k + 1).fill(0);
+    binomialProbs[0] = 1;
+    for (const successProb of successProbabilities) {
+      for (let outcomeCount = k; outcomeCount >= 1; outcomeCount--) {
+        binomialProbs[outcomeCount] = binomialProbs[outcomeCount] * (1 - successProb) + binomialProbs[outcomeCount - 1] * successProb;
+      }
+      binomialProbs[0] *= 1 - successProb;
+    }
+    return binomialProbs[k];
+  }
+  /**
+   * Returns the probability that AT MOST K attacks result in the specified outcome(s).
+   *
+   * Single label examples:
+   * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)
+   * - probAtMostK('crit', 0) = probability no attacks crit
+   * - probAtMostK('miss', 2) = probability at most 2 attacks miss
+   *
+   * Array examples:
+   * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds
+   * - probAtMostK(['hit', 'crit'], 0) = probability no attacks succeed (all miss)
+   *
+   * Use cases:
+   * - "What's the chance that at most one attack hits?" (rest miss)
+   * - "How likely am I to have mostly failures?" (at most 1 success)
+   * - "What's the probability of a really bad turn?" (at most 0 successes)
+   *
+   */
+  probAtMostK(labels, k) {
+    if (typeof labels === "string") {
+      const probabilityArray = this.computeBinomialProbabilities(labels, k);
+      let cumulativeSum2 = 0;
+      for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {
+        cumulativeSum2 += probabilityArray[outcomeCount];
+      }
+      return cumulativeSum2;
+    }
+    let cumulativeSum = 0;
+    for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {
+      cumulativeSum += this.probExactlyK(labels, outcomeCount);
+    }
+    return cumulativeSum;
+  }
+  /**
+   * Returns the expected damage attributed to specific outcome types.
+   *
+   * Single label examples:
+   * - expectedDamageFrom('hit') = expected damage from hit components
+   * - expectedDamageFrom('crit') = expected damage from crit components
+   *
+   * Array examples:
+   * - expectedDamageFrom(['hit', 'crit']) = expected damage from any success
+   * - expectedDamageFrom(['missDamage', 'missNone']) = expected damage from misses
+   *
+   * Use cases:
+   * - "How much damage do I expect from successful attacks?"
+   * - "What's the damage contribution from critical hits specifically?"
+   * - "How much damage comes from miss effects (like save-for-half spells)?"
+   */
+  expectedDamageFrom(labels) {
+    if (typeof labels === "string") {
+      return this._expectedDamageFromSingle(labels);
+    }
+    let totalExpectedDamage = 0;
+    for (const [, probabilityBin] of this.combined) {
+      for (const label of labels) {
+        totalExpectedDamage += probabilityBin.attr?.[label] || 0;
+      }
+    }
+    return totalExpectedDamage;
+  }
+  _expectedDamageFromSingle(label) {
+    let totalExpectedDamage = 0;
+    for (const [, probabilityBin] of this.combined) {
+      totalExpectedDamage += probabilityBin.attr?.[label] || 0;
+    }
+    return totalExpectedDamage;
+  }
+  /**
+   * Returns damage statistics for scenarios where AT LEAST ONE attack results in
+   * the specified outcome(s).
+   *
+   * This method answers "What happens when things go reasonably well?" rather than
+   * "What's the theoretical maximum?" It includes mixed scenarios which are more
+   * common and tactically relevant than pure scenarios.
+   *
+   * Single label examples:
+   * - damageStatsFrom('hit') = damage range when at least one attack hits
+   * - damageStatsFrom('crit') = damage range when at least one attack crits
+   *
+   * Array examples:
+   * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds
+   * - damageStatsFrom(['miss', 'missNone']) = damage range when at least one attack misses
+   *
+   * Tactical Use Cases:
+   * - "Given that I don't completely whiff (99% of turns), what damage should I expect?"
+   * - "When planning to kill a 60 HP enemy, what's my damage range on successful turns?"
+   * - "Should I use this risky spell if it has good damage when it works?"
+   * - "What's my damage potential when something goes right?" (vs pure failure)
+   *
+   * Combat Planning Examples:
+   * - 4 attacks with 90% hit chance: "96% of the time you'll do 25-150 damage, avg 52"
+   *   (Much more useful than "You average 50 damage including complete misses")
+   * - Risk assessment: "80% of successful turns do 40-80 damage, but 20% do 80-150"
+   * - Resource management: "If I hit anything, I'll likely finish this enemy"
+   *
+   * Statistical Note:
+   * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which
+   * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.
+   *
+   * @example
+   * // High-level tactical planning
+   * const successStats = query.damageStatsFrom('hit')
+   * const successChance = query.probAtLeastOne('hit')
+   * console.log(`${(successChance*100).toFixed(1)}% chance to do ${successStats.min}-${successStats.max} damage`)
+   */
+  damageStatsFrom(labels) {
+    const labelArray = typeof labels === "string" ? [labels] : labels;
+    let minDamage = Infinity;
+    let maxDamage = -Infinity;
+    let totalDamage = 0;
+    let totalCount = 0;
+    for (const [damage, probabilityBin] of this.combined) {
+      let binHasAnyLabel = false;
+      let binContribution = 0;
+      for (const label of labelArray) {
+        const count = probabilityBin.count[label];
+        if (count && count > 0) {
+          binHasAnyLabel = true;
+          binContribution += count;
+        }
+      }
+      if (damage > 0 && binHasAnyLabel) {
+        minDamage = Math.min(minDamage, damage);
+        maxDamage = Math.max(maxDamage, damage);
+        const weightToUse = labelArray.length === 1 ? binContribution : probabilityBin.p;
+        totalDamage += damage * weightToUse;
+        totalCount += weightToUse;
+      }
+    }
+    return {
+      min: minDamage === Infinity ? 0 : minDamage,
+      max: maxDamage === -Infinity ? 0 : maxDamage,
+      avg: totalCount > 0 ? totalDamage / totalCount : 0,
+      count: totalCount
+    };
+  }
+  /**
+   * Returns damage statistics for scenarios where ALL attacks result in the specified
+   * outcome, calculated by leveraging the pure partition of singles.
+   *
+   * This method answers "What's the theoretical best/worst case?" and "What are the
+   * clean mathematical boundaries?" It provides pure scenarios without mixing outcomes.
+   *
+   * Examples:
+   * - combinedDamageStats('hit') = damage range when all attacks hit (none crit, none miss)
+   * - combinedDamageStats('crit') = damage range when all attacks crit (none just hit)
+   *
+   * UI and Display Use Cases:
+   * - Statistics panels showing "MAX Hit Damage" (users expect pure hits, not mixed)
+   * - "Best case scenario" vs "worst case scenario" analysis
+   * - Mathematical verification: "Does our hit damage calculation match manual math?"
+   * - Clean damage type attribution: "How much comes from base hits vs crits?"
+   *
+   * Design and Balance Use Cases:
+   * - Game designers: "What's the damage ceiling if someone gets lucky?"
+   * - Character optimization: "What's my absolute maximum potential?"
+   * - Ability comparison: "Which build has higher crit ceiling?"
+   * - Minimum guaranteed damage: "What's the worst I can do if everything hits?"
+   *
+   * Mathematical Use Cases:
+   * - Validating complex calculations against simple manual math
+   * - Understanding damage component contributions in isolation
+   * - Separating luck (crit variance) from consistency (hit variance)
+   * - Building intuition about damage sources
+   *
+   * When to Use This vs damageStatsFrom():
+   * - Use THIS for: UI max/min displays, theoretical limits, clean comparisons
+   * - Use damageStatsFrom() for: tactical planning, realistic expectations, mixed scenarios
+   *
+   * Statistical Note:
+   * Pure scenarios (all hits, all crits) are rare but represent clear mathematical
+   * boundaries. These stats help understand the "shape" of your damage potential.
+   *
+   * @example
+   * // UI display logic
+   * const pureHitMax = query.combinedDamageStats('hit').max    // Clean "MAX Hit Damage: 90"
+   * const pureCritMax = query.combinedDamageStats('crit').max  // Clean "MAX Crit Damage: 168"
+   *
+   * // vs tactical planning (use damageStatsFrom instead)
+   * const realisticRange = query.damageStatsFrom('hit')  // Includes mixed scenarios
+   */
+  combinedDamageStats(targetLabel) {
+    const singleStats = this.singles.map(
+      (single) => new _DiceQuery([single]).damageStatsFrom(targetLabel)
+    );
+    if (singleStats.some((stats) => stats.count === 0)) {
+      return { min: 0, max: 0, avg: 0, count: 0 };
+    }
+    const combinedMin = singleStats.reduce((sum, stats) => sum + stats.min, 0);
+    const combinedMax = singleStats.reduce((sum, stats) => sum + stats.max, 0);
+    const combinedAvg = singleStats.reduce((sum, stats) => sum + stats.avg, 0);
+    const combinedProb = singleStats.reduce(
+      (product, stats) => product * stats.count,
+      1
+    );
+    return {
+      min: combinedMin,
+      max: combinedMax,
+      avg: combinedAvg,
+      count: combinedProb
+    };
+  }
+  /**
+   * Returns the probability that a result includes ANY of the specified labels.
+   *
+   * Examples:
+   * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)
+   * - `query.probabilityOf(['hit', 'crit'])` → 0.96 (probability of any success)
+   *
+   * Use cases:
+   * - "What's the chance my resolution includes a success label?"
+   * - "How likely am I to get any hits or crits across all attacks?"
+   */
+  probabilityOf(labels) {
+    if (typeof labels === "string") {
+      labels = [labels];
+    }
+    let totalProbability = 0;
+    for (const [, probabilityBin] of this.combined) {
+      let binHasAnyLabel = false;
+      for (const label of labels) {
+        if (probabilityBin.count[label] && probabilityBin.count[label] > 0) {
+          binHasAnyLabel = true;
+          break;
+        }
+      }
+      if (binHasAnyLabel) {
+        totalProbability += probabilityBin.p;
+      }
+    }
+    return totalProbability;
+  }
+  /**
+   * Returns the probability of missing (any type of miss).
+   *
+   * Example: `query.missChance()` → 0.04
+   * Use case: "What's the chance I miss completely this turn?"
+   */
+  missChance() {
+    return this.probabilityOf(["missDamage", "missNone"]);
+  }
+  /**
+   * Returns data formatted for plotting damage probability distribution.
+   *
+   * Example: `query.toChartSeries()` → [{x: 0, y: 0.04}, {x: 6, y: 0.1}, ...]
+   * Use case: "I want to visualize my damage distribution in a chart."
+   */
+  toChartSeries() {
+    return this.combined.support().map((damageValue) => ({
+      x: damageValue,
+      y: this.combined.map.get(damageValue).p
+    }));
+  }
+  /**
+   * Returns tabular data showing damage values and their probability breakdowns.
+   *
+   * Example: `query.toLabeledTable(['hit', 'crit'])` →
+   *   [{damage: 6, total: 0.01, hit: 0.008, crit: 0}, ...]
+   *
+   * Use case: "I want to see exactly how hit/crit probabilities contribute to each damage value."
+   */
+  toLabeledTable(labels = []) {
+    return this.combined.support().map((damageValue) => {
+      const probabilityBin = this.combined.map.get(damageValue);
+      const tableRow = {
+        damage: damageValue,
+        total: probabilityBin.p
+      };
+      for (const outcomeLabel of labels) {
+        tableRow[outcomeLabel] = probabilityBin.count[outcomeLabel] || 0;
+      }
+      return tableRow;
+    });
+  }
+  /**
+   * Returns data for stacked charts with unconditional per-label probability mass per damage.
+   *
+   * - Each dataset value equals the unconditional probability mass for that label at that damage
+   *   (i.e., `bin.count[label]`).
+   * - Column sums may be less than the total probability `bin.p` when you omit labels or when
+   *   there is unlabeled mass. Include all relevant outcome labels if you need the sum to match.
+   * - This behavior matches tests that expect raw per-label mass (not proportional scaling).
+   * - NOTE: This implementation may break dprcalc.com chart binning at large n, need to test it more.
+   *
+   * @example
+   * query.toStackedChartData(['hit', 'crit'])
+   * // → {labels: [0, 6, 12, ...], datasets: [{label: 'hit', data: [0, 0.03, ...]}, ...]}
+   */
+  toStackedChartData(labels = [], epsilon = 1e-12) {
+    const damageValues = this.combined.support();
+    damageValues.map((dmg) => {
+      const bin = this.combined.map.get(dmg);
+      return labels.reduce((sum, lab) => sum + (bin.count[lab] || 0), 0);
+    });
+    const datasets = labels.map((outcomeLabel) => ({
+      label: outcomeLabel,
+      data: damageValues.map((dmg) => {
+        const bin = this.combined.map.get(dmg);
+        const v = bin ? bin.count[outcomeLabel] || 0 : 0;
+        return v <= epsilon ? 0 : v;
+      })
+    }));
+    return { labels: damageValues, datasets };
+  }
+  /**
+   * Returns pure mathematical data for attribution charts showing outcome contributions.
+   *
+   * Automatically discovers all outcome types present in the PMF, applies filtering rules,
+   * and returns proportional data suitable for stacked visualization.
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support, outcomes, and proportional data
+   *
+   * @example
+   * query.toAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['hit', 'crit'], data: {hit: [5.2, 8.1, ...], crit: [0, 2.3, ...]}}
+   */
+  toAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const outcomeType in bin.count) {
+        if (bin.count[outcomeType] && bin.count[outcomeType] > 0) {
+          allOutcomeTypes.add(outcomeType);
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        const outcomeCount = bin.count[outcome] || 0;
+        let totalChartableCount = 0;
+        for (const [outcomeName, count] of Object.entries(bin.count)) {
+          if (filterRules(outcomeName, damage)) {
+            totalChartableCount += count || 0;
+          }
+        }
+        if (totalChartableCount === 0) return 0;
+        const outcomeFraction = outcomeCount / totalChartableCount;
+        const outcomeProbability = bin.p * outcomeFraction;
+        return asPercentages ? outcomeProbability * 100 : outcomeProbability;
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for damage attribution charts showing damage contribution
+   * from each outcome type at each damage value.
+   *
+   * Similar to toAttributionChartSeries() but uses bin.attr (damage attribution) instead of
+   * bin.count (probability attribution).
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or raw damage values (0+)
+   * @returns Pure data structure with support, outcomes, and damage attribution data
+   *
+   * @example
+   * query.toDamageAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['hit', 'crit'], data: {hit: [3.2, 5.1, ...], crit: [0, 1.8, ...]}}
+   */
+  toDamageAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      if (bin.attr) {
+        for (const outcomeType in bin.attr) {
+          if (bin.attr[outcomeType] && bin.attr[outcomeType] > 0) {
+            allOutcomeTypes.add(outcomeType);
+          }
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin || !bin.attr) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        const outcomeDamageAttribution = bin.attr[outcome] || 0;
+        if (asPercentages) {
+          let totalDamageAttribution = 0;
+          for (const [outcomeName, damageAttr] of Object.entries(bin.attr)) {
+            if (filterRules(outcomeName, damage)) {
+              totalDamageAttribution += damageAttr || 0;
+            }
+          }
+          if (totalDamageAttribution === 0) return 0;
+          const damagePercentage = outcomeDamageAttribution / totalDamageAttribution * 100;
+          return damagePercentage * bin.p * 100;
+        } else {
+          return outcomeDamageAttribution;
+        }
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for outcome attribution charts showing which
+   * attack outcome combinations can produce each damage value.
+   *
+   * Unlike toDamageAttributionChartSeries() which tracks damage sources, this tracks
+   * outcome combinations - answering "what attack outcomes produced this damage?"
+   *
+   * @param options Configuration options
+   * @param options.stackOrder Preferred order for outcome types (unknowns placed at end)
+   * @param options.filterRules Function to determine if outcome should be included for a given damage value
+   * @param options.asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support, outcomes, and outcome combination probabilities
+   *
+   * @example
+   * query.toOutcomeAttributionChartSeries()
+   * // → {support: [0, 6, 12], outcomes: ['all_miss', 'mixed', 'all_hit'], data: {all_miss: [15, 0, 0], mixed: [60, 80, 20], all_hit: [25, 20, 80]}}
+   */
+  toOutcomeAttributionChartSeries(options = {}) {
+    const {
+      stackOrder = [
+        "missNone",
+        "missDamage",
+        "saveFail",
+        "saveHalf",
+        "pc",
+        "hit",
+        "crit"
+      ],
+      filterRules = (outcome, damage) => !(outcome === "missNone" && damage !== 0),
+      asPercentages = true
+    } = options;
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], outcomes: [], data: {} };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    const allOutcomeTypes = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const outcomeType in bin.count) {
+        if (bin.count[outcomeType] && bin.count[outcomeType] > 0) {
+          allOutcomeTypes.add(outcomeType);
+        }
+      }
+    }
+    const existingOutcomes = Array.from(allOutcomeTypes).sort((a, b) => {
+      const indexA = stackOrder.indexOf(a);
+      const indexB = stackOrder.indexOf(b);
+      if (indexA >= 0 && indexB >= 0) return indexA - indexB;
+      if (indexA >= 0) return -1;
+      if (indexB >= 0) return 1;
+      return a.localeCompare(b);
+    });
+    if (existingOutcomes.length === 0) {
+      return { support, outcomes: [], data: {} };
+    }
+    const data = {};
+    for (const outcome of existingOutcomes) {
+      data[outcome] = support.map((damage) => {
+        const bin = this.combined.map.get(damage);
+        if (!bin) return 0;
+        if (!filterRules(outcome, damage)) {
+          return 0;
+        }
+        if (outcome === "missNone") {
+          const outcomeCount = bin.count[outcome] || 0;
+          if (outcomeCount === 0) return 0;
+          if (asPercentages) {
+            let totalChartableCount = 0;
+            for (const [outcomeName, count] of Object.entries(bin.count)) {
+              if (filterRules(outcomeName, damage)) {
+                totalChartableCount += count || 0;
+              }
+            }
+            if (totalChartableCount === 0) return 0;
+            const outcomeFraction = outcomeCount / totalChartableCount;
+            return outcomeFraction * bin.p * 100;
+          } else {
+            return outcomeCount;
+          }
+        }
+        if (!bin.attr) return 0;
+        const outcomeDamageContribution = bin.attr[outcome] || 0;
+        if (asPercentages) {
+          let totalDamageAttribution = 0;
+          for (const [, damageAttr] of Object.entries(bin.attr)) {
+            totalDamageAttribution += damageAttr || 0;
+          }
+          if (totalDamageAttribution === 0) return 0;
+          const outcomeFraction = outcomeDamageContribution / totalDamageAttribution;
+          return outcomeFraction * bin.p * 100;
+        } else {
+          return outcomeDamageContribution;
+        }
+      });
+    }
+    return {
+      support,
+      outcomes: existingOutcomes,
+      data
+    };
+  }
+  /**
+   * Returns pure mathematical data for cumulative distribution function (CDF).
+   * Shows P(X ≤ x) - the probability of getting at most x damage.
+   *
+   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support and cumulative probabilities
+   *
+   * @example
+   * query.toCDFSeries()
+   * // → {support: [0, 6, 12], data: [5.2, 18.3, 45.1]}
+   */
+  toCDFSeries(asPercentages = true) {
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], data: [] };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    let cumulativeProbability = 0;
+    const cdfData = [];
+    for (const damage of support) {
+      const bin = this.combined.map.get(damage);
+      if (bin) {
+        cumulativeProbability += bin.p;
+      }
+      cdfData.push(
+        asPercentages ? cumulativeProbability * 100 : cumulativeProbability
+      );
+    }
+    return {
+      support,
+      data: cdfData
+    };
+  }
+  /**
+   * Returns pure mathematical data for complementary cumulative distribution function (CCDF).
+   * Shows P(X ≥ x) - the probability of getting at least x damage.
+   *
+   * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)
+   * @returns Pure data structure with support and complementary cumulative probabilities
+   *
+   * @example
+   * query.toCCDFSeries()
+   * // → {support: [0, 6, 12], data: [100, 94.8, 81.7]}
+   */
+  toCCDFSeries(asPercentages = true) {
+    const originalSupport = this.combined.support();
+    if (originalSupport.length === 0) {
+      return { support: [], data: [] };
+    }
+    const minDamage = Math.min(...originalSupport);
+    const maxDamage = Math.max(...originalSupport);
+    const support = Array.from(
+      { length: maxDamage - minDamage + 1 },
+      (_, i) => minDamage + i
+    );
+    let cumulativeProbability = 0;
+    const ccdfData = [];
+    for (const damage of support) {
+      const ccdf = 1 - cumulativeProbability;
+      ccdfData.push(asPercentages ? ccdf * 100 : ccdf);
+      const bin = this.combined.map.get(damage);
+      if (bin) {
+        cumulativeProbability += bin.p;
+      }
+    }
+    return {
+      support,
+      data: ccdfData
+    };
+  }
+  /*
+        Statistics snapshot of the query.
+            */
+  /** Probability of doing strictly more than threshold damage (default >0). */
+  probDamageGreaterThan(threshold = 0) {
+    let acc = 0;
+    for (const [x, bin] of this.combined.map) if (x > threshold) acc += bin.p;
+    return acc;
+  }
+  /** All outcome keys actually present (typed & ordered if you pass an order). */
+  outcomeKeys(order) {
+    const found = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const k in bin.count)
+        if (bin.count[k] && bin.count[k] > 0) found.add(k);
+    }
+    if (found.size === 0)
+      ["hit", "crit", "missNone"].forEach((k) => found.add(k));
+    const keys = Array.from(found).filter(
+      (k) => order?.includes(k) ?? true
+    );
+    if (order && order.length)
+      keys.sort((a, b) => order.indexOf(a) + 999 - (order.indexOf(b) + 999));
+    return keys;
+  }
+  /** Total probability per outcome across the PMF. */
+  outcomeTotals(outcomes = this.outcomeKeys()) {
+    const totals = /* @__PURE__ */ new Map();
+    outcomes.forEach((o) => totals.set(o, 0));
+    for (const [x, row] of this.combined.map) {
+      for (const o of outcomes) {
+        const p = row.count[o] || 0;
+        totals.set(o, (totals.get(o) || 0) + p);
+      }
+    }
+    return totals;
+  }
+  /** Conditional damage range per outcome (min/avg/max of X | outcome). */
+  outcomeDamageRanges(outcomes = this.outcomeKeys()) {
+    const table = this.toLabeledTable(outcomes);
+    const ranges = /* @__PURE__ */ new Map();
+    outcomes.forEach((o) => ranges.set(o, { sum: 0, mass: 0 }));
+    for (const row of table) {
+      const dmg = row.damage;
+      for (const o of outcomes) {
+        const p = row[o] || 0;
+        if (p > 0) {
+          const r = ranges.get(o);
+          r.sum += dmg * p;
+          r.mass += p;
+          if (r.min === void 0 || dmg < r.min) r.min = dmg;
+          if (r.max === void 0 || dmg > r.max) r.max = dmg;
+        }
+      }
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const o of outcomes) {
+      const r = ranges.get(o);
+      const avg = r.mass > 0 ? r.sum / r.mass : 0;
+      out.set(o, { min: r.min ?? 0, avg, max: r.max ?? 0 });
+    }
+    return out;
+  }
+  /**
+   * Snapshot of the distribution in the exact shape the UI consumes.
+   * - outcome probabilities are "at least one" (and equal to "all" for a single PMF)
+   * - damageRange is conditional on the outcome occurring
+   */
+  snapshot(order) {
+    const discovered = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.combined.map) {
+      for (const k in bin.count) {
+        if (bin.count[k] && bin.count[k] > 0) discovered.add(k);
+      }
+    }
+    if (discovered.size === 0) {
+      for (const k of _DiceQuery.DEFAULT_OUTCOMES) discovered.add(k);
+    }
+    let outcomes = Array.from(discovered);
+    if (order && order.length) {
+      const inOrder = new Set(order);
+      outcomes = outcomes.filter((k) => inOrder.has(k));
+      const rank = new Map(order.map((k, i) => [k, i]));
+      outcomes.sort(
+        (a, b) => (rank.get(a) ?? 999) - (rank.get(b) ?? 999)
+      );
+    }
+    const rows = this.toLabeledTable(outcomes);
+    const totals = /* @__PURE__ */ new Map();
+    const rangeAcc = /* @__PURE__ */ new Map();
+    for (const ot of outcomes) {
+      totals.set(ot, 0);
+      rangeAcc.set(ot, { sum: 0, mass: 0 });
+    }
+    for (const row of rows) {
+      const dmg = row.damage;
+      for (const ot of outcomes) {
+        const p = row[ot] || 0;
+        if (p <= 0) continue;
+        totals.set(ot, (totals.get(ot) || 0) + p);
+        const r = rangeAcc.get(ot);
+        r.sum += dmg * p;
+        r.mass += p;
+        if (r.min === void 0 || dmg < r.min) r.min = dmg;
+        if (r.max === void 0 || dmg > r.max) r.max = dmg;
+      }
+    }
+    const outcomeMap = /* @__PURE__ */ new Map();
+    for (const ot of outcomes) {
+      const total = totals.get(ot) || 0;
+      const r = rangeAcc.get(ot);
+      const avg = r.mass > 0 ? r.sum / r.mass : 0;
+      outcomeMap.set(ot, {
+        atLeastOneProbability: total,
+        allProbability: total,
+        // single aggregate PMF: same value
+        damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 }
+      });
+    }
+    const averageDPR = this.mean();
+    let damageChance = 0;
+    for (const [x, bin] of this.combined.map) if (x > 0) damageChance += bin.p;
+    const { support, data } = this.toCDFSeries(false);
+    const quantile = (p) => {
+      if (support.length === 0) return 0;
+      for (let i = 0; i < support.length; i++)
+        if (data[i] >= p) return support[i];
+      return support[support.length - 1];
+    };
+    const percentiles = {
+      p25: quantile(0.25),
+      p50: quantile(0.5),
+      p75: quantile(0.75)
+    };
+    return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };
+  }
+  /**
+   * PMF Transformation Methods
+   *
+   * These methods provide a fluent API for transforming dice queries by wrapping
+   * the underlying PMF transformation methods. All operations work on the combined
+   * PMF and return new DiceQuery instances.
+   */
+  /**
+   * Returns a new DiceQuery with normalized probabilities (ensuring they sum to 1.0).
+   *
+   * @returns New DiceQuery with normalized combined PMF
+   */
+  normalize() {
+    return new _DiceQuery([this.combined.normalize()]);
+  }
+  /**
+   * Returns a new DiceQuery with low-probability outcomes removed.
+   *
+   * @param eps Minimum probability threshold (defaults to PMF epsilon)
+   * @param keepFinalBin Whether to keep the highest damage bin regardless of probability
+   * @returns New DiceQuery with compacted combined PMF
+   */
+  compact(eps, keepFinalBin) {
+    return new _DiceQuery([this.combined.compact(eps, keepFinalBin)]);
+  }
+  /**
+   * Returns a new DiceQuery with an additional scaled branch added.
+   * Useful for conditional outcomes like "30% chance of opportunity attack".
+   *
+   * @param branch DiceQuery to add as a scaled branch
+   * @param probability Probability of the branch occurring (0-1)
+   * @returns New DiceQuery combining this query with the scaled branch
+   *
+   * @example
+   * const baseAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const opportunityAttack = parse("(d20 + 5 AC 15) * (1d8 + 3)");
+   * const withOpportunity = baseAttack.addScaled(opportunityAttack, 0.3);
+   */
+  addScaled(branch, probability) {
+    return new _DiceQuery([
+      this.combined.addScaled(branch.combined, probability)
+    ]);
+  }
+  /**
+   * Returns a new DiceQuery with all probabilities scaled by a factor.
+   * Used for conditional scenarios where the entire outcome has reduced probability.
+   *
+   * @param factor Scaling factor for probabilities
+   * @returns New DiceQuery with scaled probabilities
+   *
+   * @example
+   * const fullAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const conditionalAttack = fullAttack.scaleMass(0.3); // 30% chance scenario
+   */
+  scaleMass(factor) {
+    return new _DiceQuery([this.combined.scaleMass(factor)]);
+  }
+  totalMass() {
+    return this.combined.mass();
+  }
+  /**
+   * Returns a new DiceQuery with damage values transformed by a function.
+   * Useful for applying modifiers, resistances, or other damage transformations.
+   *
+   * @param damageTransformFunction Function to transform each damage value
+   * @returns New DiceQuery with transformed damage values
+   *
+   * @example
+   * const baseAttack = parse("2d6 + 3");
+   * const withResistance = baseAttack.mapDamage(dmg => Math.floor(dmg / 2)); // Half damage
+   * const withBonus = baseAttack.mapDamage(dmg => dmg + 5); // +5 damage
+   */
+  mapDamage(damageTransformFunction) {
+    return new _DiceQuery([this.combined.mapDamage(damageTransformFunction)]);
+  }
+  /**
+   * Returns a new DiceQuery with damage values scaled by a factor.
+   * Convenient wrapper around mapDamage for multiplicative scaling.
+   *
+   * @param factor Scaling factor for damage values
+   * @param rounding Rounding method: "floor" (default), "round", or "ceil"
+   * @returns New DiceQuery with scaled damage values
+   *
+   * @example
+   * const baseAttack = parse("2d6 + 3");
+   * const doubled = baseAttack.scaleDamage(2); // Double damage
+   * const halfDamage = baseAttack.scaleDamage(0.5, "round"); // Half damage, rounded
+   */
+  scaleDamage(factor, rounding = "floor") {
+    return new _DiceQuery([this.combined.scaleDamage(factor, rounding)]);
+  }
+  /**
+   * Returns a new DiceQuery combining this query with another via convolution.
+   * Equivalent to rolling both queries independently and adding results.
+   * It is important to use this rather than combing()ing the PMFs directly!
+   * This method maintains the provenance of the PMFs which is needed for damage attribution.
+   * Combining the .combined PMFs directly is still valid for DPR calculations but
+   * is not statistically sound for queries.
+   *
+   * @param other DiceQuery to combine with
+   * @param eps Optional epsilon for precision control
+   * @returns New DiceQuery representing the combined outcome
+   *
+   * @example
+   * const mainAttack = parse("(d20 + 5 AC 15) * (2d6 + 3)");
+   * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
+   * const bothAttacks = mainAttack.convolve(bonusAttack);
+   */
+  convolve(other, eps) {
+    const singles = [...this.singles, ...other.singles];
+    return new _DiceQuery(singles);
+  }
+  /**
+   * First-success split over an ordered list of DISTINCT single-swing PMFs.
+   * Each PMF may have different success/subset probabilities (from labels).
+   *
+   * successOutcome: e.g., ["success"] or ["hit", "crit"]
+   * subsetOutcome:  e.g., ["subset"] or ["crit"] where subset ⊆ success
+   *
+   * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
+   */
+  firstSuccessSplit(successOutcome, subsetOutcome, eps = COMPUTATIONAL_EPS) {
+    const pmfs = this.singles;
+    if (!pmfs.length) {
+      throw new Error("firstSuccessSplitFromPMFs: pmfs must be non-empty");
+    }
+    const toArr = (x) => Array.isArray(x) ? x : [x];
+    const clamp01 = (x) => Math.max(0, Math.min(1, x));
+    const tol = Math.max(eps, 8 * Number.EPSILON);
+    const per = pmfs.map((pmf) => {
+      const dq = new _DiceQuery([pmf]);
+      const pS = dq.probAtLeastOne(toArr(successOutcome));
+      const pB = dq.probAtLeastOne(toArr(subsetOutcome));
+      if (pB - pS > eps) {
+        throw new Error(
+          "firstSuccessSplitFromPMFs: P(subset) > P(success) for an event. Ensure subset \u2286 success."
+        );
+      }
+      return { pS, pB };
+    });
+    let missSoFar = 1;
+    let pFirstSubset = 0;
+    let pFirstNonSubset = 0;
+    let pNone = 1;
+    for (const { pS, pB } of per) {
+      pFirstSubset += missSoFar * pB;
+      pFirstNonSubset += missSoFar * (pS - pB);
+      const miss = 1 - pS;
+      missSoFar *= miss;
+      pNone *= miss;
+    }
+    const pAny = 1 - pNone;
+    const a = clamp01(pFirstNonSubset);
+    const b = clamp01(pFirstSubset);
+    const any = clamp01(pAny);
+    const none = clamp01(pNone);
+    if (Math.abs(a + b - any) > tol * Math.max(1, any)) {
+      throw new Error(
+        `firstSuccessSplitFromPMFs: parts do not sum to pAny. got a+b=${a + b}, pAny=${any}`
+      );
+    }
+    return [a, b, any, none];
+  }
+};
+_DiceQuery.DEFAULT_OUTCOMES = [
+  "hit",
+  "crit",
+  "missNone"
+];
+var DiceQuery = _DiceQuery;
+var EPSILON = COMPUTATIONAL_EPS;
+var pmfCache = new LRUCache(1e3);
+var _PMF = class _PMF {
+  constructor(map = /* @__PURE__ */ new Map(), epsilon = EPSILON, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvidence = true) {
+    this.map = map;
+    this.epsilon = epsilon;
+    this.normalized = normalized;
+    this.identifier = identifier;
+    this._preservedProvidence = _preservedProvidence;
+  }
+  static empty(epsilon = EPSILON, identifier = "empty") {
+    return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
+  }
+  // This has a single bin at value 0, mass of 1
+  static zero(epsilon = EPSILON) {
+    const m = /* @__PURE__ */ new Map();
+    m.set(0, { p: 1, count: { miss: 1 }, attr: {} });
+    return new _PMF(m, epsilon, false, "zero");
+  }
+  // This creates a single bin at value 0, but with weight 0.
+  static emptyMass(epsilon = EPSILON) {
+    return _PMF.zero().scaleMass(0);
+  }
+  //  Makes PMF iterable over [damage, bin] pairs.
+  [Symbol.iterator]() {
+    return this.map[Symbol.iterator]();
+  }
+  static clearCache() {
+    pmfCache.clear();
+  }
+  /**
+   * Creates a conditional PMF from two branches (success and failure) and a probability.
+   * This is the core logic for modeling any probabilistic event where there are two
+   * distinct outcomes.
+   */
+  static branch(successPMF, failurePMF, successProbability) {
+    let p = successProbability;
+    if (!Number.isFinite(p)) p = 0;
+    if (p < 0) p = 0;
+    if (p > 1) p = 1;
+    const q = 1 - p;
+    if (p === 0) return failurePMF.scaleMass(1);
+    if (p === 1) return successPMF.scaleMass(1);
+    const eps = successPMF.epsilon ?? failurePMF.epsilon;
+    const id = `branch(${failurePMF.identifier}*${q.toFixed(6)} + ${successPMF.identifier}*${p.toFixed(6)})`;
+    const out = _PMF.empty(eps, id).addScaled(failurePMF, q).addScaled(successPMF, p);
+    return out;
+  }
+  /**
+   * withProbability()
+   *
+   * A convenience wrapper around branch() for the common case where the "failure" branch is always zero().
+   *
+   *  Think of this as a shortcut for:
+   *    pmf.gate(p, PMF.zero())
+   *
+   * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,
+   * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.
+   *
+   * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.
+   * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.
+   * - For modeling "first success" logic across multiple attacks (like Sneak Attack or Smite)
+   *   use query.firstSuccessSplit() to get the exact probabilities.
+   * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().
+   *
+   */
+  static withProbability(successPMF, probability) {
+    return _PMF.branch(successPMF, _PMF.zero(), probability);
+  }
+  /**
+   * gate()
+   *
+   * A conditional wrapper around branch() that applies this PMF with probability `p`,
+   * and applies a provided fallback PMF otherwise.
+   *
+   * This is useful for modeling a binary choice between two outcomes:
+   * - The "success" outcome (this PMF) happens with probability `p`.
+   * - The "failure" outcome (fallback PMF) happens with probability `1 - p`.
+   *
+   * Examples:
+   * - 25% chance to include an opportunity attack, otherwise nothing:
+   *     attackPMF.gate(0.25, PMF.zero())
+   *
+   * - 50% chance to deal fireball damage, otherwise cone of cold damage:
+   *     fireballPMF.gate(0.5, coneOfColdPMF)
+   *
+   * Relationship to other helpers:
+   * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.
+   * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).
+   *
+   * @param p Probability of applying this PMF (between 0 and 1).
+   * @param fallback PMF to apply when this PMF is *not* selected.
+   * @returns A new PMF representing the weighted mixture of this PMF and the fallback.
+   */
+  gate(p, zero) {
+    return _PMF.branch(this, zero, p);
+  }
+  /**
+   * PMF.exclusive()
+   *
+   * Builds a single PMF from a set of mutually exclusive weighted outcomes.
+   * Exactly one of the provided options will occur.
+   *
+   * Each option has:
+   *  - A PMF representing its outcome (e.g., damage dice).
+   *  - A weight representing its probability of being selected.
+   *
+   * This is useful for modeling situations like:
+   *  - Sneak Attack: 6d6 if first hit is a crit, 3d6 if first hit is non-crit, 0 otherwise.
+   *  - Multiple exclusive spells: Fireball vs Cone of Cold vs nothing.
+   *
+   * Notes:
+   *  - If the total weight is less than 1, a zero PMF will automatically be added to
+   *    make up the remaining probability.
+   *  - Throws an error if the total weight is greater than 1 (invalid probability sum).
+   *
+   * @param options Array of `{ pmf, weight }` objects, each representing an outcome and its probability.
+   * @param label Optional name for debugging or charting.
+   * @param eps Optional tolerance for floating point rounding
+   * @returns A single PMF representing the exclusive mixture of all options.
+   */
+  static exclusive(options, eps = 1e-12) {
+    const items = options.map(
+      (o) => Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o
+    );
+    const totalWeight = items.reduce((s, { weight }) => s + weight, 0);
+    if (totalWeight - 1 > eps) {
+      throw new Error(
+        `PMF.exclusive: total weight ${totalWeight.toFixed(6)} exceeds 1.`
+      );
+    }
+    let out = items.reduce(
+      (acc, { pmf, weight }) => weight > 0 ? acc.addScaled(pmf, weight) : acc,
+      _PMF.empty(eps)
+    );
+    const leftover = 1 - totalWeight;
+    if (leftover > eps) {
+      out = out.addScaled(_PMF.zero(), leftover);
+    }
+    return out;
+  }
+  /**
+   * General-purpose N-way mixture.
+   * weights: Array of [weight, PMF].
+   *
+   * Example: PMF.mixN([
+   *   [pMiss, zero],
+   *   [pHit, hitPMF],
+   *   [pCrit, critPMF],
+   * ]);
+   */
+  static mixN(weights) {
+    const eps = 1e-12;
+    const filtered = weights.filter(([w]) => w > eps);
+    if (filtered.length === 0) {
+      return _PMF.emptyMass();
+    }
+    let acc = null;
+    let sum = 0;
+    for (const [w, pmf] of filtered) {
+      if (acc === null) {
+        acc = pmf;
+        sum = w;
+      } else {
+        const q = w / (sum + w);
+        acc = _PMF.branch(pmf, acc, q);
+        sum += w;
+      }
+    }
+    return acc ?? _PMF.emptyMass();
+  }
+  // This is a convenience method for when we use power
+  // TODO: It can be smarter in the future, and we can also add it to query
+  // That way statistics operations on invalid PMFs can throw an error
+  // TODO… how can we detect if manually merging two queries' combined PMFs, as that loses providence?
+  setPreservedProvidence(preserved) {
+    if (!this._preservedProvidence && preserved) {
+      throw new Error(
+        "Preserved providence is already set to false, cannot fix that"
+      );
+    }
+    this._preservedProvidence = preserved;
+  }
+  preservedProvidence() {
+    return this._preservedProvidence;
+  }
+  /**
+   * Efficiently computes this PMF convolved with itself `n` times.
+   * Uses exponentiation by squaring to reduce total convolutions.
+   * n must be a positive integer.
+   * *
+   * * NOTE: This folds multiple independent attacks into a single PMF.
+   * As a result, The power() method causes a loss of data provenance.
+   * This is ONLY SAFE if you are trying to calculate masses.
+   * If you want to query any atLeast probabilities, you should use the DiceQuery class instead without power().
+   */
+  power(n, eps = this.epsilon) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new Error("power(n): n must be a positive integer");
+    }
+    if (n === 1) return this;
+    const epsilon = eps ?? this.epsilon;
+    const key = getPowerCacheKey(this, n, epsilon);
+    {
+      const cached = pmfCache?.get(key);
+      if (cached) return cached;
+    }
+    let base = this.normalized ? this : this.normalize();
+    let result = base;
+    let exp = n - 1;
+    while (exp > 0) {
+      if (exp & 1) {
+        result = result.convolve(base, epsilon);
+      }
+      exp >>= 1;
+      if (exp > 0) {
+        base = base.convolve(base, epsilon);
+      }
+    }
+    result.setPreservedProvidence(false);
+    {
+      pmfCache?.set(key, result);
+    }
+    return result;
+  }
+  /*
+   * Helper for chaining multiple identical attacks
+   */
+  replicate(n, eps = this.epsilon) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new Error("combineN(n): n must be a positive integer");
+    }
+    if (n === 1) return [this];
+    return Array.from({ length: n }, () => this);
+  }
+  mass() {
+    if (this._totalMass === void 0) {
+      let totalProbabilityMass = 0;
+      for (const { p } of this.map.values()) {
+        totalProbabilityMass += p;
+      }
+      this._totalMass = totalProbabilityMass;
+    }
+    return this._totalMass;
+  }
+  outcomeMass(outcome) {
+    let totalProbabilityMass = 0;
+    for (const { p, count } of this.map.values()) {
+      totalProbabilityMass += p * count[outcome];
+    }
+    return totalProbabilityMass;
+  }
+  // Helper for testing
+  faceTotal() {
+    return [...this.map.keys()].reduce((sum, key) => sum + key, 0);
+  }
+  normalize() {
+    if (this.normalized) return this;
+    const normalizationFactor = this.mass();
+    if (normalizationFactor === 0) return this;
+    const normalizedMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, probabilityBin] of this.map) {
+      const normalizedProbability = probabilityBin.p / normalizationFactor;
+      const normalizedCount = {};
+      for (const labelKey in probabilityBin.count) {
+        normalizedCount[labelKey] = probabilityBin.count[labelKey] / normalizationFactor;
+      }
+      let normalizedAttributes;
+      if (probabilityBin.attr) {
+        normalizedAttributes = {};
+        for (const labelKey in probabilityBin.attr) {
+          normalizedAttributes[labelKey] = probabilityBin.attr[labelKey] / normalizationFactor;
+        }
+      }
+      normalizedMap.set(damageValue, {
+        p: normalizedProbability,
+        count: normalizedCount,
+        attr: normalizedAttributes
+      });
+    }
+    return new _PMF(normalizedMap, this.epsilon, true, this.identifier);
+  }
+  /**
+   * Returns a copy with negligible probabilities removed (p < eps).
+   * If keepFinalBin is true, the bin with the largest key is always kept,
+   * even if its probability is below eps. count/attr submaps are still cleaned.
+   */
+  compact(eps = this.epsilon, keepFinalBin = false) {
+    let maxKey = -Infinity;
+    if (keepFinalBin) {
+      for (const key of this.map.keys()) {
+        if (key > maxKey) maxKey = key;
+      }
+    }
+    const compactedMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, probabilityBin] of this.map) {
+      const shouldKeep = probabilityBin.p >= eps || keepFinalBin && damageValue === maxKey;
+      if (!shouldKeep) continue;
+      for (const labelKey in probabilityBin.count) {
+        if (Math.abs(probabilityBin.count[labelKey] || 0) < eps) {
+          delete probabilityBin.count[labelKey];
+        }
+      }
+      if (probabilityBin.attr) {
+        for (const labelKey in probabilityBin.attr) {
+          if (Math.abs(probabilityBin.attr[labelKey] || 0) < eps) {
+            delete probabilityBin.attr[labelKey];
+          }
+        }
+        if (Object.keys(probabilityBin.attr).length === 0) {
+          probabilityBin.attr = void 0;
+        }
+      }
+      compactedMap.set(damageValue, probabilityBin);
+    }
+    return new _PMF(compactedMap, eps, this.normalized, this.identifier);
+  }
+  // Note: The "support" of a PMF is the set of all non-zero probability outcomes.
+  // This returns all damage values with non-zero probability, sorted ascending.
+  support() {
+    if (this._support === void 0) {
+      this._support = [...this.map.keys()].sort((a, b) => a - b);
+    }
+    return this._support;
+  }
+  // Minimum possible damage value.
+  min() {
+    if (this._min === void 0) {
+      const support = this.support();
+      this._min = support.length > 0 ? support[0] : 0;
+    }
+    return this._min;
+  }
+  // Maximum possible damage value.
+  max() {
+    if (this._max === void 0) {
+      const support = this.support();
+      this._max = support.length > 0 ? support[support.length - 1] : 0;
+    }
+    return this._max;
+  }
+  /**
+   * Returns the expected (mean) damage value.
+   * Cached for performance since this requires iterating through all bins.
+   */
+  mean() {
+    if (this._mean === void 0) {
+      let totalSum = 0;
+      for (const [damageValue, probabilityBin] of this.map) {
+        totalSum += damageValue * probabilityBin.p;
+      }
+      this._mean = totalSum;
+    }
+    return this._mean;
+  }
+  /**
+   * Returns the variance of the damage distribution.
+   * Cached for performance since this requires mean calculation plus iteration.
+   */
+  variance() {
+    if (this._variance === void 0) {
+      const meanValue = this.mean();
+      let varianceSum = 0;
+      for (const [damageValue, probabilityBin] of this.map) {
+        const deviationFromMean = damageValue - meanValue;
+        varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;
+      }
+      this._variance = varianceSum;
+    }
+    return this._variance;
+  }
+  /**
+   * Returns the standard deviation of the damage distribution.
+   */
+  stdev() {
+    if (this._stdev === void 0) {
+      this._stdev = Math.sqrt(this.variance());
+    }
+    return this._stdev;
+  }
+  static mergeInto(destinationMap, damageValue, binToAdd) {
+    const existingBin = destinationMap.get(damageValue);
+    if (!existingBin) {
+      destinationMap.set(damageValue, {
+        p: binToAdd.p,
+        count: { ...binToAdd.count },
+        attr: binToAdd.attr ? { ...binToAdd.attr } : void 0
+      });
+      return;
+    }
+    existingBin.p += binToAdd.p;
+    for (const labelKey in binToAdd.count) {
+      existingBin.count[labelKey] = (existingBin.count[labelKey] || 0) + binToAdd.count[labelKey];
+    }
+    if (binToAdd.attr) {
+      if (!existingBin.attr) {
+        existingBin.attr = {};
+      }
+      for (const labelKey in binToAdd.attr) {
+        existingBin.attr[labelKey] = (existingBin.attr[labelKey] || 0) + binToAdd.attr[labelKey];
+      }
+    }
+  }
+  // Convenience method
+  add(other) {
+    return this.addScaled(other, 1);
+  }
+  /**
+   * Returns a new PMF with a scaled branch added to this one.
+   * The branch PMF is scaled by the given probability before merging
+   * This will be very useful for conditional effects and for being
+   * able to model "I can probably have this opportunity attack 40% of rounds"
+   * Example: `pmf.addScaled(critBranch, 0.05)` → PMF including 5% crit outcomes
+   */
+  addScaled(branch, probability) {
+    if (probability === 0) return this;
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const [dmg, bin] of this.map) {
+      resultMap.set(dmg, {
+        p: bin.p,
+        count: { ...bin.count },
+        attr: bin.attr ? { ...bin.attr } : void 0
+      });
+    }
+    for (const [damageValue, probabilityBin] of branch.map) {
+      const scaledCount = {};
+      for (const k in probabilityBin.count) {
+        scaledCount[k] = probability * probabilityBin.count[k];
+      }
+      let scaledAttributes;
+      if (probabilityBin.attr) {
+        scaledAttributes = {};
+        for (const k in probabilityBin.attr) {
+          scaledAttributes[k] = probability * probabilityBin.attr[k];
+        }
+      }
+      _PMF.mergeInto(resultMap, damageValue, {
+        p: probability * probabilityBin.p,
+        count: scaledCount,
+        attr: scaledAttributes
+      });
+    }
+    return new _PMF(
+      resultMap,
+      this.epsilon,
+      false,
+      `${this.identifier}+scaled(${branch.identifier},${probability})`
+    );
+  }
+  scaleMass(factor) {
+    if (factor === 1) return this;
+    const scaledMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, probabilityBin] of this.map) {
+      const scaledCount = {};
+      for (const labelKey in probabilityBin.count) {
+        scaledCount[labelKey] = probabilityBin.count[labelKey] * factor;
+      }
+      let scaledAttributes;
+      if (probabilityBin.attr) {
+        scaledAttributes = {};
+        for (const labelKey in probabilityBin.attr) {
+          scaledAttributes[labelKey] = probabilityBin.attr[labelKey] * factor;
+        }
+      }
+      scaledMap.set(damageValue, {
+        p: probabilityBin.p * factor,
+        count: scaledCount,
+        attr: scaledAttributes
+      });
+    }
+    return new _PMF(
+      scaledMap,
+      this.epsilon,
+      false,
+      `scale(${this.identifier},${factor})`
+    );
+  }
+  mapDamage(damageTransformFunction) {
+    const transformedMap = /* @__PURE__ */ new Map();
+    for (const [originalDamage, probabilityBin] of this.map) {
+      const transformedDamage = damageTransformFunction(originalDamage);
+      _PMF.mergeInto(transformedMap, transformedDamage, {
+        p: probabilityBin.p,
+        count: { ...probabilityBin.count },
+        attr: probabilityBin.attr ? { ...probabilityBin.attr } : void 0
+      });
+    }
+    return new _PMF(
+      transformedMap,
+      this.epsilon,
+      this.normalized,
+      `map(${this.identifier})`
+    );
+  }
+  scaleDamage(factor, rounding = "floor") {
+    const roundFunction = rounding === "round" ? Math.round : rounding === "ceil" ? Math.ceil : Math.floor;
+    return this.mapDamage((damageValue) => roundFunction(damageValue * factor));
+  }
+  getPMFCombineCacheKey(p1, p2, eps, raw) {
+    const [id1, id2] = [p1.identifier, p2.identifier].sort();
+    const fp = (x) => {
+      const m = x.mass().toFixed(12);
+      const n = x.map.size;
+      let faceSum = 0;
+      for (const k of x.map.keys()) faceSum += k;
+      return `${m}|${n}|${faceSum}`;
+    };
+    return `v4:${raw ? "RAW" : "N"}:${id1}+${id2}@${eps}|${fp(p1)}|${fp(p2)}`;
+  }
+  convolve(other, eps, raw = false) {
+    const epsilon = eps ?? this.epsilon;
+    const norm = (x) => raw ? x : Math.abs(x.mass() - 1) <= 1e-12 ? x : x.normalize();
+    const A0 = norm(this);
+    const B0 = norm(other);
+    const [A, B] = A0.identifier <= B0.identifier ? [A0, B0] : [B0, A0];
+    const cacheKey = this.getPMFCombineCacheKey(A, B, epsilon, raw);
+    const cached = pmfCache?.get(cacheKey);
+    if (cached) return cached;
+    const combinedMap = /* @__PURE__ */ new Map();
+    for (const [aVal, aBin] of A.map) {
+      for (const [bVal, bBin] of B.map) {
+        const p = aBin.p * bBin.p;
+        const dmg = aVal + bVal;
+        const count = {};
+        for (const k in aBin.count)
+          count[k] = (count[k] || 0) + aBin.count[k] * bBin.p;
+        for (const k in bBin.count)
+          count[k] = (count[k] || 0) + bBin.count[k] * aBin.p;
+        let attr;
+        if (aBin.attr || bBin.attr) {
+          attr = {};
+          if (aBin.attr)
+            for (const k in aBin.attr)
+              attr[k] = (attr[k] || 0) + aBin.attr[k] * bBin.p;
+          if (bBin.attr)
+            for (const k in bBin.attr)
+              attr[k] = (attr[k] || 0) + bBin.attr[k] * aBin.p;
+        }
+        _PMF.mergeInto(combinedMap, dmg, { p, count, attr });
+      }
+    }
+    let result = new _PMF(
+      combinedMap,
+      epsilon,
+      !raw,
+      `${A.identifier}${raw ? "*" : "+"}${B.identifier}`
+      // ← canonical order
+    );
+    const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);
+    const mGot = result.mass();
+    if (mExp !== 0 && Math.abs(mGot - mExp) > 1e-12) {
+      result = result.scaleMass(mExp / mGot);
+    }
+    if (!raw && Math.abs(result.mass() - 1) > 1e-12)
+      result = result.normalize();
+    pmfCache?.set(cacheKey, result);
+    return result;
+  }
+  // 3) Nice wrapper so you can call pmf.combineRaw(other)
+  combineRaw(other, eps) {
+    return this.convolve(other, eps, true);
+  }
+  // Collapse repeated identical PMFs using power() and return a sorted list
+  // Temporarily disabled for now. This was used for a performance optimization, but can lose data provenance.
+  //   private static collapseIdentical(pmfList: PMF[], eps: number): PMF[] {
+  //     const grouped = new Map<string, { pmf: PMF; count: number }>();
+  //     for (const pmf of pmfList) {
+  //       const id = pmf.identifier;
+  //       const g = grouped.get(id);
+  //       if (g) g.count++;
+  //       else grouped.set(id, { pmf, count: 1 });
+  //     }
+  //     if (grouped.size >= pmfList.length) return pmfList;
+  //     const collapsed: PMF[] = [];
+  //     for (const { pmf, count } of grouped.values()) {
+  //       collapsed.push(count > 1 ? pmf.power(count, eps) : pmf);
+  //     }
+  //     // Stable order for better cache locality
+  //     collapsed.sort((a, b) =>
+  //       a.identifier < b.identifier ? -1 : a.identifier > b.identifier ? 1 : 0
+  //     );
+  //     return collapsed;
+  //   }
+  // Reduce a list of PMFs by left-folding convolve() with the given eps
+  static reduceConvolveLeft(pmfList, eps) {
+    let result = pmfList[0];
+    for (let i = 1; i < pmfList.length; i++) {
+      result = result.convolve(pmfList[i], eps);
+    }
+    return result;
+  }
+  /**
+   * Convolves multiple PMFs using linear convolution with automatic caching.
+   * Uses a left-to-right accumulation approach for maximum cache reuse.
+   * Each convolve() call automatically uses the convolution cache for performance.
+   *
+   * This linear approach provides better cache hits than pairwise because:
+   * - Intermediate results are more predictable and stable
+   * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
+   * - Order-independent cache keys work better with consistent build patterns
+   */
+  static convolveMany(pmfList, eps = EPSILON) {
+    if (pmfList.length === 0) return _PMF.empty(eps);
+    if (pmfList.length === 1) return pmfList[0];
+    return _PMF.reduceConvolveLeft(pmfList, eps);
+  }
+  toJSON() {
+    return JSON.stringify({
+      bins: [...this.map.entries()],
+      normalized: this.normalized,
+      identifier: this.identifier
+    });
+  }
+  static fromJSON(jsonData) {
+    return new _PMF(
+      new Map(jsonData.bins),
+      EPSILON,
+      !!jsonData.normalized,
+      jsonData.identifier || "fromJSON"
+    );
+  }
+  /**
+   * Relative pruning with optional top-K floor.
+   * Keeps bins with p >= epsRel * peak, always keeps min and max damage,
+   * optionally guarantees at least `minBins` survivors by adding top-K.
+   * Returns a new, non-normalized PMF.
+   */
+  pruneRelative(epsRel, minBins = 0) {
+    const size = this.map.size;
+    if (size === 0) return this;
+    let peak = 0;
+    let minDamage = Number.POSITIVE_INFINITY;
+    let maxDamage = Number.NEGATIVE_INFINITY;
+    for (const [dmg, bin] of this.map) {
+      if (bin.p > peak) peak = bin.p;
+      if (dmg < minDamage) minDamage = dmg;
+      if (dmg > maxDamage) maxDamage = dmg;
+    }
+    if (peak === 0)
+      return new _PMF(new Map(this.map), this.epsilon, false, this.identifier);
+    const thresh = epsRel * peak;
+    const entries = [...this.map.entries()];
+    const survivorsByDmg = /* @__PURE__ */ new Map();
+    const protect = (d) => {
+      const b = this.map.get(d);
+      if (b) survivorsByDmg.set(d, b);
+    };
+    protect(minDamage);
+    if (maxDamage !== minDamage) protect(maxDamage);
+    for (const [dmg, bin] of entries) {
+      if (bin.p >= thresh) survivorsByDmg.set(dmg, bin);
+    }
+    if (minBins > 0 && survivorsByDmg.size < minBins) {
+      entries.sort((a, b) => b[1].p - a[1].p);
+      for (const [dmg, bin] of entries) {
+        if (!survivorsByDmg.has(dmg)) {
+          survivorsByDmg.set(dmg, bin);
+          if (survivorsByDmg.size >= minBins) break;
+        }
+      }
+    }
+    const prunedMap = /* @__PURE__ */ new Map();
+    for (const [dmg, bin] of survivorsByDmg) {
+      const newCount = {};
+      for (const k in bin.count) {
+        const v = bin.count[k];
+        if (Math.abs(v) >= thresh) newCount[k] = v;
+      }
+      let newAttr;
+      if (bin.attr) {
+        for (const k in bin.attr) {
+          const v = bin.attr[k];
+          if (Math.abs(v) >= thresh) {
+            if (!newAttr) newAttr = {};
+            newAttr[k] = v;
+          }
+        }
+      }
+      prunedMap.set(dmg, { p: bin.p, count: newCount, attr: newAttr });
+    }
+    return new _PMF(prunedMap, this.epsilon, false, `prune(${this.identifier})`);
+  }
+  /** NEW - REVIEW IF THESE ARE USEFUL OR DUPLCIATIVE?  */
+  /** Probability mass at exactly x. */
+  pAt(x) {
+    return this.map.get(x)?.p ?? 0;
+  }
+  /** Dense integer support from min..max (inclusive).
+   * Useful for showing empty bars in charts.
+   */
+  denseSupport() {
+    const s = this.support();
+    if (s.length === 0) return [];
+    const lo = Math.min(...s), hi = Math.max(...s);
+    return Array.from({ length: hi - lo + 1 }, (_, i) => lo + i).sort(
+      (a, b) => a - b
+    );
+  }
+  /** CDF at x: P(X ≤ x). */
+  cdfAt(x) {
+    let acc = 0;
+    for (const [val, bin] of this.map) if (val <= x) acc += bin.p;
+    return acc;
+  }
+  /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
+  quantile(p) {
+    if (this.map.size === 0) return 0;
+    const s = this.support().sort((a, b) => a - b);
+    let acc = 0;
+    for (const x of s) {
+      acc += this.pAt(x);
+      if (acc >= p) return x;
+    }
+    return s[s.length - 1];
+  }
+  /** Get outcome probability at specific damage value. */
+  outcomeAt(damage, outcome) {
+    return this.map.get(damage)?.count[outcome] ?? 0;
+  }
+  /** Get all outcome types present in this PMF. */
+  outcomes() {
+    const outcomeSet = /* @__PURE__ */ new Set();
+    for (const [, bin] of this.map) {
+      for (const outcome in bin.count) {
+        if (bin.count[outcome] > 0) {
+          outcomeSet.add(outcome);
+        }
+      }
+    }
+    return Array.from(outcomeSet).sort();
+  }
+  /** Get total probability of an outcome across all damage values. */
+  outcomeProbability(outcome) {
+    let total = 0;
+    for (const [, bin] of this.map) {
+      total += bin.count[outcome] ?? 0;
+    }
+    return total;
+  }
+  /** Get damage attribution for an outcome at specific damage value. */
+  outcomeAttributionAt(damage, outcome) {
+    return this.map.get(damage)?.attr?.[outcome] ?? 0;
+  }
+  /** Get all outcome data at specific damage value. */
+  binAt(damage) {
+    const bin = this.map.get(damage);
+    if (!bin) return null;
+    return {
+      p: bin.p,
+      count: { ...bin.count },
+      attr: bin.attr ? { ...bin.attr } : void 0
+    };
+  }
+  /** Check if outcome exists in this PMF. */
+  hasOutcome(outcome) {
+    for (const [, bin] of this.map) {
+      if ((bin.count[outcome] ?? 0) > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns a new PMF containing only bins where the specified outcome has non-zero probability.
+   * This creates a marginal distribution for the given outcome type, with probabilities
+   * scaled to represent the unconditional mass attributable to that outcome.
+   */
+  filterOutcome(outcome) {
+    const filteredMap = /* @__PURE__ */ new Map();
+    for (const [damageValue, bin] of this.map) {
+      const outcomeCount = bin.count[outcome] ?? 0;
+      const totalCount = Object.values(bin.count ?? {}).reduce(
+        (a, b) => (a ?? 0) + (b ?? 0),
+        0
+      );
+      if (outcomeCount > 0 && totalCount !== void 0 && totalCount > 0) {
+        const proportion = outcomeCount / totalCount;
+        const newP = bin.p * proportion;
+        const newCount = { [outcome]: outcomeCount };
+        let newAttr;
+        if (bin.attr && bin.attr[outcome] !== void 0) {
+          newAttr = { [outcome]: bin.attr[outcome] * proportion };
+        }
+        filteredMap.set(damageValue, {
+          p: newP,
+          count: newCount,
+          attr: newAttr
+        });
+      }
+    }
+    return new _PMF(
+      filteredMap,
+      this.epsilon,
+      false,
+      // don't normalize by default
+      `filter(${this.identifier},${outcome})`
+    );
+  }
+  /**
+   * Calculates probabilities for first-success outcomes across n independent attempts.
+   *
+   * @param pSuccess - Total probability of any success on a single attempt.
+   * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).
+   * @param n - Number of independent attempts.
+   *
+   * Returns:
+   *  - pSpecificSuccess: Probability that the first success was of the "special" type
+   *  - pGeneralSuccess: Probability that the first success was of the non-special type
+   *  - pNone: Probability that no successes occurred
+   *  - pAny: Probability that at least one success occurred
+   */
+  static firstSuccessWeights(pSuccess, pSpecial, n) {
+    const pFail = 1 - pSuccess;
+    const pFailAll = Math.pow(pFail, n);
+    const pAny = 1 - pFailAll;
+    const denom = pSuccess === 0 ? 1 : pSuccess;
+    const pSpecificSuccess = pSpecial * pAny / denom;
+    const pGeneralSuccess = (pSuccess - pSpecial) * pAny / denom;
+    const pNone = 1 - pSpecificSuccess - pGeneralSuccess;
+    return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };
+  }
+  query() {
+    return new DiceQuery(this);
+  }
+};
+// Unique ID generator for anonymous PMFs to avoid cache key collisions
+_PMF.__anonIdCounter = 1;
+var PMF = _PMF;
+function getPowerCacheKey(base, n, eps) {
+  const id = base.identifier;
+  let key = `${id}`;
+  for (let i = 1; i < n; i++) key += `+${id}`;
+  return `${key}@${eps}`;
+}
+
+// src/dice.ts
+var Dice = class _Dice {
+  constructor(x = 0) {
+    this.faces = {};
+    this.privateData = {};
+    this.outcomeData = {};
+    this.hasHitDistributionCalculated = false;
+    if (x <= 0) return;
+    for (let i = 1; i <= x; i++) {
+      this.faces[i] = 1;
+    }
+  }
+  getOutcomeDistribution(key) {
+    if (key === "hit") {
+      this.ensureHitDistribution();
+    }
+    return this.outcomeData[key];
+  }
+  getFullOutcomeDistribution() {
+    return { ...this.outcomeData };
+  }
+  setOutcomeDistribution(key, data) {
+    if (data) {
+      this.outcomeData[key] = data;
+    } else {
+      delete this.outcomeData[key];
+    }
+  }
+  hasOutcomeData(key) {
+    if (key === "hit") {
+      this.ensureHitDistribution();
+    }
+    const data = this.outcomeData[key];
+    return data !== void 0 && Object.keys(data).length > 0;
+  }
+  getOutcomeCount(key, face) {
+    return this.outcomeData[key]?.[face] ?? 0;
+  }
+  getAverage(key) {
+    const distribution = this.getOutcomeDistribution(key);
+    if (!distribution) return 0;
+    const totalCount = Object.values(distribution).reduce(
+      (sum, count) => sum + count,
+      0
+    );
+    const expectedDamage = Object.entries(distribution).reduce(
+      (sum, [damage, count]) => sum + Number(damage) * count,
+      0
+    );
+    if (totalCount === 0) return 0;
+    return expectedDamage / totalCount;
+  }
+  // TODO this can be private later if we change how testing works
+  calculateHitDistribution() {
+    const hitValues = {};
+    for (const [face, totalCount] of Object.entries(this.faces)) {
+      const numFace = Number(face);
+      let hitCount = totalCount;
+      for (const outcomeType of [
+        "crit",
+        "missNone",
+        "missDamage",
+        "saveHalf",
+        "saveFail",
+        "pc"
+      ]) {
+        const distribution = this.getOutcomeDistribution(outcomeType);
+        if (distribution && distribution[numFace]) {
+          hitCount -= distribution[numFace];
+        }
+      }
+      if (numFace === 0) {
+        hitCount = 0;
+      }
+      if (hitCount < 0) {
+        console.error("hitCount is <=0?", face, totalCount, hitCount);
+        hitCount = 0;
+      }
+      hitValues[numFace] = hitCount;
+    }
+    return hitValues;
+  }
+  ensureHitDistribution() {
+    if (!this.hasHitDistributionCalculated) {
+      const hitValues = this.calculateHitDistribution();
+      this.setOutcomeDistribution("hit", hitValues);
+      this.hasHitDistributionCalculated = true;
+    }
+  }
+  // PRIVATE FUNCTIONS
+  binaryOp(other, op, diceConstructor) {
+    const result = diceConstructor ? diceConstructor() : new _Dice();
+    const isScalar = typeof other === "number";
+    const keys1 = this.keys();
+    for (const key1 of keys1) {
+      const value1 = this.faces[key1];
+      if (isScalar) {
+        const resultKey = op(key1, other);
+        result.increment(resultKey, value1);
+      } else {
+        const keys2 = other.keys();
+        for (const key2 of keys2) {
+          const value2 = other.faces[key2];
+          const resultKey = op(key1, key2);
+          result.increment(resultKey, value1 * value2);
+        }
+      }
+    }
+    return result;
+  }
+  removeFaces(facesToRemove) {
+    const result = new _Dice();
+    for (const [key, value] of Object.entries(this.faces)) {
+      const numKey = Number(key);
+      if (!facesToRemove.includes(numKey)) {
+        result.faces[numKey] = value;
+      }
+    }
+    result.privateData = { ...this.privateData };
+    result.outcomeData = { ...this.outcomeData };
+    return result;
+  }
+  // PUBLIC FUNTIONS
+  getFaceEntries() {
+    return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);
+  }
+  getFaceMap() {
+    return { ...this.faces };
+  }
+  get(face) {
+    return this.faces[face] ?? 0;
+  }
+  keys() {
+    return Object.keys(this.faces).map(Number);
+  }
+  values() {
+    return Object.values(this.faces);
+  }
+  total() {
+    return Object.values(this.faces).reduce((sum, value) => sum + value, 0);
+  }
+  setFace(key, value) {
+    this.faces[key] = value;
+  }
+  static scalar(value) {
+    const result = new _Dice();
+    result.increment(value, 1);
+    return result;
+  }
+  maxFace() {
+    const numericKeys = this.keys();
+    if (numericKeys.length === 0) {
+      throw new Error("No numeric faces found");
+    }
+    return Math.max(...numericKeys);
+  }
+  minFace() {
+    const numericKeys = this.keys();
+    if (numericKeys.length === 0) {
+      throw new Error("No numeric faces found");
+    }
+    return Math.min(...numericKeys);
+  }
+  increment(face, count) {
+    const current = this.faces[face] || 0;
+    this.faces[face] = current + count;
+  }
+  normalize(scalar) {
+    const result = new _Dice();
+    for (const [face, count] of Object.entries(this.faces)) {
+      result.faces[Number(face)] = count * scalar;
+    }
+    result.privateData = { ...this.privateData };
+    result.outcomeData = { ...this.outcomeData };
+    return result;
+  }
+  // OPERATIONS
+  add(other) {
+    return this.binaryOp(other, (a, b) => a + b);
+  }
+  subtract(other) {
+    return this.binaryOp(other, (a, b) => a - b);
+  }
+  conditionalApply(other) {
+    return this.binaryOp(other, (a, b) => (a === 0 ? 0 : 1) * b);
+  }
+  multiply(other) {
+    return this.binaryOp(other, (a, b) => a * b);
+  }
+  addNonZero(other) {
+    return this.binaryOp(other, (a, b) => a !== 0 ? a + b : a);
+  }
+  eq(other) {
+    return this.binaryOp(other, (a, b) => a === b ? 1 : 0);
+  }
+  max(other) {
+    return this.binaryOp(other, (a, b) => Math.max(a, b));
+  }
+  min(other) {
+    return this.binaryOp(other, (a, b) => Math.min(a, b));
+  }
+  advantage() {
+    return this.max(this);
+  }
+  ge(other) {
+    return this.binaryOp(other, (a, b) => a >= b ? 0 : 1);
+  }
+  divide(other) {
+    return this.binaryOp(other, (a, b) => a / b);
+  }
+  divideRoundUp(other) {
+    return this.binaryOp(other, (a, b) => Math.ceil(a / b));
+  }
+  divideRoundDown(other) {
+    return this.binaryOp(other, (a, b) => Math.floor(a / b));
+  }
+  and(other) {
+    return this.binaryOp(other, (a, b) => a && b ? 1 : 0);
+  }
+  checkTarget(other, comparisonLogic) {
+    const createResult = () => {
+      const result = new _Dice();
+      result.increment(0, 0);
+      result.increment(1, 0);
+      return result;
+    };
+    return this.binaryOp(other, comparisonLogic, createResult);
+  }
+  dc(other) {
+    const dcCheck = (a, b) => a >= b ? 0 : 1;
+    const result = this.checkTarget(other, dcCheck);
+    result.privateData.isDCCheck = true;
+    return result;
+  }
+  ac(other) {
+    const acCheck = (a, b) => a >= b ? a : 0;
+    return this.checkTarget(other, acCheck);
+  }
+  deleteFace(face) {
+    const result = new _Dice();
+    for (const [key, value] of Object.entries(this.faces)) {
+      const numKey = Number(key);
+      if (numKey !== face) {
+        result.increment(numKey, value);
+      }
+    }
+    result.privateData = { ...this.privateData };
+    result.outcomeData = { ...this.outcomeData };
+    return result;
+  }
+  reroll(toReroll) {
+    const rerollDice = typeof toReroll === "number" ? _Dice.scalar(toReroll) : toReroll;
+    const removed = this.removeFaces(rerollDice.keys());
+    let result = new _Dice();
+    for (const face of this.keys()) {
+      const wasRerolled = rerollDice.keys().includes(face);
+      result = result.combine(removed);
+      if (wasRerolled) {
+        result = result.combine(this);
+      }
+    }
+    return result;
+  }
+  // This is not addition and not rolling two dice at once.
+  // Instead, it’s mixing two distributions into a single weighted die.
+  combine(other) {
+    if (typeof other === "number") {
+      other = _Dice.scalar(other);
+    }
+    const result = new _Dice();
+    for (const [key, value] of Object.entries(other.faces)) {
+      result.faces[Number(key)] = value;
+    }
+    const except = new _Dice();
+    for (const [key, value] of Object.entries(this.faces)) {
+      const numKey = Number(key);
+      result.increment(numKey, value);
+      if (!(numKey in other.faces)) {
+        except.increment(numKey, value);
+      }
+    }
+    result.privateData = { ...this.privateData, except: other };
+    result.outcomeData = { ...this.outcomeData };
+    return result;
+  }
+  combineInPlace(other) {
+    for (const [key, value] of Object.entries(other.faces)) {
+      const numKey = Number(key);
+      const current = this.faces[numKey] || 0;
+      this.faces[numKey] = current + value;
+    }
+  }
+  percent() {
+    const total = this.total();
+    const result = {};
+    for (const [face, count] of Object.entries(this.faces)) {
+      result[Number(face)] = count / total;
+    }
+    return result;
+  }
+  average() {
+    const total = this.total();
+    if (total === 0) return 0;
+    let sum = 0;
+    for (const [key, value] of Object.entries(this.faces)) {
+      sum += Number(key) * value;
+    }
+    return sum / total;
+  }
+  /*
+   * Convert dice to PMF using OutcomeType labels directly from damage distribution.
+   * This is much cleaner than the original complex distribution conversion.
+   */
+  toPMF(numEpsilon = COMPUTATIONAL_EPS) {
+    const total = this.total();
+    if (total === 0) return PMF.empty(numEpsilon);
+    this.ensureHitDistribution();
+    const map = /* @__PURE__ */ new Map();
+    const hitDistro = this.getOutcomeDistribution("hit") || {};
+    const critDistro = this.getOutcomeDistribution("crit") || {};
+    const missDistro = this.getOutcomeDistribution("missDamage") || {};
+    const saveDistro = this.getOutcomeDistribution("saveHalf") || {};
+    const pcDistro = this.getOutcomeDistribution("pc") || {};
+    let isSaveHalf = false;
+    for (const halfDamage of Object.keys(saveDistro).map(Number)) {
+      const fullDamage = halfDamage * 2;
+      if (fullDamage > 0 && hitDistro[fullDamage]) {
+        isSaveHalf = true;
+        break;
+      }
+    }
+    const isDCCheck = this.privateData.isDCCheck === true;
+    const clampNonNeg = (x) => x < 0 && x > -1e-15 ? 0 : x;
+    for (const [faceStr, faceCountRaw] of Object.entries(this.getFaceMap())) {
+      const face = Number(faceStr);
+      const faceCount = Number(faceCountRaw);
+      if (faceCount <= 0) continue;
+      let p = faceCount / total;
+      p = clampNonNeg(p);
+      if (!(p > 0)) continue;
+      if (numEpsilon >= 0 && p < numEpsilon) continue;
+      const count = {};
+      const attr = {};
+      if (hitDistro[face]) {
+        const c = clampNonNeg(hitDistro[face] / total);
+        if (c > 0) {
+          if (isSaveHalf || isDCCheck) {
+            count.saveFail = c;
+            attr.saveFail = clampNonNeg(face * hitDistro[face] / total);
+          } else {
+            count.hit = c;
+            attr.hit = clampNonNeg(face * hitDistro[face] / total);
+          }
+        }
+      }
+      if (critDistro[face]) {
+        const c = clampNonNeg(critDistro[face] / total);
+        if (c > 0) {
+          count.crit = c;
+          attr.crit = clampNonNeg(face * critDistro[face] / total);
+        }
+      }
+      if (missDistro[face]) {
+        const c = clampNonNeg(missDistro[face] / total);
+        if (c > 0) {
+          count.missDamage = c;
+          attr.missDamage = clampNonNeg(face * missDistro[face] / total);
+        }
+      }
+      if (saveDistro[face]) {
+        const c = clampNonNeg(saveDistro[face] / total);
+        if (c > 0) {
+          if (isSaveHalf) {
+            count.saveHalf = c;
+            attr.saveHalf = clampNonNeg(face * saveDistro[face] / total);
+          } else {
+            count.saveFail = (count.saveFail ?? 0) + c;
+            attr.saveFail = clampNonNeg(
+              (attr.saveFail ?? 0) + face * saveDistro[face] / total
+            );
+          }
+        }
+      }
+      if (pcDistro[face]) {
+        const c = clampNonNeg(pcDistro[face] / total);
+        if (c > 0) {
+          count.pc = c;
+          attr.pc = clampNonNeg(face * pcDistro[face] / total);
+        }
+      }
+      if (!isSaveHalf && !isDCCheck) {
+        const distroCountRaw = (hitDistro[face] || 0) + (critDistro[face] || 0) + (missDistro[face] || 0) + (saveDistro[face] || 0) + (pcDistro[face] || 0);
+        const unaccountedCount = clampNonNeg(faceCount - distroCountRaw);
+        if (unaccountedCount > 0) {
+          const frac = clampNonNeg(unaccountedCount / total);
+          if (frac > 0) {
+            count.missNone = (count.missNone ?? 0) + frac;
+          }
+        }
+      }
+      const bin = { p, count };
+      if (Object.keys(attr).length > 0) {
+        bin.attr = attr;
+      }
+      map.set(face, bin);
+    }
+    const identifier = this.identifier || "ERROR";
+    if (identifier === "ERROR") {
+      console.error("Dice identifier is undefined", this);
+    }
+    return new PMF(map, numEpsilon, true, identifier).compact(numEpsilon, true);
+  }
+};
+
+// src/parser.ts
+var parseCache = new LRUCache(1e3);
+var cachingEnabled = true;
+function setCachingEnabled(enabled) {
+  cachingEnabled = enabled;
+  if (!enabled) clearParserCache();
+}
+function getCachingEnabled() {
+  return cachingEnabled;
+}
+function clearParserCache() {
+  parseCache.clear();
+}
+function parse(expression, n = 0) {
+  const cleaned = expression.replace(/ /g, "").toLowerCase();
+  if (cachingEnabled) {
+    const cacheKey = `${cleaned}:${n}`;
+    const cached = parseCache.get(cacheKey);
+    if (cached) return cached;
+  }
+  const chars = [...cleaned];
+  let result = void 0;
+  try {
+    result = parseExpression(chars, n);
+  } catch (error) {
+    throw new Error(`Cannot parse dice expression [${expression}]: ${error}`);
+  }
+  try {
+    result.privateData = result.privateData || {};
+    result.identifier = cleaned;
+  } catch {
+  }
+  if (chars.length > 0) {
+    throw new Error(
+      `Unexpected token: '${chars[0]}' from expression: '${expression}'`
+    );
+  }
+  const resultPMF = result.toPMF(-1);
+  if (cachingEnabled) {
+    const cacheKey = `${cleaned}:${n}`;
+    parseCache.set(cacheKey, resultPMF);
+  }
+  return resultPMF;
+}
+function combineDiceWithNormalization(dice, normValue, outcomeType, currentNorm, finalResult) {
+  dice = dice.normalize(currentNorm);
+  finalResult = finalResult.normalize(normValue);
+  finalResult.setOutcomeDistribution(outcomeType, dice.getFaceMap());
+  finalResult = finalResult.combine(dice);
+  return { newNorm: currentNorm * normValue, updatedResult: finalResult };
+}
+function parseExpression(arr, n) {
+  const result = (() => {
+    const res = parseArgument(arr, n);
+    return typeof res === "number" ? Dice.scalar(res) : res;
+  })();
+  let op = parseOperation(arr);
+  let finalResult = result;
+  while (op != null) {
+    const arg = !op.unary ? parseArgument(arr, n) : finalResult;
+    let crit;
+    let critNorm = 1;
+    if (arr[0] === "x" || arr[0] === "c") {
+      const isXcrit = arr[0] === "x";
+      if (isXcrit) assertToken(arr, "x");
+      assertToken(arr, "c");
+      assertToken(arr, "r");
+      assertToken(arr, "i");
+      assertToken(arr, "t");
+      const count = isXcrit ? parseNumber(arr, n) : 1;
+      crit = new Dice();
+      for (let i = 0; i < count; i++) {
+        const max = finalResult.maxFace();
+        crit.setFace(max, finalResult.get(max));
+        finalResult = finalResult.deleteFace(max);
+      }
+      critNorm = crit.total();
+      crit = op.call(crit, parseBinaryArgument(arg, arr, n));
+      critNorm = critNorm ? crit.total() / critNorm : 1;
+    }
+    let save;
+    let saveNorm = 1;
+    if (arr[0] === "s") {
+      assertToken(arr, "s");
+      assertToken(arr, "a");
+      assertToken(arr, "v");
+      assertToken(arr, "e");
+      save = new Dice();
+      const min = finalResult.minFace();
+      save.increment(min > 0 ? min : 1, finalResult.get(min));
+      saveNorm = save.total();
+      finalResult = finalResult.deleteFace(min);
+      save = op.call(save, parseBinaryArgument(arg, arr, n));
+      saveNorm = saveNorm ? save.total() / saveNorm : 1;
+    }
+    let pc;
+    let pcNorm = 1;
+    if (arr.length >= 2 && arr[0] === "p" && arr[1] === "c") {
+      assertToken(arr, "p");
+      assertToken(arr, "c");
+      pc = new Dice();
+      const min = finalResult.minFace();
+      pc.increment(min > 0 ? min : 1, finalResult.get(min));
+      const missBefore = pc.total();
+      finalResult = finalResult.deleteFace(min);
+      pc = op.call(pc, parseBinaryArgument(arg, arr, n)).divideRoundDown(2);
+      const missAfter = pc.total();
+      pcNorm = missBefore ? missAfter / missBefore : 1;
+    }
+    let miss;
+    let missNorm = 1;
+    if (arr[0] === "m") {
+      assertToken(arr, "m");
+      assertToken(arr, "i");
+      assertToken(arr, "s");
+      assertToken(arr, "s");
+      miss = new Dice();
+      const min = finalResult.minFace();
+      miss.increment(min > 0 ? min : 1, finalResult.get(min));
+      missNorm = miss.total();
+      finalResult = finalResult.deleteFace(min);
+      miss = op.call(miss, parseBinaryArgument(arg, arr, n));
+      missNorm = missNorm ? miss.total() / missNorm : 1;
+    }
+    let norm = finalResult.total();
+    finalResult = op.call(finalResult, arg);
+    norm = norm ? finalResult.total() / norm : 1;
+    if (crit) {
+      const result2 = combineDiceWithNormalization(
+        crit,
+        critNorm,
+        "crit",
+        norm,
+        finalResult
+      );
+      norm = result2.newNorm;
+      finalResult = result2.updatedResult;
+    }
+    if (save) {
+      const result2 = combineDiceWithNormalization(
+        save,
+        saveNorm,
+        "saveHalf",
+        norm,
+        finalResult
+      );
+      norm = result2.newNorm;
+      finalResult = result2.updatedResult;
+    }
+    if (miss) {
+      const result2 = combineDiceWithNormalization(
+        miss,
+        missNorm,
+        "missDamage",
+        norm,
+        finalResult
+      );
+      norm = result2.newNorm;
+      finalResult = result2.updatedResult;
+    }
+    if (pc) {
+      const result2 = combineDiceWithNormalization(
+        pc,
+        pcNorm,
+        "pc",
+        norm,
+        finalResult
+      );
+      norm = result2.newNorm;
+      finalResult = result2.updatedResult;
+    }
+    op = parseOperation(arr);
+  }
+  return finalResult;
+}
+function parseArgument(s, n) {
+  let result = parseArgumentInternal(s, n);
+  while (true) {
+    const next = parseArgumentInternal(s, n);
+    if (next === void 0) break;
+    result = multiplyDiceByDice(result, next);
+  }
+  return result;
+}
+function multiplyDiceByDice(d1, d2) {
+  if (typeof d1 === "number") d1 = Dice.scalar(d1);
+  if (typeof d2 === "number") d2 = Dice.scalar(d2);
+  const result = new Dice();
+  const faces = {};
+  let normalizationFactor = 1;
+  for (const key of d1.keys()) {
+    let face;
+    if (typeof key !== "number") {
+      continue;
+    }
+    if (d2.privateData.keep) {
+      const repeat = Array(key).fill(d2);
+      face = opDice(repeat, d2.privateData.keep);
+    } else {
+      face = multiplyDice(key, d2);
+    }
+    normalizationFactor *= face.total();
+    faces[key] = face;
+  }
+  for (const key of Object.keys(faces)) {
+    const k = parseFloat(key);
+    const face = faces[k];
+    const count = d1.get(k);
+    result.combineInPlace(
+      face.normalize(count * normalizationFactor / face.total())
+    );
+  }
+  result.privateData.except = {};
+  return result;
+}
+function multiplyDice(n, d) {
+  if (n === 0) return new Dice(0);
+  if (n === 1) return d;
+  const half = Math.floor(n / 2);
+  let result = multiplyDice(half, d);
+  result = result.add(result);
+  if (n % 2 === 1) {
+    result = result.add(d);
+  }
+  return result;
+}
+function opDice(diceList, keepFn) {
+  return opDiceInternal(diceList, new Dice(), 0, [], 1, keepFn);
+}
+function opDiceInternal(diceList, result, index, values, weight, combineFn) {
+  if (index === diceList.length) {
+    return result.combine(Dice.scalar(combineFn(values)).normalize(weight));
+  }
+  const currentDice = diceList[index];
+  for (const face of currentDice.keys()) {
+    values.push(face);
+    result = opDiceInternal(
+      diceList,
+      result,
+      index + 1,
+      values,
+      weight * currentDice.get(face),
+      combineFn
+    );
+    values.pop();
+  }
+  return result;
+}
+function parseArgumentInternal(s, n) {
+  if (s.length === 0) return;
+  const c = s[0];
+  switch (c) {
+    case "(":
+      s.shift();
+      return assertToken(s, ")", parseExpression(s, n));
+    case "h":
+    case "d":
+      return parseDice(s, n);
+    case "k":
+      assertToken(s, "k");
+      return parseKeep(s, n);
+    case "0":
+    case "1":
+    case "2":
+    case "3":
+    case "4":
+    case "5":
+    case "6":
+    case "7":
+    case "8":
+    case "9":
+    case "n":
+      return parseNumber(s, n);
+  }
+  return;
+}
+function parseBinaryArgument(arg, arr, n) {
+  if (arr.length >= 4 && arr[0] === "h" && peek(arr, "half")) {
+    assertToken(arr, "half");
+    const diceArg = typeof arg === "number" ? Dice.scalar(arg) : arg;
+    return diceArg.divideRoundDown(2);
+  }
+  const parsed = parseArgument(arr, n);
+  return typeof parsed === "number" ? Dice.scalar(parsed) : parsed;
+}
+function assertToken(s, expected, ret) {
+  for (const ch of expected) {
+    const found = s.shift();
+    if (found !== ch) {
+      throw new Error(`Expected character '${ch}', found '${found}'`);
+    }
+  }
+  return ret;
+}
+function parseDice(s, n) {
+  let rerollOne = false;
+  if (peek(s, "hd") && peekIsNumber(s, 2)) {
+    assertToken(s, "h");
+    assertToken(s, "d");
+    rerollOne = true;
+  } else if (peek(s, "d") && peekIsNumber(s, 1)) {
+    assertToken(s, "d");
+  } else {
+    return;
+  }
+  const sides = parseNumber(s, n);
+  let result = new Dice(sides);
+  if (rerollOne) {
+    result = result.deleteFace(1).combine(result);
+  }
+  return result;
+}
+function peek(arr, expected) {
+  if (expected.length > arr.length) return false;
+  for (let i = 0; i < expected.length; i++) {
+    if (arr[i] !== expected.charAt(i)) return false;
+  }
+  return true;
+}
+function peekIsNumber(arr, index) {
+  if (index >= arr.length) return false;
+  return isDigit(arr[index]) || arr[index] === "n";
+}
+function parseNumber(s, n) {
+  let ret = "";
+  while (s.length > 0 && (isDigit(s[0]) || s[0] === "n")) {
+    const ch = s.shift();
+    ret += ch === "n" ? n.toString() : ch;
+  }
+  if (ret.length === 0) {
+    throw new Error(`Expected number, found: '${s[0]}'`);
+  }
+  return parseInt(ret, 10);
+}
+function isDigit(c) {
+  return c >= "0" && c <= "9";
+}
+function parseKeep(s, n) {
+  let keepLowest = false;
+  if (peek(s, "l")) {
+    assertToken(s, "l");
+    keepLowest = true;
+  } else if (peek(s, "h")) {
+    assertToken(s, "h");
+    keepLowest = false;
+  } else {
+    return;
+  }
+  const keepCount = parseNumber(s, n);
+  const result = parseArgumentInternal(s, n);
+  if (result instanceof Dice) {
+    result.privateData.keep = keepN(keepCount, keepLowest);
+    return result;
+  }
+  throw new Error("Expected Dice after keep modifier");
+}
+function keepN(n, low) {
+  return (values) => {
+    const sorted = [...values].sort((a, b) => low ? a - b : b - a);
+    return sorted.slice(0, n).reduce((sum, val) => sum + val, 0);
+  };
+}
+function parseOperation(s) {
+  switch (s[0]) {
+    case ")":
+      return;
+    case "a":
+      assertToken(s, "ac");
+      return Dice.prototype.ac;
+    case "d":
+      assertToken(s, "dc");
+      return Dice.prototype.dc;
+    case "!":
+      assertToken(s, "!");
+      const adv = Dice.prototype.advantage;
+      adv.unary = true;
+      return adv;
+    case ">":
+      assertToken(s, ">");
+      return Dice.prototype.max;
+    case "<":
+      assertToken(s, "<");
+      return Dice.prototype.min;
+    case "+":
+      assertToken(s, "+");
+      return Dice.prototype.addNonZero;
+    case "~":
+      assertToken(s, "~");
+      assertToken(s, "+");
+      return Dice.prototype.add;
+    case "-":
+      assertToken(s, "-");
+      return Dice.prototype.subtract;
+    case "&":
+      assertToken(s, "&");
+      return Dice.prototype.combine;
+    case "r":
+      assertToken(s, "reroll");
+      return Dice.prototype.reroll;
+    case "*":
+      assertToken(s, "*");
+      if (peek(s, "*")) {
+        assertToken(s, "*");
+        return Dice.prototype.multiply;
+      }
+      return Dice.prototype.conditionalApply;
+    case "/":
+      assertToken(s, "/");
+      if (s[0] === "/") {
+        assertToken(s, "/");
+        return Dice.prototype.divideRoundDown;
+      }
+      return Dice.prototype.divideRoundUp;
+    case "=":
+      assertToken(s, "=");
+      return Dice.prototype.eq;
+  }
+  return;
+}
+
+export { COMPUTATIONAL_EPS, Dice, DiceQuery, LRUCache, PMF, TEST_EPS, clearParserCache, getCachingEnabled, getPowerCacheKey, parse, setCachingEnabled };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map