@yipe/dice 0.2.16 → 0.2.19

package/dist/builder/index.cjs

@@ -54,6 +54,7 @@ var _DiceQuery = class _DiceQuery {
   constructor(singles, combined, eps = EPS) {
     __publicField(this, "singles");
     __publicField(this, "combined");
+    __publicField(this, "_combinedWithAttr");
     this.singles = Array.isArray(singles) ? singles : [singles];
     if (this.singles.some((s) => s === void 0)) {
       throw new Error("DiceQuery contains undefined singles");
@@ -61,6 +62,35 @@ var _DiceQuery = class _DiceQuery {
     const c = combined ?? PMF.convolveMany(this.singles);
     this.combined = Math.abs(c.mass() - 1) <= eps ? c : c.normalize();
   }
+  /**
+   * Returns a new PMF with damage attribution metadata populated.
+   *
+   * This method computes attribution on-demand for builder-generated PMFs,
+   * enabling them to work with damage attribution charts. The `attr` field
+   * tracks how much damage each outcome type contributes at each damage value.
+   *
+   * For each bin at damage D: sum(attr.values()) ≈ D × P(damage = D)
+   *
+   * Performance: Cached after first call. Adds minimal overhead vs `combined`.
+   *
+   * @returns PMF with attr field populated for damage attribution charts
+   *
+   * @example
+   * const attack = d20.plus(5).ac(15).onHit(d(2,6).plus(3)).onCrit(d(2,6))
+   * const query = attack.toQuery()
+   * const pmf = query.combinedWithAttribution()
+   * // Now pmf can be used with toDamageAttributionChartSeries()
+   */
+  combinedWithAttribution() {
+    if (this._combinedWithAttr) {
+      return this._combinedWithAttr;
+    }
+    const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());
+    const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);
+    const normalized = Math.abs(combined.mass() - 1) <= this.combined.epsilon ? combined : combined.normalize();
+    this._combinedWithAttr = normalized;
+    return normalized;
+  }
   /**
    * Returns the expected damage across all possible outcomes.
    *
@@ -1405,9 +1435,9 @@ var _PMF = class _PMF {
     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) {
+    if (totalWeight > 1 + EPS) {
       throw new Error(
-        `PMF.exclusive: total weight ${totalWeight.toFixed(6)} exceeds 1.`
+        `PMF.exclusive: total weight ${totalWeight} exceeds 1. (epsilon: ${eps})`
       );
     }
     let out = _PMF.empty(eps);
@@ -1449,6 +1479,44 @@ var _PMF = class _PMF {
     }
     return out;
   }
+  /**
+   * Adds damage attribution metadata to this PMF based on existing count metadata.
+   * For each bin, sets attr[outcome] = damage × count[outcome].
+   *
+   * This enables damage attribution charts to work with builder-generated PMFs.
+   * The parser generates attr automatically, but builder PMFs only have count.
+   *
+   * @returns New PMF with attr field populated in each bin
+   */
+  withAttribution() {
+    for (const [damage, bin] of this.map) {
+      if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {
+        return this;
+      }
+      if (damage > 0) break;
+    }
+    const newMap = /* @__PURE__ */ new Map();
+    for (const [damage, bin] of this.map) {
+      const attr = {};
+      for (const outcome in bin.count) {
+        const probability = bin.count[outcome];
+        if (probability > 0) {
+          attr[outcome] = damage * probability;
+        }
+      }
+      newMap.set(damage, {
+        p: bin.p,
+        count: { ...bin.count },
+        attr: Object.keys(attr).length > 0 ? attr : void 0
+      });
+    }
+    return new _PMF(
+      newMap,
+      this.epsilon,
+      this.normalized,
+      `${this.identifier}~attr`
+    );
+  }
   /**
    * General-purpose N-way mixture.
    * weights: Array of [weight, PMF].
@@ -2337,6 +2405,822 @@ var Mixture = class _Mixture {
   }
 };
 
+// src/parser/dice.ts
+var Dice = class _Dice {
+  constructor(x = 0) {
+    __publicField(this, "faces", {});
+    __publicField(this, "privateData", {});
+    __publicField(this, "outcomeData", {});
+    __publicField(this, "hasHitDistributionCalculated", false);
+    __publicField(this, "identifier");
+    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 = 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/parser.ts
+var parseCache = new LRUCache(1e3);
+function parse(expression, n = 0) {
+  const cleaned = expression.replace(/ /g, "").toLowerCase();
+  {
+    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);
+  {
+    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 = crit && 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 = save && 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 ? pc.total() : 0;
+      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 = miss && 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, d2) {
+  if (n === 0) return new Dice(0);
+  if (n === 1) return d2;
+  const half = Math.floor(n / 2);
+  let result = multiplyDice(half, d2);
+  result = result.add(result);
+  if (n % 2 === 1) {
+    result = result.add(d2);
+  }
+  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 "n":
+      return parseNumber(s, n);
+    default:
+      if (isDigit(c)) 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;
+}
+
 // src/builder/prob.ts
 function d20PmfFromCdf(cdfPow, eps = EPS) {
   const out = /* @__PURE__ */ new Map();
@@ -2478,6 +3362,9 @@ var RollBuilder = class _RollBuilder {
         if (isNaN(arg)) throw new Error("Invalid NaN value for argument");
         return new _RollBuilder(0).plus(arg);
       }
+      if (typeof arg === "string") {
+        return new ParsedRollBuilder(arg);
+      }
       if (arg instanceof _RollBuilder) {
         return arg;
       }
@@ -3060,6 +3947,34 @@ var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
     return new _AlwaysCritBuilder(baseCopy, newConfig, this.fromAlwaysHit);
   }
 };
+var ParsedRollBuilder = class _ParsedRollBuilder extends RollBuilder {
+  constructor(expression) {
+    super([]);
+    __publicField(this, "cachedPMF");
+    __publicField(this, "originalExpression");
+    this.originalExpression = expression;
+    this.cachedPMF = parse(expression, 0);
+  }
+  toPMF(eps = 0) {
+    return this.cachedPMF;
+  }
+  toExpression() {
+    return this.originalExpression;
+  }
+  toAST() {
+    throw new Error(
+      "ParsedRollBuilder does not support AST conversion. Use the builder API instead."
+    );
+  }
+  copy() {
+    return new _ParsedRollBuilder(this.originalExpression);
+  }
+  doubleDice() {
+    throw new Error(
+      "ParsedRollBuilder does not support doubleDice(). Use explicit onCrit() with the crit damage expression instead."
+    );
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -3590,7 +4505,11 @@ var AttackBuilder = class _AttackBuilder {
         if (this.critEffect) {
           crit = this.critEffect;
         } else {
-          crit = this.hitEffect?.copy().doubleDice() ?? RollBuilder.fromArgs(0);
+          if (this.hitEffect instanceof ParsedRollBuilder) {
+            crit = RollBuilder.fromArgs(0);
+          } else {
+            crit = this.hitEffect?.copy().doubleDice() ?? RollBuilder.fromArgs(0);
+          }
         }
         const critThreshold = this.check.critThreshold;
         if (critThreshold < 1 || critThreshold > 20) {
@@ -3598,11 +4517,14 @@ var AttackBuilder = class _AttackBuilder {
             `Invalid crit threshold: ${critThreshold}. Must be between 1 and 20.`
           );
         }
-        if (critThreshold === 20) {
-          effectPart += ` crit (${crit.toExpression()})`;
-        } else {
-          const xcritNumber = 21 - critThreshold;
-          effectPart += ` xcrit${xcritNumber} (${crit.toExpression()})`;
+        const critExpression = crit.toExpression();
+        if (critExpression !== "0") {
+          if (critThreshold === 20) {
+            effectPart += ` crit (${critExpression})`;
+          } else {
+            const xcritNumber = 21 - critThreshold;
+            effectPart += ` xcrit${xcritNumber} (${critExpression})`;
+          }
         }
       }
       if (this.missEffect) {
@@ -3683,7 +4605,7 @@ var AttackBuilder = class _AttackBuilder {
       pCrit,
       pMiss: pmiss
     } = this.resolveProbabilities(this.check, eps);
-    const hitPMF = this.hitEffect ? pmfFromRollBuilder(this.hitEffect, eps) : PMF.delta(0, eps);
+    const hitPMF = this.hitEffect ? this.hitEffect instanceof ParsedRollBuilder ? this.hitEffect.toPMF(eps) : pmfFromRollBuilder(this.hitEffect, eps) : PMF.delta(0, eps);
     let critPMF = null;
     let phit = pHit;
     let pcrit = pCrit;
@@ -3692,10 +4614,22 @@ var AttackBuilder = class _AttackBuilder {
       phit += pcrit;
       pcrit = 0;
     } else {
-      const critBuilder = this.critEffect ?? this.hitEffect?.copy().doubleDice();
-      critPMF = critBuilder ? pmfFromRollBuilder(critBuilder, eps) : PMF.delta(0, eps);
+      let critBuilder;
+      if (this.critEffect) {
+        critBuilder = this.critEffect;
+      } else if (this.hitEffect instanceof ParsedRollBuilder) {
+        critPMF = null;
+        phit += pcrit;
+        pcrit = 0;
+        critBuilder = void 0;
+      } else {
+        critBuilder = this.hitEffect?.copy().doubleDice();
+      }
+      if (critBuilder) {
+        critPMF = critBuilder instanceof ParsedRollBuilder ? critBuilder.toPMF(eps) : pmfFromRollBuilder(critBuilder, eps);
+      }
     }
-    const missPMF = this.missEffect ? pmfFromRollBuilder(this.missEffect, eps) : PMF.delta(0, eps);
+    const missPMF = this.missEffect ? this.missEffect instanceof ParsedRollBuilder ? this.missEffect.toPMF(eps) : pmfFromRollBuilder(this.missEffect, eps) : PMF.delta(0, eps);
     const mix = new Mixture(eps);
     if (phit > 0) mix.add("hit", hitPMF, phit);
     if (critPMF && pcrit > 0) mix.add("crit", critPMF, pcrit);
@@ -3952,6 +4886,7 @@ exports.AlwaysHitBuilder = AlwaysHitBuilder;
 exports.DCBuilder = DCBuilder;
 exports.HalfRollBuilder = HalfRollBuilder;
 exports.MaxOfRollBuilder = MaxOfRollBuilder;
+exports.ParsedRollBuilder = ParsedRollBuilder;
 exports.RollBuilder = RollBuilder;
 exports.SaveBuilder = SaveBuilder;
 exports.builderPMFCache = builderPMFCache;