@yipe/dice 0.2.1 → 0.2.2

package/dist/builder/index.cjs

@@ -1387,40 +1387,68 @@ var _PMF = class _PMF {
    *  - 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.
+   *  - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()
+   *
+   * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
+   * @param eps Optional tolerance for floating point rounding.
    */
   static exclusive(options, eps = EPS) {
     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) {
+    for (const { weight } of items) {
+      if (!Number.isFinite(weight) || weight < -eps) {
+        throw new Error(`PMF.exclusive: invalid weight ${weight}.`);
+      }
+    }
+    let totalWeight = items.reduce((s, { weight }) => s + weight, 0);
+    if (Math.abs(totalWeight) <= eps) totalWeight = 0;
+    if (Math.abs(1 - totalWeight) <= eps) totalWeight = 1;
+    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;
+    let out = _PMF.empty(eps);
+    for (const { pmf, weight } of items) {
+      if (weight > eps) out = out.addScaled(pmf, weight);
+    }
+    const leftover = Math.max(0, 1 - totalWeight);
     if (leftover > eps) {
       out = out.addScaled(_PMF.zero(), leftover);
     }
     return out;
   }
+  /**
+   * PMF.mix()
+   *
+   * Builds a PMF as a linear combination of input PMFs with the given weights.
+   * Unlike `exclusive`, this does NOT:
+   *  - enforce that weights sum to 1
+   *  - add leftover probability to δ0 (PMF.zero())
+   *
+   * Use when outcomes are not mutually exclusive, or for interpolation/blending.
+   *
+   * @param options Array of `{ pmf, weight }` or `[PMF, number]`.
+   * @param eps Optional tolerance for skipping tiny weights.
+   */
+  static mix(options, eps = EPS) {
+    const items = options.map(
+      (o) => Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o
+    );
+    for (const { weight } of items) {
+      if (!Number.isFinite(weight)) {
+        throw new Error(`PMF.mix: invalid weight ${weight}.`);
+      }
+    }
+    let out = _PMF.empty(eps);
+    for (const { pmf, weight } of items) {
+      if (Math.abs(weight) <= eps) continue;
+      out = out.addScaled(pmf, weight);
+    }
+    return out;
+  }
   /**
    * General-purpose N-way mixture.
    * weights: Array of [weight, PMF].
@@ -2389,386 +2417,113 @@ function d20PMF(rerollOne) {
   return result;
 }
 
-// src/builder/ast.ts
-var defaultEps = 0;
-var singleDiePMFCache = new LRUCache(1e3);
-function astFromRollConfigs(configs) {
-  if (!configs || configs.length === 0) return void 0;
-  const children = [];
-  let constantSum = 0;
-  for (const cfg of configs) {
-    const sign = cfg.isSubtraction || cfg.count < 0 ? -1 : 1;
-    const count = Math.abs(cfg.count || 0);
-    constantSum += cfg.modifier || 0;
-    if ((cfg.sides || 0) <= 0) continue;
-    const die = {
-      type: "die",
-      sides: cfg.sides,
-      reroll: cfg.reroll > 0 ? cfg.reroll : void 0,
-      minimum: cfg.minimum > 0 ? cfg.minimum : void 0,
-      explode: cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0 ? cfg.explode : void 0
-    };
-    let node = die;
-    let appliedRollType = false;
-    if (cfg.rollType && cfg.rollType !== "flat") {
-      if (cfg.sides === 20) {
-        node = {
-          type: "d20Roll",
-          rollType: cfg.rollType,
-          child: node
-        };
-      } else {
-        const n = cfg.rollType === "elven accuracy" ? 3 : 2;
-        const mode = cfg.rollType === "disadvantage" ? "lowest" : "highest";
-        const base = { type: "sum", count: n, child: node };
-        node = { type: "keep", mode, count: 1, child: base };
-      }
-      appliedRollType = true;
-    }
-    if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
-      const base = { type: "sum", count: cfg.keep.total, child: node };
-      node = {
-        type: "keep",
-        mode: cfg.keep.mode,
-        count: cfg.keep.count,
-        child: base
-      };
+// src/builder/roll.ts
+var defaultConfig = {
+  count: 1,
+  sides: 0,
+  modifier: 0,
+  reroll: 0,
+  explode: 0,
+  minimum: 0,
+  bestOf: 0,
+  keep: void 0,
+  rollType: "flat"
+};
+var RollBuilder = class _RollBuilder {
+  constructor(countOrConfigs = 1) {
+    __publicField(this, "subRollConfigs");
+    // --- Dice Shortcut Methods ---
+    __publicField(this, "d4", () => this.d(4));
+    __publicField(this, "d6", () => this.d(6));
+    __publicField(this, "d8", () => this.d(8));
+    __publicField(this, "d10", () => this.d(10));
+    __publicField(this, "d12", () => this.d(12));
+    __publicField(this, "d20", () => this.d(20));
+    __publicField(this, "d100", () => this.d(100));
+    if (typeof countOrConfigs === "number") {
+      const count = countOrConfigs;
+      if (isNaN(count)) throw new Error("Invalid NaN value for count");
+      this.subRollConfigs = [
+        { ...defaultConfig, count, isSubtraction: count < 0 }
+      ];
     } else {
-      const c = appliedRollType ? 1 : Math.max(1, count || 1);
-      node = { type: "sum", count: c, child: node };
+      this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));
     }
-    children.push({ node, sign });
   }
-  if (children.length === 0) {
-    return { type: "constant", value: constantSum };
+  get lastConfig() {
+    return this.subRollConfigs[this.subRollConfigs.length - 1];
   }
-  const add = { type: "add", children };
-  if (constantSum !== 0)
-    add.children.push({
-      node: { type: "constant", value: constantSum },
-      sign: 1
-    });
-  return add;
-}
-function resolve(node, eps = defaultEps) {
-  const signature = getASTSignature(node);
-  const cacheKey = `${signature}_${eps}`;
-  const cached = builderPMFCache.get(cacheKey);
-  if (cached) return cached;
-  const result = (() => {
-    switch (node.type) {
-      case "constant":
-        return PMF.delta(node.value, eps);
-      case "die": {
-        return resolveSingleDie(node, eps);
-      }
-      case "sum": {
-        const base = resolve(node.child, eps);
-        const n = Math.max(0, Math.floor(node.count));
-        if (n === 0) return PMF.delta(0, eps);
-        if (n === 1) return base;
-        return base.power(n, eps);
+  getSubRollConfigs() {
+    return this.subRollConfigs.map((c) => ({ ...c }));
+  }
+  // for testing
+  static fromConfig(config) {
+    return new _RollBuilder([{ ...defaultConfig, ...config }]);
+  }
+  static fromConfigs(configs) {
+    return new _RollBuilder(
+      configs.map((config) => ({ ...defaultConfig, ...config }))
+    );
+  }
+  static fromArgs(...args) {
+    if (args.length === 1) {
+      const arg = args[0];
+      if (typeof arg === "number") {
+        if (isNaN(arg)) throw new Error("Invalid NaN value for argument");
+        return new _RollBuilder(0).plus(arg);
       }
-      case "add": {
-        let shift = 0;
-        const parts = [];
-        for (const c of node.children) {
-          if (c.node.type === "constant") {
-            shift += c.sign * c.node.value;
-          } else {
-            const p = resolve(c.node, eps);
-            parts.push(c.sign === 1 ? p : p.mapDamage((v) => -v));
-          }
-        }
-        if (parts.length === 0) return PMF.delta(shift, eps);
-        let res = parts.length === 1 ? parts[0] : PMF.convolveMany(parts, eps);
-        if (shift !== 0) res = res.mapDamage((v) => v + shift);
-        return res;
+      if (arg instanceof _RollBuilder) {
+        return arg;
       }
-      case "keep": {
-        const total = getTotalCount(node);
-        const die = findDie(node.child.child);
-        const perDie = die ? resolveSingleDie(die, eps) : PMF.delta(0, eps);
-        const keepCount = Math.max(0, Math.min(node.count, total));
-        if (keepCount === 0 || total === 0) return PMF.delta(0, eps);
-        return keepSumPMF(
-          perDie,
-          total,
-          keepCount,
-          node.mode === "highest",
-          eps
-        );
+    }
+    if (args.length === 2 || args.length === 3) {
+      const [count, sidesOrDie, modifier] = args;
+      if (typeof count !== "number") {
+        throw new Error("First argument must be a number for multi-arg call");
       }
-      case "d20Roll": {
-        const childDie = findDie(node.child);
-        const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
-        return d20RollPMF(node.rollType, rerollOne);
+      if (isNaN(count)) throw new Error("Invalid NaN value for count argument");
+      if (sidesOrDie instanceof _RollBuilder) {
+        const subRollConfigs = sidesOrDie.getSubRollConfigs();
+        if (subRollConfigs.length === 0) {
+          const result = new _RollBuilder(0);
+          return modifier !== void 0 ? result.plus(modifier) : result;
+        }
+        const absCount = Math.abs(count);
+        const newConfigs = subRollConfigs.map((config) => ({
+          ...config,
+          count: config.count * absCount,
+          modifier: config.modifier * absCount
+        }));
+        let resultBuilder = new _RollBuilder(newConfigs);
+        if (count < 0) {
+          const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
+          resultBuilder = new _RollBuilder(negatedConfigs);
+        }
+        return modifier !== void 0 ? resultBuilder.plus(modifier) : resultBuilder;
+      } else if (typeof sidesOrDie === "number" || sidesOrDie === void 0) {
+        if (typeof sidesOrDie === "number" && isNaN(sidesOrDie))
+          throw new Error("Invalid NaN value for sides argument");
+        let builder = new _RollBuilder(count);
+        if (sidesOrDie && sidesOrDie > 0) {
+          builder = builder.d(sidesOrDie);
+        }
+        return modifier !== void 0 ? builder.plus(modifier) : builder;
       }
     }
-  })();
-  builderPMFCache.set(cacheKey, result);
-  return result;
-}
-function pmfFromRollBuilder(rb, eps = defaultEps) {
-  const configs = rb.getSubRollConfigs?.() ?? [];
-  const ast = astFromRollConfigs(configs) || { type: "constant", value: 0 };
-  return resolve(ast, eps);
-}
-function resolveSingleDie(die, eps = defaultEps) {
-  const signature = getASTSignature(die);
-  const cacheKey = `${signature}_${eps}`;
-  const cached = singleDiePMFCache.get(cacheKey);
-  if (cached) return cached;
-  const s = Math.max(0, Math.floor(die.sides));
-  if (s <= 0) return PMF.delta(0, eps);
-  let probs = /* @__PURE__ */ new Map();
-  for (let v = 1; v <= s; v++) probs.set(v, 1 / s);
-  const r = Math.max(0, Math.floor(die.reroll || 0));
-  if (r > 0) {
-    const k = Math.min(r, s);
-    const rerollMass = k / s;
-    const uniformReroll = rerollMass / s;
-    const next = /* @__PURE__ */ new Map();
-    for (let v = 1; v <= s; v++) {
-      const keep = v <= k ? 0 : 1 / s;
-      next.set(v, keep + uniformReroll);
+    throw new Error(`Invalid arguments passed: ${args.join(", ")}`);
+  }
+  // --- Core Dice Methods ---
+  d(sides) {
+    if (sides !== void 0 && isNaN(sides))
+      throw new Error("Invalid NaN value for sides");
+    if (sides === void 0) return this;
+    if (this.lastConfig.sides && this.lastConfig.sides > 0) {
+      throw new Error("Cannot add a die after adding a die");
     }
-    probs = next;
-  }
-  let pmf = PMF.fromMap(new Map(probs), eps);
-  const minV = Math.max(0, Math.floor(die.minimum || 0));
-  if (minV > 0) pmf = pmf.mapDamage((v) => Math.max(v, minV));
-  const explode = die.explode;
-  if (explode && Number.isFinite(explode) && explode > 0) {
-    const times = Math.floor(explode);
-    const maxFace = s;
-    const nonMax = /* @__PURE__ */ new Map();
-    const pMax = pmf.pAt(maxFace);
-    for (const v of pmf.support()) {
-      if (v !== maxFace) nonMax.set(v, pmf.pAt(v));
-    }
-    let nonMaxPMF = PMF.fromMap(nonMax, eps);
-    if (Math.abs(nonMaxPMF.mass() - (1 - pMax)) > eps) {
-      nonMaxPMF = nonMaxPMF.scaleMass(1 - pMax);
-    }
-    let tail = PMF.delta(0, eps);
-    const addOnce = pmf;
-    for (let t = 1; t <= times; t++) {
-      tail = tail.convolve(addOnce, eps);
-    }
-    const exploded = PMF.branch(
-      tail.mapDamage((v) => v + maxFace),
-      nonMaxPMF,
-      pMax
-    );
-    pmf = exploded;
-  }
-  singleDiePMFCache.set(cacheKey, pmf);
-  return pmf;
-}
-function findDie(node) {
-  switch (node.type) {
-    case "die":
-      return node;
-    case "constant":
-      return void 0;
-    case "sum":
-    case "d20Roll":
-      return findDie(node.child);
-    case "keep":
-      return findDie(node.child.child);
-    case "add":
-      for (const c of node.children) {
-        const d2 = findDie(c.node);
-        if (d2) return d2;
-      }
-      return void 0;
-  }
-}
-function getTotalCount(node) {
-  let cur = node.child;
-  while (cur.type === "keep") cur = cur.child;
-  return cur.type === "sum" ? Math.max(0, Math.floor(cur.count)) : 0;
-}
-function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
-  if (keep >= total) return single.power(total, eps);
-  if (keep <= 0) return PMF.delta(0, eps);
-  const sortedSupport = [...single.support()].sort((a, b) => a - b);
-  const pmfSig = sortedSupport.map((val) => `${val}:${single.pAt(val).toPrecision(6)}`).join(",");
-  const cacheKey = `keep|${pmfSig}|t:${total}|k:${keep}|h:${highest ? 1 : 0}|e:${eps}`;
-  const cached = builderPMFCache.get(cacheKey);
-  if (cached) return cached;
-  const support = single.support();
-  const probs = support.map((v) => ({ v, p: single.pAt(v) }));
-  const out = /* @__PURE__ */ new Map();
-  function dfs(i, accValues, weight) {
-    if (i === total) {
-      const sorted = [...accValues].sort((a, b) => highest ? b - a : a - b);
-      let sum = 0;
-      for (let j = 0; j < keep; j++) sum += sorted[j];
-      out.set(sum, (out.get(sum) || 0) + weight);
-      return;
-    }
-    for (const { v, p } of probs) {
-      if (p <= 0) continue;
-      dfs(i + 1, [...accValues, v], weight * p);
-    }
-  }
-  dfs(0, [], 1);
-  const result = PMF.fromMap(out, eps);
-  builderPMFCache.set(cacheKey, result);
-  return result;
-}
-function getASTSignature(node) {
-  switch (node.type) {
-    case "constant":
-      return `c:${node.value}`;
-    case "die": {
-      const parts = [];
-      parts.push(`s:${node.sides}`);
-      if (node.reroll) parts.push(`r:${node.reroll}`);
-      if (node.minimum) parts.push(`m:${node.minimum}`);
-      if (node.explode) parts.push(`e:${node.explode}`);
-      return `d{${parts.join(",")}}`;
-    }
-    case "sum":
-      return `sum{c:${node.count},ch:${getASTSignature(node.child)}}`;
-    case "d20Roll":
-      return `d20{t:${node.rollType},ch:${getASTSignature(node.child)}}`;
-    case "keep":
-      return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(
-        node.child
-      )}}`;
-    case "add": {
-      let constantValue = 0;
-      const otherChildrenSigs = [];
-      for (const c of node.children) {
-        if (c.node.type === "constant") {
-          constantValue += c.sign * c.node.value;
-        } else {
-          otherChildrenSigs.push(
-            `${c.sign === -1 ? "-" : "+"}${getASTSignature(c.node)}`
-          );
-        }
-      }
-      if (constantValue !== 0) {
-        otherChildrenSigs.push(
-          constantValue > 0 ? `+c:${constantValue}` : `-c:${-constantValue}`
-        );
-      }
-      otherChildrenSigs.sort();
-      return `add[${otherChildrenSigs.join("")}]`;
-    }
-  }
-}
-
-// src/builder/roll.ts
-var defaultConfig = {
-  count: 1,
-  sides: 0,
-  modifier: 0,
-  reroll: 0,
-  explode: 0,
-  minimum: 0,
-  bestOf: 0,
-  keep: void 0,
-  rollType: "flat"
-};
-var RollBuilder = class _RollBuilder {
-  constructor(countOrConfigs = 1) {
-    __publicField(this, "subRollConfigs");
-    // --- Dice Shortcut Methods ---
-    __publicField(this, "d4", () => this.d(4));
-    __publicField(this, "d6", () => this.d(6));
-    __publicField(this, "d8", () => this.d(8));
-    __publicField(this, "d10", () => this.d(10));
-    __publicField(this, "d12", () => this.d(12));
-    __publicField(this, "d20", () => this.d(20));
-    __publicField(this, "d100", () => this.d(100));
-    if (typeof countOrConfigs === "number") {
-      const count = countOrConfigs;
-      if (isNaN(count)) throw new Error("Invalid NaN value for count");
-      this.subRollConfigs = [
-        { ...defaultConfig, count, isSubtraction: count < 0 }
-      ];
-    } else {
-      this.subRollConfigs = countOrConfigs.map((c) => ({ ...c }));
-    }
-  }
-  get lastConfig() {
-    return this.subRollConfigs[this.subRollConfigs.length - 1];
-  }
-  getSubRollConfigs() {
-    return this.subRollConfigs.map((c) => ({ ...c }));
-  }
-  // for testing
-  static fromConfig(config) {
-    return new _RollBuilder([{ ...defaultConfig, ...config }]);
-  }
-  static fromConfigs(configs) {
-    return new _RollBuilder(
-      configs.map((config) => ({ ...defaultConfig, ...config }))
-    );
-  }
-  static fromArgs(...args) {
-    if (args.length === 1) {
-      const arg = args[0];
-      if (typeof arg === "number") {
-        if (isNaN(arg)) throw new Error("Invalid NaN value for argument");
-        return new _RollBuilder(0).plus(arg);
-      }
-      if (arg instanceof _RollBuilder) {
-        return arg;
-      }
-    }
-    if (args.length === 2 || args.length === 3) {
-      const [count, sidesOrDie, modifier] = args;
-      if (typeof count !== "number") {
-        throw new Error("First argument must be a number for multi-arg call");
-      }
-      if (isNaN(count)) throw new Error("Invalid NaN value for count argument");
-      if (sidesOrDie instanceof _RollBuilder) {
-        const subRollConfigs = sidesOrDie.getSubRollConfigs();
-        if (subRollConfigs.length === 0) {
-          const result = new _RollBuilder(0);
-          return modifier !== void 0 ? result.plus(modifier) : result;
-        }
-        const absCount = Math.abs(count);
-        const newConfigs = subRollConfigs.map((config) => ({
-          ...config,
-          count: config.count * absCount,
-          modifier: config.modifier * absCount
-        }));
-        let resultBuilder = new _RollBuilder(newConfigs);
-        if (count < 0) {
-          const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
-          resultBuilder = new _RollBuilder(negatedConfigs);
-        }
-        return modifier !== void 0 ? resultBuilder.plus(modifier) : resultBuilder;
-      } else if (typeof sidesOrDie === "number" || sidesOrDie === void 0) {
-        if (typeof sidesOrDie === "number" && isNaN(sidesOrDie))
-          throw new Error("Invalid NaN value for sides argument");
-        let builder = new _RollBuilder(count);
-        if (sidesOrDie && sidesOrDie > 0) {
-          builder = builder.d(sidesOrDie);
-        }
-        return modifier !== void 0 ? builder.plus(modifier) : builder;
-      }
-    }
-    throw new Error(`Invalid arguments passed: ${args.join(", ")}`);
-  }
-  // --- Core Dice Methods ---
-  d(sides) {
-    if (sides !== void 0 && isNaN(sides))
-      throw new Error("Invalid NaN value for sides");
-    if (sides === void 0) return this;
-    if (this.lastConfig.sides && this.lastConfig.sides > 0) {
-      throw new Error("Cannot add a die after adding a die");
-    }
-    if (sides === 0) return this;
-    const newConfigs = this.getSubRollConfigs();
-    newConfigs[newConfigs.length - 1].sides = sides;
-    return new this.constructor(newConfigs);
+    if (sides === 0) return this;
+    const newConfigs = this.getSubRollConfigs();
+    newConfigs[newConfigs.length - 1].sides = sides;
+    return new this.constructor(newConfigs);
   }
   plus(modOrRoll, die) {
     if (typeof modOrRoll === "number" && isNaN(modOrRoll))
@@ -2903,19 +2658,11 @@ var RollBuilder = class _RollBuilder {
   copy() {
     return new this.constructor(this.getSubRollConfigs());
   }
-  ac(targetAC) {
-    if (isNaN(targetAC)) throw new Error("Invalid NaN value for targetAC");
-    return new ACBuilder(this, targetAC);
-  }
   withElvenAccuracy() {
     const newConfigs = this.getSubRollConfigs();
     newConfigs[newConfigs.length - 1].rollType = "elven accuracy";
     return new this.constructor(newConfigs);
   }
-  dc(saveDC) {
-    if (isNaN(saveDC)) throw new Error("Invalid NaN value for saveDC");
-    return new DCBuilder(this).dc(saveDC);
-  }
   toExpression() {
     const diceConfigs = this.subRollConfigs.filter(
       (config) => config.sides && config.sides > 0
@@ -2943,118 +2690,444 @@ var RollBuilder = class _RollBuilder {
         result += operator + expression;
       }
     }
-    if (totalModifier > 0) result += ` + ${totalModifier}`;
-    else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;
-    return result.replace(/\+ -/g, "-");
-  }
-  toPMF(eps = 0) {
-    return pmfFromRollBuilder(this, eps);
-  }
-  toQuery(eps = 0) {
-    return this.toPMF(eps).query();
-  }
-  toAST() {
-    const configs = this.getSubRollConfigs();
-    return astFromRollConfigs(configs) || { type: "constant", value: 0 };
+    if (totalModifier > 0) result += ` + ${totalModifier}`;
+    else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;
+    return result.replace(/\+ -/g, "-");
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  get pmf() {
+    return this.toPMF();
+  }
+  toQuery(eps = 0) {
+    return this.toPMF(eps).query();
+  }
+  toAST() {
+    const configs = this.getSubRollConfigs();
+    return astFromRollConfigs(configs) || { type: "constant", value: 0 };
+  }
+  configToSingleExpressionWithoutModifier(config, isRootDie) {
+    if (!config.sides || config.sides <= 0) return "";
+    let baseDie = `d${config.sides}`;
+    if (config.reroll > 0) {
+      if (config.minimum > 0 && config.explode > 0) ; else if (config.minimum > 0) {
+        for (let i = config.reroll; i >= 1; i--) baseDie += ` reroll ${i}`;
+      } else {
+        for (let i = 1; i <= config.reroll; i++) baseDie += ` reroll ${i}`;
+      }
+    }
+    if (config.minimum > 0) {
+      baseDie = `${config.minimum}>${baseDie}`;
+      if (config.reroll > 0 && config.explode > 0) {
+        for (let i = 1; i <= config.reroll; i++) {
+          baseDie += ` reroll ${i}`;
+        }
+      }
+    }
+    if (baseDie === "d20 reroll 1" && config.minimum <= 1) baseDie = "hd20";
+    let mainExpression = "";
+    switch (config.rollType) {
+      case "advantage":
+        mainExpression = `${baseDie} > ${baseDie}`;
+        break;
+      case "disadvantage":
+        mainExpression = `${baseDie} < ${baseDie}`;
+        break;
+      case "elven accuracy":
+        mainExpression = `${baseDie} > ${baseDie} > ${baseDie}`;
+        break;
+      case "flat":
+        if (config.keep) {
+          const mode = config.keep.mode === "highest" ? "kh" : "kl";
+          mainExpression = `${config.keep.total}${mode}${config.keep.count}(${baseDie})`;
+        } else {
+          const isComplex = baseDie.length > `d${config.sides}`.length;
+          const isHalflingShorthand = baseDie === "hd20";
+          const isD20Shorthand = baseDie === "d20" && isRootDie;
+          const hasMinimum = baseDie.startsWith("(") && baseDie.includes(">");
+          const hasReroll = baseDie.includes("reroll");
+          const effectiveCount = config.isSubtraction ? Math.abs(config.count) : config.count < 0 ? 1 : Math.abs(config.count);
+          if (effectiveCount > 1) {
+            const shouldAddParentheses = isComplex && (// Complex single roll: explode + reroll
+            !hasMinimum && !hasReroll || // Simple complex case
+            hasReroll && !hasMinimum);
+            mainExpression = shouldAddParentheses ? `${effectiveCount}(${baseDie})` : `${effectiveCount}${baseDie}`;
+          } else if (effectiveCount === 1) {
+            if (config.isSubtraction) {
+              mainExpression = `1${baseDie}`;
+            } else if (isComplex || isHalflingShorthand || isD20Shorthand || config.count < 0) {
+              mainExpression = baseDie;
+            } else {
+              mainExpression = `1${baseDie}`;
+            }
+          } else {
+            mainExpression = baseDie;
+          }
+        }
+        if (config.bestOf && config.count && config.bestOf < config.count) {
+          mainExpression += `kh${config.bestOf}`;
+        }
+        break;
+    }
+    return mainExpression;
+  }
+  getRootDieConfig() {
+    const configs = this.subRollConfigs;
+    return configs.find((config) => config.sides > 0) || configs[0];
+  }
+  getAllDieConfigs() {
+    return this.getSubRollConfigs();
+  }
+  getBonusDiceConfigs() {
+    const allConfigs = this.subRollConfigs;
+    const rootConfig = allConfigs.find((config) => config.sides > 0) || allConfigs[0];
+    if (!rootConfig) return [];
+    return allConfigs.filter((config) => config.sides > 0).filter((config) => config !== rootConfig);
+  }
+  getBonusDicePMFs(check, eps = 0) {
+    return check.getBonusDiceConfigs().map(
+      (config) => pmfFromRollBuilder(_RollBuilder.fromConfigs([config]), eps)
+    );
+  }
+  get modifier() {
+    return this.subRollConfigs.reduce(
+      (sum, config) => sum + config.modifier,
+      0
+    );
+  }
+  get rollType() {
+    const rootConfig = this.getRootDieConfig();
+    return rootConfig?.rollType || "flat";
+  }
+  get baseReroll() {
+    const rootConfig = this.getRootDieConfig();
+    return rootConfig?.reroll || 0;
+  }
+};
+
+// src/builder/factory.ts
+var rollFn = (count, sidesOrDie, modifier) => {
+  if (sidesOrDie instanceof RollBuilder) {
+    const subRollConfigs = sidesOrDie.getSubRollConfigs();
+    if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);
+    const absCount = Math.abs(count);
+    const newConfigs = subRollConfigs.map((config) => ({
+      ...config,
+      count: config.count * absCount,
+      modifier: config.modifier * absCount
+    }));
+    let resultBuilder = new RollBuilder(newConfigs);
+    if (count < 0) {
+      const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
+      resultBuilder = new RollBuilder(negatedConfigs);
+    }
+    return resultBuilder.plus(modifier);
+  } else {
+    let builder = new RollBuilder(count);
+    if (sidesOrDie && sidesOrDie > 0) {
+      builder = builder.d(sidesOrDie);
+    }
+    return builder.plus(modifier);
+  }
+};
+rollFn.d = (sides) => new RollBuilder(1).d(sides);
+rollFn.hd20 = () => new RollBuilder(1).d20().reroll(1);
+rollFn.d4 = () => new RollBuilder(1).d4();
+rollFn.d6 = () => new RollBuilder(1).d6();
+rollFn.d8 = () => new RollBuilder(1).d8();
+rollFn.d10 = () => new RollBuilder(1).d10();
+rollFn.d12 = () => new RollBuilder(1).d12();
+rollFn.d20 = () => new RollBuilder(1).d20();
+rollFn.d100 = () => new RollBuilder(1).d100();
+rollFn.flat = (n) => new RollBuilder(0).plus(n);
+function d(sides) {
+  return new RollBuilder(1).d(sides);
+}
+var d4 = new RollBuilder(1).d4();
+var d6 = new RollBuilder(1).d6();
+var d8 = new RollBuilder(1).d8();
+var d10 = new RollBuilder(1).d10();
+var d12 = new RollBuilder(1).d12();
+var d20 = new RollBuilder(1).d20();
+var hd20 = new RollBuilder(1).d20().reroll(1);
+var d100 = new RollBuilder(1).d100();
+var flat = (n) => new RollBuilder(0).plus(n);
+var roll = rollFn;
+var builderPMFCache = new LRUCache(1e3);
+
+// src/builder/ast.ts
+var defaultEps = 0;
+var singleDiePMFCache = new LRUCache(1e3);
+function astFromRollConfigs(configs) {
+  if (!configs || configs.length === 0) return void 0;
+  const children = [];
+  let constantSum = 0;
+  for (const cfg of configs) {
+    const sign = cfg.isSubtraction || cfg.count < 0 ? -1 : 1;
+    const count = Math.abs(cfg.count || 0);
+    constantSum += cfg.modifier || 0;
+    if ((cfg.sides || 0) <= 0) continue;
+    const die = {
+      type: "die",
+      sides: cfg.sides,
+      reroll: cfg.reroll > 0 ? cfg.reroll : void 0,
+      minimum: cfg.minimum > 0 ? cfg.minimum : void 0,
+      explode: cfg.explode && Number.isFinite(cfg.explode) && cfg.explode > 0 ? cfg.explode : void 0
+    };
+    let node = die;
+    let appliedRollType = false;
+    if (cfg.rollType && cfg.rollType !== "flat") {
+      if (cfg.sides === 20) {
+        node = {
+          type: "d20Roll",
+          rollType: cfg.rollType,
+          child: node
+        };
+      } else {
+        const n = cfg.rollType === "elven accuracy" ? 3 : 2;
+        const mode = cfg.rollType === "disadvantage" ? "lowest" : "highest";
+        const base = { type: "sum", count: n, child: node };
+        node = { type: "keep", mode, count: 1, child: base };
+      }
+      appliedRollType = true;
+    }
+    if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
+      const base = { type: "sum", count: cfg.keep.total, child: node };
+      node = {
+        type: "keep",
+        mode: cfg.keep.mode,
+        count: cfg.keep.count,
+        child: base
+      };
+    } else {
+      const c = appliedRollType ? 1 : Math.max(1, count || 1);
+      node = { type: "sum", count: c, child: node };
+    }
+    children.push({ node, sign });
+  }
+  if (children.length === 0) {
+    return { type: "constant", value: constantSum };
+  }
+  const add = { type: "add", children };
+  if (constantSum !== 0)
+    add.children.push({
+      node: { type: "constant", value: constantSum },
+      sign: 1
+    });
+  return add;
+}
+function resolve(node, eps = defaultEps) {
+  const signature = getASTSignature(node);
+  const cacheKey = `${signature}_${eps}`;
+  const cached = builderPMFCache.get(cacheKey);
+  if (cached) return cached;
+  const result = (() => {
+    switch (node.type) {
+      case "constant":
+        return PMF.delta(node.value, eps);
+      case "die": {
+        return resolveSingleDie(node, eps);
+      }
+      case "sum": {
+        const base = resolve(node.child, eps);
+        const n = Math.max(0, Math.floor(node.count));
+        if (n === 0) return PMF.delta(0, eps);
+        if (n === 1) return base;
+        return base.power(n, eps);
+      }
+      case "add": {
+        let shift = 0;
+        const parts = [];
+        for (const c of node.children) {
+          if (c.node.type === "constant") {
+            shift += c.sign * c.node.value;
+          } else {
+            const p = resolve(c.node, eps);
+            parts.push(c.sign === 1 ? p : p.mapDamage((v) => -v));
+          }
+        }
+        if (parts.length === 0) return PMF.delta(shift, eps);
+        let res = parts.length === 1 ? parts[0] : PMF.convolveMany(parts, eps);
+        if (shift !== 0) res = res.mapDamage((v) => v + shift);
+        return res;
+      }
+      case "keep": {
+        const total = getTotalCount(node);
+        const die = findDie(node.child.child);
+        const perDie = die ? resolveSingleDie(die, eps) : PMF.delta(0, eps);
+        const keepCount = Math.max(0, Math.min(node.count, total));
+        if (keepCount === 0 || total === 0) return PMF.delta(0, eps);
+        return keepSumPMF(
+          perDie,
+          total,
+          keepCount,
+          node.mode === "highest",
+          eps
+        );
+      }
+      case "d20Roll": {
+        const childDie = findDie(node.child);
+        const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
+        return d20RollPMF(node.rollType, rerollOne);
+      }
+    }
+  })();
+  builderPMFCache.set(cacheKey, result);
+  return result;
+}
+function pmfFromRollBuilder(rb, eps = defaultEps) {
+  const configs = rb.getSubRollConfigs?.() ?? [];
+  const ast = astFromRollConfigs(configs) || { type: "constant", value: 0 };
+  return resolve(ast, eps);
+}
+function resolveSingleDie(die, eps = defaultEps) {
+  const signature = getASTSignature(die);
+  const cacheKey = `${signature}_${eps}`;
+  const cached = singleDiePMFCache.get(cacheKey);
+  if (cached) return cached;
+  const s = Math.max(0, Math.floor(die.sides));
+  if (s <= 0) return PMF.delta(0, eps);
+  let probs = /* @__PURE__ */ new Map();
+  for (let v = 1; v <= s; v++) probs.set(v, 1 / s);
+  const r = Math.max(0, Math.floor(die.reroll || 0));
+  if (r > 0) {
+    const k = Math.min(r, s);
+    const rerollMass = k / s;
+    const uniformReroll = rerollMass / s;
+    const next = /* @__PURE__ */ new Map();
+    for (let v = 1; v <= s; v++) {
+      const keep = v <= k ? 0 : 1 / s;
+      next.set(v, keep + uniformReroll);
+    }
+    probs = next;
+  }
+  let pmf = PMF.fromMap(new Map(probs), eps);
+  const minV = Math.max(0, Math.floor(die.minimum || 0));
+  if (minV > 0) pmf = pmf.mapDamage((v) => Math.max(v, minV));
+  const explode = die.explode;
+  if (explode && Number.isFinite(explode) && explode > 0) {
+    const times = Math.floor(explode);
+    const maxFace = s;
+    const nonMax = /* @__PURE__ */ new Map();
+    const pMax = pmf.pAt(maxFace);
+    for (const v of pmf.support()) {
+      if (v !== maxFace) nonMax.set(v, pmf.pAt(v));
+    }
+    let nonMaxPMF = PMF.fromMap(nonMax, eps);
+    if (Math.abs(nonMaxPMF.mass() - (1 - pMax)) > eps) {
+      nonMaxPMF = nonMaxPMF.scaleMass(1 - pMax);
+    }
+    let tail = PMF.delta(0, eps);
+    const addOnce = pmf;
+    for (let t = 1; t <= times; t++) {
+      tail = tail.convolve(addOnce, eps);
+    }
+    const exploded = PMF.branch(
+      tail.mapDamage((v) => v + maxFace),
+      nonMaxPMF,
+      pMax
+    );
+    pmf = exploded;
   }
-  configToSingleExpressionWithoutModifier(config, isRootDie) {
-    if (!config.sides || config.sides <= 0) return "";
-    let baseDie = `d${config.sides}`;
-    if (config.reroll > 0) {
-      if (config.minimum > 0 && config.explode > 0) ; else if (config.minimum > 0) {
-        for (let i = config.reroll; i >= 1; i--) baseDie += ` reroll ${i}`;
-      } else {
-        for (let i = 1; i <= config.reroll; i++) baseDie += ` reroll ${i}`;
+  singleDiePMFCache.set(cacheKey, pmf);
+  return pmf;
+}
+function findDie(node) {
+  switch (node.type) {
+    case "die":
+      return node;
+    case "constant":
+      return void 0;
+    case "sum":
+    case "d20Roll":
+      return findDie(node.child);
+    case "keep":
+      return findDie(node.child.child);
+    case "add":
+      for (const c of node.children) {
+        const d2 = findDie(c.node);
+        if (d2) return d2;
       }
+      return void 0;
+  }
+}
+function getTotalCount(node) {
+  let cur = node.child;
+  while (cur.type === "keep") cur = cur.child;
+  return cur.type === "sum" ? Math.max(0, Math.floor(cur.count)) : 0;
+}
+function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
+  if (keep >= total) return single.power(total, eps);
+  if (keep <= 0) return PMF.delta(0, eps);
+  const sortedSupport = [...single.support()].sort((a, b) => a - b);
+  const pmfSig = sortedSupport.map((val) => `${val}:${single.pAt(val).toPrecision(6)}`).join(",");
+  const cacheKey = `keep|${pmfSig}|t:${total}|k:${keep}|h:${highest ? 1 : 0}|e:${eps}`;
+  const cached = builderPMFCache.get(cacheKey);
+  if (cached) return cached;
+  const support = single.support();
+  const probs = support.map((v) => ({ v, p: single.pAt(v) }));
+  const out = /* @__PURE__ */ new Map();
+  function dfs(i, accValues, weight) {
+    if (i === total) {
+      const sorted = [...accValues].sort((a, b) => highest ? b - a : a - b);
+      let sum = 0;
+      for (let j = 0; j < keep; j++) sum += sorted[j];
+      out.set(sum, (out.get(sum) || 0) + weight);
+      return;
     }
-    if (config.minimum > 0) {
-      baseDie = `${config.minimum}>${baseDie}`;
-      if (config.reroll > 0 && config.explode > 0) {
-        for (let i = 1; i <= config.reroll; i++) {
-          baseDie += ` reroll ${i}`;
-        }
-      }
+    for (const { v, p } of probs) {
+      if (p <= 0) continue;
+      dfs(i + 1, [...accValues, v], weight * p);
     }
-    if (baseDie === "d20 reroll 1" && config.minimum <= 1) baseDie = "hd20";
-    let mainExpression = "";
-    switch (config.rollType) {
-      case "advantage":
-        mainExpression = `${baseDie} > ${baseDie}`;
-        break;
-      case "disadvantage":
-        mainExpression = `${baseDie} < ${baseDie}`;
-        break;
-      case "elven accuracy":
-        mainExpression = `${baseDie} > ${baseDie} > ${baseDie}`;
-        break;
-      case "flat":
-        if (config.keep) {
-          const mode = config.keep.mode === "highest" ? "kh" : "kl";
-          mainExpression = `${config.keep.total}${mode}${config.keep.count}(${baseDie})`;
+  }
+  dfs(0, [], 1);
+  const result = PMF.fromMap(out, eps);
+  builderPMFCache.set(cacheKey, result);
+  return result;
+}
+function getASTSignature(node) {
+  switch (node.type) {
+    case "constant":
+      return `c:${node.value}`;
+    case "die": {
+      const parts = [];
+      parts.push(`s:${node.sides}`);
+      if (node.reroll) parts.push(`r:${node.reroll}`);
+      if (node.minimum) parts.push(`m:${node.minimum}`);
+      if (node.explode) parts.push(`e:${node.explode}`);
+      return `d{${parts.join(",")}}`;
+    }
+    case "sum":
+      return `sum{c:${node.count},ch:${getASTSignature(node.child)}}`;
+    case "d20Roll":
+      return `d20{t:${node.rollType},ch:${getASTSignature(node.child)}}`;
+    case "keep":
+      return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(
+        node.child
+      )}}`;
+    case "add": {
+      let constantValue = 0;
+      const otherChildrenSigs = [];
+      for (const c of node.children) {
+        if (c.node.type === "constant") {
+          constantValue += c.sign * c.node.value;
         } else {
-          const isComplex = baseDie.length > `d${config.sides}`.length;
-          const isHalflingShorthand = baseDie === "hd20";
-          const isD20Shorthand = baseDie === "d20" && isRootDie;
-          const hasMinimum = baseDie.startsWith("(") && baseDie.includes(">");
-          const hasReroll = baseDie.includes("reroll");
-          const effectiveCount = config.isSubtraction ? Math.abs(config.count) : config.count < 0 ? 1 : Math.abs(config.count);
-          if (effectiveCount > 1) {
-            const shouldAddParentheses = isComplex && (// Complex single roll: explode + reroll
-            !hasMinimum && !hasReroll || // Simple complex case
-            hasReroll && !hasMinimum);
-            mainExpression = shouldAddParentheses ? `${effectiveCount}(${baseDie})` : `${effectiveCount}${baseDie}`;
-          } else if (effectiveCount === 1) {
-            if (config.isSubtraction) {
-              mainExpression = `1${baseDie}`;
-            } else if (isComplex || isHalflingShorthand || isD20Shorthand || config.count < 0) {
-              mainExpression = baseDie;
-            } else {
-              mainExpression = `1${baseDie}`;
-            }
-          } else {
-            mainExpression = baseDie;
-          }
-        }
-        if (config.bestOf && config.count && config.bestOf < config.count) {
-          mainExpression += `kh${config.bestOf}`;
+          otherChildrenSigs.push(
+            `${c.sign === -1 ? "-" : "+"}${getASTSignature(c.node)}`
+          );
         }
-        break;
+      }
+      if (constantValue !== 0) {
+        otherChildrenSigs.push(
+          constantValue > 0 ? `+c:${constantValue}` : `-c:${-constantValue}`
+        );
+      }
+      otherChildrenSigs.sort();
+      return `add[${otherChildrenSigs.join("")}]`;
     }
-    return mainExpression;
-  }
-  getRootDieConfig() {
-    const configs = this.subRollConfigs;
-    return configs.find((config) => config.sides > 0) || configs[0];
-  }
-  getAllDieConfigs() {
-    return this.getSubRollConfigs();
-  }
-  getBonusDiceConfigs() {
-    const allConfigs = this.subRollConfigs;
-    const rootConfig = allConfigs.find((config) => config.sides > 0) || allConfigs[0];
-    if (!rootConfig) return [];
-    return allConfigs.filter((config) => config.sides > 0).filter((config) => config !== rootConfig);
-  }
-  getBonusDicePMFs(check, eps = 0) {
-    return check.getBonusDiceConfigs().map(
-      (config) => pmfFromRollBuilder(_RollBuilder.fromConfigs([config]), eps)
-    );
-  }
-  get modifier() {
-    return this.subRollConfigs.reduce(
-      (sum, config) => sum + config.modifier,
-      0
-    );
-  }
-  get rollType() {
-    const rootConfig = this.getRootDieConfig();
-    return rootConfig?.rollType || "flat";
-  }
-  get baseReroll() {
-    const rootConfig = this.getRootDieConfig();
-    return rootConfig?.reroll || 0;
   }
-};
+}
 
 // src/builder/attack.ts
 var AttackBuilder = class _AttackBuilder {
@@ -3091,9 +3164,8 @@ var AttackBuilder = class _AttackBuilder {
     let effectPart = "";
     if (this.hitEffect) {
       effectPart = `(${this.hitEffect.toExpression()})`;
-      let crit = void 0;
       if (this.critEffect !== null) {
-        crit = this.critEffect ?? this.hitEffect.copy().doubleDice();
+        const crit = this.critEffect ?? this.hitEffect.copy().doubleDice();
         const critThreshold = this.check.critThreshold;
         if (critThreshold < 15 || critThreshold > 20) {
           throw new Error(
@@ -3181,6 +3253,9 @@ var AttackBuilder = class _AttackBuilder {
   toPMF(eps = 0) {
     return this.resolve(eps).pmf;
   }
+  get pmf() {
+    return this.toPMF();
+  }
   // By default, create query on PMF with no pruning
   toQuery(eps = 0) {
     return this.toPMF(eps).query();
@@ -3254,6 +3329,10 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
     return new _ACBuilder(baseCopy, newConfig.ac, newConfig);
   }
 };
+RollBuilder.prototype.ac = function(targetAC) {
+  if (isNaN(targetAC)) throw new Error("Invalid NaN value for targetAC");
+  return new ACBuilder(this, targetAC);
+};
 
 // src/builder/save.ts
 var SaveBuilder = class _SaveBuilder {
@@ -3296,6 +3375,9 @@ var SaveBuilder = class _SaveBuilder {
   toPMF(eps = 0) {
     return this.resolve(eps).pmf;
   }
+  get pmf() {
+    return this.toPMF();
+  }
   // By default, create query on PMF with no pruning
   toQuery(eps = 0) {
     return this.toPMF(eps).query();
@@ -3393,56 +3475,10 @@ var DCBuilder = class _DCBuilder extends RollBuilder {
     return PMF.fromMap(m, eps);
   }
 };
-
-// src/builder/factory.ts
-var rollFn = (count, sidesOrDie, modifier) => {
-  if (sidesOrDie instanceof RollBuilder) {
-    const subRollConfigs = sidesOrDie.getSubRollConfigs();
-    if (subRollConfigs.length === 0) return new RollBuilder(0).plus(modifier);
-    const absCount = Math.abs(count);
-    const newConfigs = subRollConfigs.map((config) => ({
-      ...config,
-      count: config.count * absCount,
-      modifier: config.modifier * absCount
-    }));
-    let resultBuilder = new RollBuilder(newConfigs);
-    if (count < 0) {
-      const negatedConfigs = resultBuilder.getSubRollConfigs().map((c) => ({ ...c, isSubtraction: !c.isSubtraction }));
-      resultBuilder = new RollBuilder(negatedConfigs);
-    }
-    return resultBuilder.plus(modifier);
-  } else {
-    let builder = new RollBuilder(count);
-    if (sidesOrDie && sidesOrDie > 0) {
-      builder = builder.d(sidesOrDie);
-    }
-    return builder.plus(modifier);
-  }
+RollBuilder.prototype.dc = function(saveDC) {
+  if (isNaN(saveDC)) throw new Error("Invalid NaN value for saveDC");
+  return new DCBuilder(this).dc(saveDC);
 };
-rollFn.d = (sides) => new RollBuilder(1).d(sides);
-rollFn.hd20 = () => new RollBuilder(1).d20().reroll(1);
-rollFn.d4 = () => new RollBuilder(1).d4();
-rollFn.d6 = () => new RollBuilder(1).d6();
-rollFn.d8 = () => new RollBuilder(1).d8();
-rollFn.d10 = () => new RollBuilder(1).d10();
-rollFn.d12 = () => new RollBuilder(1).d12();
-rollFn.d20 = () => new RollBuilder(1).d20();
-rollFn.d100 = () => new RollBuilder(1).d100();
-rollFn.flat = (n) => new RollBuilder(0).plus(n);
-function d(sides) {
-  return new RollBuilder(1).d(sides);
-}
-var d4 = new RollBuilder(1).d4();
-var d6 = new RollBuilder(1).d6();
-var d8 = new RollBuilder(1).d8();
-var d10 = new RollBuilder(1).d10();
-var d12 = new RollBuilder(1).d12();
-var d20 = new RollBuilder(1).d20();
-var hd20 = new RollBuilder(1).d20().reroll(1);
-var d100 = new RollBuilder(1).d100();
-var flat = (n) => new RollBuilder(0).plus(n);
-var roll = rollFn;
-var builderPMFCache = new LRUCache(1e3);
 
 exports.ACBuilder = ACBuilder;
 exports.DCBuilder = DCBuilder;