@yipe/dice 0.1.6 → 0.2.1

package/dist/index.d.ts

@@ -1,885 +1,5 @@
-/**
- * Simple LRU cache implementation
- */
-declare class LRUCache<K, V> {
-    private readonly maxSize;
-    private cache;
-    constructor(maxSize?: number);
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    set(key: K, value: V): this;
-    clear(): void;
-    get size(): number;
-    has(key: K): boolean;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-}
-
-/** Mapping from outcome label to probability mass or damage attribution. */
-type OutcomeLabelMap = Partial<Record<string, number>>;
-/** Computational epsilon for pruning negligible probabilities. */
-declare const EPS = 1e-12;
-/** A probability bin for a specific damage value. */
-interface Bin {
-    /** Total probability mass at this damage value. */
-    p: number;
-    /** Per-outcome probability mass contributions at this damage. */
-    count: OutcomeLabelMap;
-    /** Optional per-outcome damage attribution at this damage. */
-    attr?: OutcomeLabelMap;
-}
-/** Simple mapping from damage value to probability. */
-type DamageDistribution = Record<number, number>;
-/** Canonical outcome labels supported by the query helpers. */
-type OutcomeType = "crit" | "hit" | "missNone" | "missDamage" | "saveHalf" | "saveFail" | "pc";
-type Rounding = "none" | "floor" | "round" | "ceil";
-
-/**
- * Query interface for analyzing dice roll probability distributions.
- *
- * Combines multiple attack PMFs and provides statistical analysis methods for:
- * - Basic statistics (mean, variance, min/max, percentiles)
- * - Probability queries (hit chances, success rates, exact counts)
- * - Damage analysis (ranges by outcome type, expected values)
- * - Data export (charts, tables, visualizations)
- *
- */
-declare class DiceQuery {
-    readonly singles: PMF[];
-    readonly combined: PMF;
-    constructor(singles: PMF | PMF[], combined?: PMF, eps?: number);
-    private static readonly DEFAULT_OUTCOMES;
-    /**
-     * Returns the expected damage across all possible outcomes.
-     *
-     * Example: `query.mean()` → 12.5
-     * Use case: "What's my average damage per round?"
-     */
-    mean(): number;
-    /**
-     * 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(): number;
-    /**
-     * 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(): number;
-    /**
-     * Returns the Cumulative Distribution Function.
-     */
-    cdf(x: number): number;
-    /**
-     * 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: number): number;
-    /**
-     * Returns the Complementary Cumulative Distribution Function.
-     */
-    ccdf(x: number): number;
-    /**
-     * 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: number): number;
-    /**
-     * 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: number[]): number[];
-    /**
-     * Returns the minimum possible damage.
-     *
-     * Example: `query.min()` → 0
-     * Use case: "What's the worst-case damage if everything misses?"
-     */
-    min(): number;
-    /**
-     * Returns the maximum possible damage.
-     *
-     * Example: `query.max()` → 56
-     * Use case: "What's the best-case damage if everything crits and rolls max?"
-     */
-    max(): number;
-    private singleProb;
-    probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number;
-    /**
-     * 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: OutcomeType | OutcomeType[]): number;
-    /**
-     * 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)
-     */
-    private computeBinomialProbabilities;
-    /**
-     * 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: OutcomeType | OutcomeType[], k: number): number;
-    /**
-     * 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: OutcomeType | OutcomeType[], k: number): number;
-    /**
-     * 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: OutcomeType | OutcomeType[]): number;
-    /**
-     * 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: OutcomeType | OutcomeType[]): {
-        min: number;
-        max: number;
-        avg: number;
-        count: number;
-    };
-    /**
-     * 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: OutcomeType): {
-        min: number;
-        max: number;
-        avg: number;
-        count: number;
-    };
-    /**
-     * 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: OutcomeType | OutcomeType[]): number;
-    /**
-     * 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(): number;
-    /**
-     * 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(): Array<{
-        x: number;
-        y: number;
-    }>;
-    /**
-     * 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?: OutcomeType[]): Array<{
-        damage: number;
-        total: number;
-    } & Record<string, number>>;
-    /**
-     * 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?: OutcomeType[], epsilon?: number): {
-        labels: number[];
-        datasets: Array<{
-            label: string;
-            data: number[];
-        }>;
-    };
-    /**
-     * 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?: {
-        stackOrder?: string[];
-        filterRules?: (outcome: string, damage: number) => boolean;
-        asPercentages?: boolean;
-    }): {
-        support: number[];
-        outcomes: string[];
-        data: {
-            [outcome: string]: number[];
-        };
-    };
-    /**
-     * 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?: {
-        stackOrder?: string[];
-        filterRules?: (outcome: string, damage: number) => boolean;
-        asPercentages?: boolean;
-    }): {
-        support: number[];
-        outcomes: string[];
-        data: {
-            [outcome: string]: number[];
-        };
-    };
-    /**
-     * 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?: {
-        stackOrder?: string[];
-        filterRules?: (outcome: string, damage: number) => boolean;
-        asPercentages?: boolean;
-    }): {
-        support: number[];
-        outcomes: string[];
-        data: {
-            [outcome: string]: number[];
-        };
-    };
-    /**
-     * 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?: boolean): {
-        support: number[];
-        data: number[];
-    };
-    /**
-     * 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?: boolean): {
-        support: number[];
-        data: number[];
-    };
-    /** Probability of doing strictly more than threshold damage (default >0). */
-    probDamageGreaterThan(threshold?: number): number;
-    /** All outcome keys actually present (typed & ordered if you pass an order). */
-    outcomeKeys(order?: OutcomeType[]): OutcomeType[];
-    /** Total probability per outcome across the PMF. */
-    outcomeTotals(outcomes?: OutcomeType[]): Map<OutcomeType, number>;
-    /** Conditional damage range per outcome (min/avg/max of X | outcome). */
-    outcomeDamageRanges(outcomes?: OutcomeType[]): Map<OutcomeType, {
-        min: number;
-        avg: number;
-        max: number;
-    }>;
-    /**
-     * 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?: readonly OutcomeType[]): Snapshot;
-    /**
-     * 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(): DiceQuery;
-    /**
-     * 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?: number, keepFinalBin?: boolean): DiceQuery;
-    /**
-     * 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: DiceQuery, probability: number): DiceQuery;
-    /**
-     * 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: number): DiceQuery;
-    totalMass(): number;
-    /**
-     * 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: (damageValue: number) => number): DiceQuery;
-    /**
-     * 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: number, rounding?: "floor" | "round" | "ceil"): DiceQuery;
-    /**
-     * 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: DiceQuery): DiceQuery;
-    /**
-     * 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: string | string[], subsetOutcome: string | string[], eps?: number): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number];
-}
-type OutcomeSnapshot = {
-    atLeastOneProbability: number;
-    allProbability: number;
-    damageRange: {
-        min: number;
-        avg: number;
-        max: number;
-    };
-};
-type Snapshot = {
-    averageDPR: number;
-    damageChance: number;
-    percentiles: {
-        p25: number;
-        p50: number;
-        p75: number;
-    };
-    outcomes: Map<OutcomeType, OutcomeSnapshot>;
-};
-
-declare const pmfCache: LRUCache<string, PMF>;
-/**
- * Probability Mass Function for discrete damage distributions.
- */
-declare class PMF {
-    readonly map: Map<number, Bin>;
-    readonly epsilon: number;
-    readonly normalized: boolean;
-    readonly identifier: string;
-    private _preservedProvenance;
-    private static __anonIdCounter;
-    private _support?;
-    private _min?;
-    private _max?;
-    private _totalMass?;
-    private _mean?;
-    private _variance?;
-    private _stdev?;
-    constructor(map?: Map<number, Bin>, epsilon?: number, normalized?: boolean, identifier?: string, _preservedProvenance?: boolean);
-    static empty(epsilon?: number, identifier?: string): PMF;
-    static zero(epsilon?: number): PMF;
-    static delta(value: number, epsilon?: number): PMF;
-    static emptyMass(): PMF;
-    [Symbol.iterator](): IterableIterator<[number, Bin]>;
-    static clearCache(): void;
-    /**
-     * 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: PMF, failurePMF: PMF, successProbability: number): PMF;
-    /**
-     * 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: PMF, probability: number): PMF;
-    /**
-     * 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: number, zero: PMF): PMF;
-    /**
-     * 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: Array<{
-        pmf: PMF;
-        weight: number;
-    } | [PMF, number]>, eps?: number): PMF;
-    /**
-     * General-purpose N-way mixture.
-     * weights: Array of [weight, PMF].
-     *
-     * Example: PMF.mixN([
-     *   [pMiss, zero],
-     *   [pHit, hitPMF],
-     *   [pCrit, critPMF],
-     * ]);
-     */
-    static mixN(weights: [number, PMF][], eps?: number): PMF;
-    private setPreservedProvenance;
-    preservedProvenance(): boolean;
-    private getPowerCacheKey;
-    /**
-     * 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: number, eps?: number): PMF;
-    replicate(n: number): PMF[];
-    mass(): number;
-    outcomeMass(outcome: string): number;
-    faceTotal(): number;
-    normalize(): PMF;
-    /**
-     * 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?: number, keepFinalBin?: boolean): PMF;
-    support(): number[];
-    min(): number;
-    max(): number;
-    /**
-     * Returns the expected (mean) damage value.
-     * Cached for performance since this requires iterating through all bins.
-     */
-    mean(): number;
-    /**
-     * Returns the variance of the damage distribution.
-     * Cached for performance since this requires mean calculation plus iteration.
-     */
-    variance(): number;
-    /**
-     * Returns the standard deviation of the damage distribution.
-     */
-    stdev(): number;
-    private static mergeInto;
-    add(other: PMF): PMF;
-    /**
-     * 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: PMF, probability: number): PMF;
-    scaleMass(factor: number): PMF;
-    mapDamage(damageTransformFunction: (damageValue: number) => number): PMF;
-    scaleDamage(factor: number, rounding?: "floor" | "round" | "ceil"): PMF;
-    private getPMFCombineCacheKey;
-    convolve(other: PMF, eps?: number, raw?: boolean): PMF;
-    combineRaw(other: PMF, eps?: number): PMF;
-    private static reduceConvolveLeft;
-    /**
-     * 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: PMF[], eps?: number): PMF;
-    toJSON(): string;
-    static fromJSON(jsonData: {
-        bins: Array<[number, Bin]>;
-        normalized?: boolean;
-        identifier?: string;
-    }): PMF;
-    /**
-     * 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.
-     */
-    prune(epsRel: number, minBins?: number): PMF;
-    /** NEW - REVIEW IF THESE ARE USEFUL OR DUPLCIATIVE?  */
-    /** Probability mass at exactly x. */
-    pAt(x: number): number;
-    /** Dense integer support from min..max (inclusive).
-     * Useful for showing empty bars in charts.
-     */
-    denseSupport(): number[];
-    /** CDF at x: P(X ≤ x). */
-    cdfAt(x: number): number;
-    /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
-    quantile(p: number): number;
-    /** Get outcome probability at specific damage value. */
-    outcomeAt(damage: number, outcome: string): number;
-    /** Get all outcome types present in this PMF. */
-    outcomes(): string[];
-    /** Get total probability of an outcome across all damage values. */
-    outcomeProbability(outcome: string): number;
-    /** Get damage attribution for an outcome at specific damage value. */
-    outcomeAttributionAt(damage: number, outcome: string): number;
-    /** Get all outcome data at specific damage value. */
-    binAt(damage: number): {
-        p: number;
-        count: Record<string, number>;
-        attr?: Record<string, number>;
-    } | null;
-    /** Check if outcome exists in this PMF. */
-    hasOutcome(outcome: string): boolean;
-    tailProbGE(t: number): number;
-    tailProbGT(t: number): number;
-    /**
-     * 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: string): PMF;
-    /**
-     * 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: number, pSpecial: number, n: number): {
-        pSpecificSuccess: number;
-        pGeneralSuccess: number;
-        pNone: number;
-        pAny: number;
-    };
-    mapValues(f: (v: number) => number, eps?: number, opts?: {
-        rounding?: Rounding;
-        preserveCounts?: boolean;
-    }): PMF;
-    static fromMap(m: Map<number, number>, eps?: number, { requireIntegerValues }?: {
-        requireIntegerValues?: boolean;
-    }): PMF;
-    query(): DiceQuery;
-}
+import { P as PMF } from './pmf-DIegvlyA.js';
+export { B as Bin, D as DamageDistribution, b as DiceQuery, E as EPS, L as LRUCache, O as OutcomeLabelMap, c as OutcomeSnapshot, a as OutcomeType, R as Rounding, S as Snapshot, p as pmfCache } from './pmf-DIegvlyA.js';
 
 /** Enable or disable the internal parse cache. */
 declare function setCachingEnabled(enabled: boolean): void;
@@ -930,4 +50,4 @@ declare class Mixture<L extends string = string> {
     static mix<L extends string = string>(items: Array<[label: L, pmf: PMF, weight: number]>, eps?: number): PMF;
 }
 
-export { type Bin, type DamageDistribution, DiceQuery, EPS, LRUCache, Mixture, type OutcomeLabelMap, type OutcomeSnapshot, type OutcomeType, PMF, type Rounding, type Snapshot, clearParserCache, getCachingEnabled, parse, pmfCache, setCachingEnabled };
+export { Mixture, PMF, clearParserCache, getCachingEnabled, parse, setCachingEnabled };