@yipe/dice 0.1.0 → 0.1.1

package/README.md

@@ -1,15 +1,23 @@
-<!-- [![npm version](https://img.shields.io/npm/v/@dpr/dice.svg)](https://www.npmjs.com/package/@dpr/dice)
-[![Build Status](https://github.com/yipe/dpr/actions/workflows/ci.yml/badge.svg)](https://github.com/yipe/dpr/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) -->
+[![npm version](https://img.shields.io/npm/v/@yipe/dice.svg)](https://www.npmjs.com/package/@yipe/dice)
+[![License: MIT](https://img.shields.io/badge/License-MIT-007ec6.svg)](LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178c6?logo=typescript)
+![Size](https://img.shields.io/bundlephobia/minzip/@yipe/dice?logo=npm&logoColor=fff&label=Size)
+![Dice](https://dprcalc.com/api/roll)
 
-# 🎲 @dpr/dice
+![Last Commit](https://img.shields.io/github/last-commit/yipe/dice?logo=github)
+![Dependencies](https://img.shields.io/librariesio/release/npm/@yipe/dice?logo=npm)
+[![GitHub issues](https://img.shields.io/github/issues/yipe/dice.svg?logo=github)](https://github.com/yipe/dice/issues)
+[![Build Status](https://github.com/yipe/dice/actions/workflows/ci.yml/badge.svg)](https://github.com/yipe/dice/actions)
+[![Tests](https://img.shields.io/badge/tests-passing-4c1.svg?logo=vitest&logoColor=white)](https://github.com/yipe/dice/actions/workflows/ci.yml)
+
+# 🎲 @yipe/dice
 
 A TypeScript library for **D&D 5e damage-per-round (DPR) calculations**, designed for players, Dungeon Masters, and developers who want to analyze combat mathematically.
 
 This library powers [dprcalc.com](https://dprcalc.com) and provides a precise, composable way to model dice rolls, attacks, and outcomes with probability mass functions (PMFs) — not just averages. This allows for rich charting and statistics with full outcome attribution.
 
 ```ts
-import { parse } from "@dpr/dice";
+import { parse } from "@yipe/dice";
 
 const attack = parse("(d20 + 8 AC 16) * (1d8 + 4) crit (2d8 + 4)");
 console.log("DPR:", attack.mean());
@@ -29,9 +37,9 @@ console.log("DPR:", attack.mean());
 
 ```bash
 # Install with npm or yarn
-npm install @dpr/dice
+npm install @yipe/dice
 # or
-yarn add @dpr/dice
+yarn add @yipe/dice
 ```
 
 ## 📦 Core Concepts
@@ -48,7 +56,7 @@ yarn add @dpr/dice
 Here's a simple example of calculating damage for a basic attack:
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 const query = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)").toQuery();
 
@@ -70,7 +78,7 @@ DPR: 4.35
 Conditional damage ("once-per-turn damage riders") like Sneak Attack can be modeled easily:
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 function damageRiderExample() {
   const attack = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)");
@@ -107,7 +115,7 @@ function damageRiderExample() {
 You can generate full statistical distributions for visualization or reporting.
 
 ```ts
-import { parse, DiceQuery } from "@dpr/dice";
+import { parse, DiceQuery } from "@yipe/dice";
 
 const query2 = parse("(d20 + 8 AC 16) * (1d4 + 4) crit (2d4 + 4)").toQuery();
 console.table(query2.toChartSeries());
@@ -227,7 +235,6 @@ Here is the basic example:
 
 ## 🧱 Roadmap
 
-- [ ] **Publish** to npm as `@dpr/dice`
 - [ ] Create a **web playground** with live examples
 - [ ] Consider creating higher-level APIs: `Turn`, `Attack`, `DamageRider`
 - [ ] Simplify and improve PMF and Query interface ergonomics

package/dist/index.cjs

@@ -1,10 +1,14 @@
 'use strict';
 
+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);
@@ -49,6 +53,8 @@ var TEST_EPS = 1e-10;
 // 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();
@@ -995,7 +1001,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);
@@ -1210,7 +1216,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);
   }
@@ -1266,11 +1272,11 @@ 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);
@@ -1281,6 +1287,14 @@ var _PMF = class _PMF {
     this.normalized = normalized;
     this.identifier = identifier;
     this._preservedProvidence = _preservedProvidence;
+    // 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 = EPSILON, identifier = "empty") {
     return new _PMF(/* @__PURE__ */ new Map(), epsilon, false, identifier);
@@ -1292,7 +1306,7 @@ var _PMF = class _PMF {
     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.
@@ -1500,7 +1514,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");
     }
@@ -2098,7 +2112,7 @@ 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;
@@ -2110,10 +2124,11 @@ function getPowerCacheKey(base, n, 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;
@@ -2782,20 +2797,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")) {