@yipe/dice 0.1.0 → 0.1.2

package/dist/index.d.cts

@@ -1,9 +1,24 @@
+/**
+ * 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 COMPUTATIONAL_EPS = 1e-40;
-/** Test tolerance for floating-point precision errors. */
-declare const TEST_EPS = 1e-10;
+declare const EPS = 1e-12;
 /** A probability bin for a specific damage value. */
 interface Bin {
     /** Total probability mass at this damage value. */
@@ -572,7 +587,7 @@ declare class DiceQuery {
      * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
      * const bothAttacks = mainAttack.convolve(bonusAttack);
      */
-    convolve(other: DiceQuery, eps?: number): DiceQuery;
+    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).
@@ -604,6 +619,7 @@ type Snapshot = {
     outcomes: Map<OutcomeType, OutcomeSnapshot>;
 };
 
+declare const pmfCache: LRUCache<string, PMF>;
 /**
  * Probability Mass Function for discrete damage distributions.
  *
@@ -635,7 +651,7 @@ declare class PMF {
     constructor(map?: Map<number, Bin>, epsilon?: number, normalized?: boolean, identifier?: string, _preservedProvidence?: boolean);
     static empty(epsilon?: number, identifier?: string): PMF;
     static zero(epsilon?: number): PMF;
-    static emptyMass(epsilon?: number): PMF;
+    static emptyMass(): PMF;
     [Symbol.iterator](): IterableIterator<[number, Bin]>;
     static clearCache(): void;
     /**
@@ -730,6 +746,7 @@ declare class PMF {
     static mixN(weights: [number, PMF][]): PMF;
     private setPreservedProvidence;
     preservedProvidence(): boolean;
+    private getPowerCacheKey;
     /**
      * Efficiently computes this PMF convolved with itself `n` times.
      * Uses exponentiation by squaring to reduce total convolutions.
@@ -741,7 +758,7 @@ declare class PMF {
      * 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, eps?: number): PMF[];
+    replicate(n: number): PMF[];
     mass(): number;
     outcomeMass(outcome: string): number;
     faceTotal(): number;
@@ -864,7 +881,6 @@ declare class PMF {
     };
     query(): DiceQuery;
 }
-declare function getPowerCacheKey(base: PMF, n: number, eps: number): string;
 
 /**
  * @internal
@@ -925,23 +941,6 @@ declare class Dice {
 }
 type _DiceInternal = never;
 
-/**
- * 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>;
-}
-
 /** Enable or disable the internal parse cache. */
 declare function setCachingEnabled(enabled: boolean): void;
 /** Returns whether the internal parse cache is currently enabled. */
@@ -955,4 +954,4 @@ declare function clearParserCache(): void;
  */
 declare function parse(expression: string, n?: number): PMF;
 
-export { type Bin, COMPUTATIONAL_EPS, type DamageDistribution, Dice, DiceQuery, LRUCache, type OutcomeLabelMap, type OutcomeSnapshot, type OutcomeType, PMF, type Snapshot, TEST_EPS, type _DiceInternal, clearParserCache, getCachingEnabled, getPowerCacheKey, parse, setCachingEnabled };
+export { type Bin, type DamageDistribution, Dice, DiceQuery, EPS, LRUCache, type OutcomeLabelMap, type OutcomeSnapshot, type OutcomeType, PMF, type Snapshot, type _DiceInternal, clearParserCache, getCachingEnabled, parse, pmfCache, setCachingEnabled };

package/dist/index.d.ts

@@ -1,9 +1,24 @@
+/**
+ * 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 COMPUTATIONAL_EPS = 1e-40;
-/** Test tolerance for floating-point precision errors. */
-declare const TEST_EPS = 1e-10;
+declare const EPS = 1e-12;
 /** A probability bin for a specific damage value. */
 interface Bin {
     /** Total probability mass at this damage value. */
@@ -572,7 +587,7 @@ declare class DiceQuery {
      * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
      * const bothAttacks = mainAttack.convolve(bonusAttack);
      */
-    convolve(other: DiceQuery, eps?: number): DiceQuery;
+    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).
@@ -604,6 +619,7 @@ type Snapshot = {
     outcomes: Map<OutcomeType, OutcomeSnapshot>;
 };
 
+declare const pmfCache: LRUCache<string, PMF>;
 /**
  * Probability Mass Function for discrete damage distributions.
  *
@@ -635,7 +651,7 @@ declare class PMF {
     constructor(map?: Map<number, Bin>, epsilon?: number, normalized?: boolean, identifier?: string, _preservedProvidence?: boolean);
     static empty(epsilon?: number, identifier?: string): PMF;
     static zero(epsilon?: number): PMF;
-    static emptyMass(epsilon?: number): PMF;
+    static emptyMass(): PMF;
     [Symbol.iterator](): IterableIterator<[number, Bin]>;
     static clearCache(): void;
     /**
@@ -730,6 +746,7 @@ declare class PMF {
     static mixN(weights: [number, PMF][]): PMF;
     private setPreservedProvidence;
     preservedProvidence(): boolean;
+    private getPowerCacheKey;
     /**
      * Efficiently computes this PMF convolved with itself `n` times.
      * Uses exponentiation by squaring to reduce total convolutions.
@@ -741,7 +758,7 @@ declare class PMF {
      * 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, eps?: number): PMF[];
+    replicate(n: number): PMF[];
     mass(): number;
     outcomeMass(outcome: string): number;
     faceTotal(): number;
@@ -864,7 +881,6 @@ declare class PMF {
     };
     query(): DiceQuery;
 }
-declare function getPowerCacheKey(base: PMF, n: number, eps: number): string;
 
 /**
  * @internal
@@ -925,23 +941,6 @@ declare class Dice {
 }
 type _DiceInternal = never;
 
-/**
- * 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>;
-}
-
 /** Enable or disable the internal parse cache. */
 declare function setCachingEnabled(enabled: boolean): void;
 /** Returns whether the internal parse cache is currently enabled. */
@@ -955,4 +954,4 @@ declare function clearParserCache(): void;
  */
 declare function parse(expression: string, n?: number): PMF;
 
-export { type Bin, COMPUTATIONAL_EPS, type DamageDistribution, Dice, DiceQuery, LRUCache, type OutcomeLabelMap, type OutcomeSnapshot, type OutcomeType, PMF, type Snapshot, TEST_EPS, type _DiceInternal, clearParserCache, getCachingEnabled, getPowerCacheKey, parse, setCachingEnabled };
+export { type Bin, type DamageDistribution, Dice, DiceQuery, EPS, LRUCache, type OutcomeLabelMap, type OutcomeSnapshot, type OutcomeType, PMF, type Snapshot, type _DiceInternal, clearParserCache, getCachingEnabled, parse, pmfCache, setCachingEnabled };

package/dist/index.js

@@ -1,8 +1,12 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
 // src/lru-cache.ts
 var LRUCache = class {
   constructor(maxSize = 1e3) {
     this.maxSize = maxSize;
-    this.cache = /* @__PURE__ */ new Map();
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
   }
   get(key) {
     const value = this.cache.get(key);
@@ -41,12 +45,13 @@ var LRUCache = class {
 };
 
 // src/types.ts
-var COMPUTATIONAL_EPS = 1e-40;
-var TEST_EPS = 1e-10;
+var EPS = 1e-12;
 
 // src/query.ts
 var _DiceQuery = class _DiceQuery {
   constructor(singles, combined) {
+    __publicField(this, "singles");
+    __publicField(this, "combined");
     this.singles = Array.isArray(singles) ? singles : [singles];
     const c = combined ?? PMF.convolveMany(this.singles);
     this.combined = Math.abs(c.mass() - 1) <= 1e-12 ? c : c.normalize();
@@ -993,7 +998,7 @@ var _DiceQuery = class _DiceQuery {
   outcomeTotals(outcomes = this.outcomeKeys()) {
     const totals = /* @__PURE__ */ new Map();
     outcomes.forEach((o) => totals.set(o, 0));
-    for (const [x, row] of this.combined.map) {
+    for (const [, row] of this.combined.map) {
       for (const o of outcomes) {
         const p = row.count[o] || 0;
         totals.set(o, (totals.get(o) || 0) + p);
@@ -1208,7 +1213,7 @@ var _DiceQuery = class _DiceQuery {
    * const bonusAttack = parse("(d20 + 3 AC 15) * (1d6 + 1)");
    * const bothAttacks = mainAttack.convolve(bonusAttack);
    */
-  convolve(other, eps) {
+  convolve(other) {
     const singles = [...this.singles, ...other.singles];
     return new _DiceQuery(singles);
   }
@@ -1221,7 +1226,7 @@ var _DiceQuery = class _DiceQuery {
    *
    * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]
    */
-  firstSuccessSplit(successOutcome, subsetOutcome, eps = COMPUTATIONAL_EPS) {
+  firstSuccessSplit(successOutcome, subsetOutcome, eps = EPS) {
     const pmfs = this.singles;
     if (!pmfs.length) {
       throw new Error("firstSuccessSplitFromPMFs: pmfs must be non-empty");
@@ -1264,33 +1269,40 @@ var _DiceQuery = class _DiceQuery {
     return [a, b, any, none];
   }
 };
-_DiceQuery.DEFAULT_OUTCOMES = [
+__publicField(_DiceQuery, "DEFAULT_OUTCOMES", [
   "hit",
   "crit",
   "missNone"
-];
+]);
 var DiceQuery = _DiceQuery;
-var EPSILON = COMPUTATIONAL_EPS;
 var pmfCache = new LRUCache(1e3);
 var _PMF = class _PMF {
-  constructor(map = /* @__PURE__ */ new Map(), epsilon = EPSILON, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvidence = true) {
+  constructor(map = /* @__PURE__ */ new Map(), epsilon = EPS, normalized = false, identifier = `anon#${_PMF.__anonIdCounter++}`, _preservedProvidence = true) {
     this.map = map;
     this.epsilon = epsilon;
     this.normalized = normalized;
     this.identifier = identifier;
     this._preservedProvidence = _preservedProvidence;
-  }
-  static empty(epsilon = EPSILON, identifier = "empty") {
+    // Cached computed values
+    __publicField(this, "_support");
+    __publicField(this, "_min");
+    __publicField(this, "_max");
+    __publicField(this, "_totalMass");
+    __publicField(this, "_mean");
+    __publicField(this, "_variance");
+    __publicField(this, "_stdev");
+  }
+  static empty(epsilon = EPS, identifier = "empty") {
     return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
   }
   // This has a single bin at value 0, mass of 1
-  static zero(epsilon = EPSILON) {
+  static zero(epsilon = EPS) {
     const m = /* @__PURE__ */ new Map();
     m.set(0, { p: 1, count: { miss: 1 }, attr: {} });
     return new _PMF(m, epsilon, false, "zero");
   }
   // This creates a single bin at value 0, but with weight 0.
-  static emptyMass(epsilon = EPSILON) {
+  static emptyMass() {
     return _PMF.zero().scaleMass(0);
   }
   //  Makes PMF iterable over [damage, bin] pairs.
@@ -1456,6 +1468,12 @@ var _PMF = class _PMF {
   preservedProvidence() {
     return this._preservedProvidence;
   }
+  getPowerCacheKey(n, eps) {
+    const id = this.identifier;
+    let key = `${id}`;
+    for (let i = 1; i < n; i++) key += `+${id}`;
+    return `${key}@${eps}`;
+  }
   /**
    * Efficiently computes this PMF convolved with itself `n` times.
    * Uses exponentiation by squaring to reduce total convolutions.
@@ -1472,7 +1490,7 @@ var _PMF = class _PMF {
     }
     if (n === 1) return this;
     const epsilon = eps ?? this.epsilon;
-    const key = getPowerCacheKey(this, n, epsilon);
+    const key = this.getPowerCacheKey(n, epsilon);
     {
       const cached = pmfCache?.get(key);
       if (cached) return cached;
@@ -1498,7 +1516,7 @@ var _PMF = class _PMF {
   /*
    * Helper for chaining multiple identical attacks
    */
-  replicate(n, eps = this.epsilon) {
+  replicate(n) {
     if (!Number.isInteger(n) || n <= 0) {
       throw new Error("combineN(n): n must be a positive integer");
     }
@@ -1871,7 +1889,7 @@ var _PMF = class _PMF {
    * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)
    * - Order-independent cache keys work better with consistent build patterns
    */
-  static convolveMany(pmfList, eps = EPSILON) {
+  static convolveMany(pmfList, eps = EPS) {
     if (pmfList.length === 0) return _PMF.empty(eps);
     if (pmfList.length === 1) return pmfList[0];
     return _PMF.reduceConvolveLeft(pmfList, eps);
@@ -1886,7 +1904,7 @@ var _PMF = class _PMF {
   static fromJSON(jsonData) {
     return new _PMF(
       new Map(jsonData.bins),
-      EPSILON,
+      EPS,
       !!jsonData.normalized,
       jsonData.identifier || "fromJSON"
     );
@@ -2096,22 +2114,17 @@ var _PMF = class _PMF {
   }
 };
 // Unique ID generator for anonymous PMFs to avoid cache key collisions
-_PMF.__anonIdCounter = 1;
+__publicField(_PMF, "__anonIdCounter", 1);
 var PMF = _PMF;
-function getPowerCacheKey(base, n, eps) {
-  const id = base.identifier;
-  let key = `${id}`;
-  for (let i = 1; i < n; i++) key += `+${id}`;
-  return `${key}@${eps}`;
-}
 
 // src/dice.ts
 var Dice = class _Dice {
   constructor(x = 0) {
-    this.faces = {};
-    this.privateData = {};
-    this.outcomeData = {};
-    this.hasHitDistributionCalculated = false;
+    __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;
@@ -2418,7 +2431,7 @@ var Dice = class _Dice {
    * Convert dice to PMF using OutcomeType labels directly from damage distribution.
    * This is much cleaner than the original complex distribution conversion.
    */
-  toPMF(numEpsilon = COMPUTATIONAL_EPS) {
+  toPMF(numEpsilon = EPS) {
     const total = this.total();
     if (total === 0) return PMF.empty(numEpsilon);
     this.ensureHitDistribution();
@@ -2780,20 +2793,12 @@ function parseArgumentInternal(s, n) {
     case "k":
       assertToken(s, "k");
       return parseKeep(s, n);
-    case "0":
-    case "1":
-    case "2":
-    case "3":
-    case "4":
-    case "5":
-    case "6":
-    case "7":
-    case "8":
-    case "9":
     case "n":
       return parseNumber(s, n);
+    default:
+      if (isDigit(c)) return parseNumber(s, n);
+      return;
   }
-  return;
 }
 function parseBinaryArgument(arg, arr, n) {
   if (arr.length >= 4 && arr[0] === "h" && peek(arr, "half")) {
@@ -2939,6 +2944,6 @@ function parseOperation(s) {
   return;
 }
 
-export { COMPUTATIONAL_EPS, Dice, DiceQuery, LRUCache, PMF, TEST_EPS, clearParserCache, getCachingEnabled, getPowerCacheKey, parse, setCachingEnabled };
+export { Dice, DiceQuery, EPS, LRUCache, PMF, clearParserCache, getCachingEnabled, parse, pmfCache, setCachingEnabled };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map