@platonic-dice/core 2.2.2 → 3.0.0

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "@platonic-dice/core",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "packageManager": "pnpm@8.15.9",
+  "engines": {
+    "node": ">=24"
+  },
   "description": "Core JavaScript logic for simulating TTRPG dice rolls.",
   "main": "dist/index.js",
-  "types": "dist-types.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist-types.d.ts"
+      "require": "./dist/index.js"
     },
     "./entities": {
       "import": "./dist/entities/index.js",
-      "require": "./dist/entities/index.js",
-      "types": "./dist/entities/index.d.ts"
+      "require": "./dist/entities/index.js"
     }
   },
   "files": [
-    "dist",
-    "dist-types.d.ts"
+    "dist"
   ],
   "keywords": [
     "dice",
@@ -41,24 +40,22 @@
   },
   "homepage": "https://github.com/sjs2k20/platonic-dice.git#readme",
   "scripts": {
-    "build": "rm -rf dist && mkdir -p dist && cp -R src/* dist/ && tsc -p tsconfig.json --emitDeclarationOnly",
+    "build": "rm -rf dist && mkdir -p dist && cp -R src/* dist/ && find dist -name \"*.d.ts\" -delete",
     "prepublishOnly": "pnpm run build",
     "test": "jest",
-    "test:types": "tsd",
-    "examples": "pnpm run examples:roll && pnpm run examples:rollDice && pnpm run examples:rollMod && pnpm run examples:rollDiceMod && pnpm run examples:rollTest && pnpm run examples:rollModTest",
+    "examples": "pnpm run examples:roll && pnpm run examples:rollDice && pnpm run examples:rollMod && pnpm run examples:rollDiceMod && pnpm run examples:rollTest && pnpm run examples:rollModTest && pnpm run examples:rollDiceTest",
     "examples:roll": "node examples/roll-example.js",
     "examples:rollDice": "node examples/rollDice-example.js",
     "examples:rollMod": "node examples/rollMod-example.js",
     "examples:rollDiceMod": "node examples/rollDiceMod-example.js",
     "examples:rollTest": "node examples/rollTest-example.js",
     "examples:rollModTest": "node examples/rollModTest-example.js",
+    "examples:rollDiceTest": "node examples/rollDiceTest-example.js",
     "examples:rollModTest:advanced": "node examples/rollModTest-advanced-features-example.js",
     "examples:analyseTest": "node examples/analyseTest-example.js",
     "examples:analyseModTest": "node examples/analyseModTest-example.js",
-    "examples:entities": "node examples/entities/DieType-example.js && node examples/entities/RollType-example.js && node examples/entities/RollModifier-example.js && node examples/entities/TestType-example.js && node examples/entities/TestConditions-example.js && node examples/entities/ModifiedTestConditions-example.js && node examples/entities/Outcome-example.js",
+    "examples:entities": "node examples/entities/DieType-example.js && node examples/entities/RollType-example.js && node examples/entities/RollModifier-example.js && node examples/entities/TestType-example.js && node examples/entities/TestConditions-example.js && node examples/entities/TestConditionsArray-example.js && node examples/entities/DiceTestConditions-example.js && node examples/entities/ModifiedTestConditions-example.js && node examples/entities/Outcome-example.js",
     "examples:all": "pnpm run examples && pnpm run examples:rollModTest:advanced && pnpm run examples:analyseTest && pnpm run examples:analyseModTest && pnpm run examples:entities"
   },
-  "tsd": {
-    "directory": "src/test-d"
-  }
+  "devDependencies": {}
 }

package/dist/analyseModTest.d.ts

@@ -1,126 +0,0 @@
-export type DieTypeValue = import("./entities/DieType").DieTypeValue;
-export type OutcomeValue = import("./entities/Outcome").OutcomeValue;
-export type RollModifierFunction = import("./entities/RollModifier").RollModifierFunction;
-export type RollModifierInstance = import("./entities/RollModifier").RollModifierInstance;
-export type TestTypeValue = import("./entities/TestType").TestTypeValue;
-export type TestConditionsInstance = import("./entities/TestConditions").TestConditionsInstance;
-export type ModifiedTestAnalysis = {
-    /**
-     * - Total number of possible die rolls
-     */
-    totalPossibilities: number;
-    /**
-     * - Count of each outcome type
-     */
-    outcomeCounts: {
-        [x: string]: number;
-    };
-    /**
-     * - Probability (0-1) of each outcome
-     */
-    outcomeProbabilities: {
-        [x: string]: number;
-    };
-    /**
-     * - Map of base roll to outcome
-     */
-    outcomesByRoll: {
-        [x: number]: import("./entities").OutcomeValue;
-    };
-    /**
-     * - Map of base roll to modified value
-     */
-    modifiedValuesByRoll: {
-        [x: number]: number;
-    };
-    /**
-     * - Array of all possible base roll values
-     */
-    rolls: number[];
-    /**
-     * - Base rolls grouped by their outcome
-     */
-    rollsByOutcome: any;
-    /**
-     * - Range of modified values achievable
-     */
-    modifiedRange: {
-        min: number;
-        max: number;
-    };
-};
-export type analyseModTestOptions = {
-    /**
-     * - If true, natural max/min rolls trigger
-     * critical outcomes. Defaults to true for Skill tests, false otherwise.
-     */
-    useNaturalCrits?: boolean | undefined;
-};
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/Outcome").OutcomeValue} OutcomeValue
- * @typedef {import("./entities/RollModifier").RollModifierFunction} RollModifierFunction
- * @typedef {import("./entities/RollModifier").RollModifierInstance} RollModifierInstance
- * @typedef {import("./entities/TestType").TestTypeValue} TestTypeValue
- * @typedef {import("./entities/TestConditions").TestConditionsInstance} TestConditionsInstance
- */
-/**
- * @typedef {Object} ModifiedTestAnalysis
- * @property {number} totalPossibilities - Total number of possible die rolls
- * @property {Object.<string, number>} outcomeCounts - Count of each outcome type
- * @property {Object.<string, number>} outcomeProbabilities - Probability (0-1) of each outcome
- * @property {Object.<number, OutcomeValue>} outcomesByRoll - Map of base roll to outcome
- * @property {Object.<number, number>} modifiedValuesByRoll - Map of base roll to modified value
- * @property {number[]} rolls - Array of all possible base roll values
- * @property {Object.<OutcomeValue, number[]>} rollsByOutcome - Base rolls grouped by their outcome
- * @property {{ min: number, max: number }} modifiedRange - Range of modified values achievable
- */
-/**
- * @typedef {Object} analyseModTestOptions
- * @property {boolean} [useNaturalCrits] - If true, natural max/min rolls trigger
- *   critical outcomes. Defaults to true for Skill tests, false otherwise.
- */
-/**
- * analyses modified test conditions without performing an actual roll.
- *
- * @function analyseModTest
- * @param {DieTypeValue} dieType - The type of die (e.g., `DieType.D20`).
- * @param {RollModifierFunction|RollModifierInstance} modifier - The modifier to apply to the roll.
- * @param {TestConditionsInstance|{ testType: TestTypeValue, [key: string]: any }} testConditions
- *   Can be:
- *   - A `TestConditions` instance
- *   - A plain object `{ testType, ...conditions }`
- * @param {analyseModTestOptions} [options={}] - Optional configuration
- * @returns {ModifiedTestAnalysis} Detailed analysis of the modified test outcomes
- * @throws {TypeError} If `dieType`, `modifier`, or `testConditions` are invalid.
- *
- * @example
- * // analyse a D20+5 skill check with DC 20
- * const analysis = analyseModTest(
- *   DieType.D20,
- *   (n) => n + 5,
- *   {
- *     testType: TestType.Skill,
- *     target: 20,
- *     critical_success: 25,
- *     critical_failure: 6
- *   }
- * );
- *
- * console.log(`Modified range: ${analysis.modifiedRange.min}-${analysis.modifiedRange.max}`);
- * console.log(`Success rate: ${(analysis.outcomeProbabilities.success * 100).toFixed(1)}%`);
- * console.log(`Need to roll: ${analysis.rollsByOutcome.success}`);
- *
- * @example
- * // See how modifier affects outcomes
- * const noMod = analyseTest(DieType.D20, { testType: TestType.AtLeast, target: 15 });
- * const withMod = analyseModTest(DieType.D20, n => n + 5, { testType: TestType.AtLeast, target: 15 });
- *
- * console.log(`Without modifier: ${(noMod.outcomeProbabilities.success * 100).toFixed(1)}%`);
- * console.log(`With +5 modifier: ${(withMod.outcomeProbabilities.success * 100).toFixed(1)}%`);
- */
-export function analyseModTest(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
-    testType: TestTypeValue;
-    [key: string]: any;
-}, options?: analyseModTestOptions): ModifiedTestAnalysis;
-//# sourceMappingURL=analyseModTest.d.ts.map

package/dist/analyseModTest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyseModTest.d.ts","sourceRoot":"","sources":["../src/analyseModTest.js"],"names":[],"mappings":"2BAyBa,OAAO,oBAAoB,EAAE,YAAY;2BACzC,OAAO,oBAAoB,EAAE,YAAY;mCACzC,OAAO,yBAAyB,EAAE,oBAAoB;mCACtD,OAAO,yBAAyB,EAAE,oBAAoB;4BACtD,OAAO,qBAAqB,EAAE,aAAa;qCAC3C,OAAO,2BAA2B,EAAE,sBAAsB;;;;;wBAKzD,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAKN,MAAM,EAAE;;;;;;;;mBAER;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;;;;;;;;;AAlB1C;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wCAnCW,YAAY,YACZ,oBAAoB,GAAC,oBAAoB,kBACzC,sBAAsB,GAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,YAItE,qBAAqB,GACnB,oBAAoB,CAkHhC"}

package/dist/analyseTest.d.ts

@@ -1,101 +0,0 @@
-export type DieTypeValue = import("./entities/DieType").DieTypeValue;
-export type OutcomeValue = import("./entities/Outcome").OutcomeValue;
-export type TestTypeValue = import("./entities/TestType").TestTypeValue;
-export type TestConditionsInstance = import("./entities/TestConditions").TestConditionsInstance;
-export type TestAnalysis = {
-    /**
-     * - Total number of possible die rolls
-     */
-    totalPossibilities: number;
-    /**
-     * - Count of each outcome type
-     */
-    outcomeCounts: {
-        [x: string]: number;
-    };
-    /**
-     * - Probability (0-1) of each outcome
-     */
-    outcomeProbabilities: {
-        [x: string]: number;
-    };
-    /**
-     * - Map of roll value to outcome
-     */
-    outcomesByRoll: {
-        [x: number]: import("./entities").OutcomeValue;
-    };
-    /**
-     * - Array of all possible roll values
-     */
-    rolls: number[];
-    /**
-     * - Rolls grouped by their outcome
-     */
-    rollsByOutcome: any;
-};
-export type analyseTestOptions = {
-    /**
-     * - If true, natural max/min rolls trigger
-     * critical outcomes. Defaults to true for Skill tests, false otherwise.
-     */
-    useNaturalCrits?: boolean | undefined;
-};
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/Outcome").OutcomeValue} OutcomeValue
- * @typedef {import("./entities/TestType").TestTypeValue} TestTypeValue
- * @typedef {import("./entities/TestConditions").TestConditionsInstance} TestConditionsInstance
- */
-/**
- * @typedef {Object} TestAnalysis
- * @property {number} totalPossibilities - Total number of possible die rolls
- * @property {Object.<string, number>} outcomeCounts - Count of each outcome type
- * @property {Object.<string, number>} outcomeProbabilities - Probability (0-1) of each outcome
- * @property {Object.<number, OutcomeValue>} outcomesByRoll - Map of roll value to outcome
- * @property {number[]} rolls - Array of all possible roll values
- * @property {Object.<OutcomeValue, number[]>} rollsByOutcome - Rolls grouped by their outcome
- */
-/**
- * @typedef {Object} analyseTestOptions
- * @property {boolean} [useNaturalCrits] - If true, natural max/min rolls trigger
- *   critical outcomes. Defaults to true for Skill tests, false otherwise.
- */
-/**
- * analyses test conditions without performing an actual roll.
- *
- * @function analyseTest
- * @param {DieTypeValue} dieType - The type of die (e.g., `DieType.D20`).
- * @param {TestConditionsInstance|{ testType: TestTypeValue, [key: string]: any }} testConditions
- *   Can be:
- *   - A `TestConditions` instance.
- *   - A plain object `{ testType, ...conditions }`.
- * @param {analyseTestOptions} [options={}] - Optional configuration for analysis
- * @returns {TestAnalysis} Detailed analysis of the test outcomes
- * @throws {TypeError} If `dieType` or `testConditions` are invalid.
- *
- * @example
- * // analyse a D20 skill check with DC 15
- * const analysis = analyseTest(DieType.D20, {
- *   testType: TestType.Skill,
- *   target: 15,
- *   critical_success: 20,
- *   critical_failure: 1
- * });
- *
- * console.log(`Success rate: ${(analysis.outcomeProbabilities.success * 100).toFixed(1)}%`);
- * console.log(`Critical success on: ${analysis.rollsByOutcome.critical_success}`);
- *
- * @example
- * // analyse without natural crits
- * const analysis = analyseTest(
- *   DieType.D20,
- *   { testType: TestType.AtLeast, target: 15 },
- *   { useNaturalCrits: false }
- * );
- */
-export function analyseTest(dieType: DieTypeValue, testConditions: TestConditionsInstance | {
-    testType: TestTypeValue;
-    [key: string]: any;
-}, options?: analyseTestOptions): TestAnalysis;
-//# sourceMappingURL=analyseTest.d.ts.map

package/dist/analyseTest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyseTest.d.ts","sourceRoot":"","sources":["../src/analyseTest.js"],"names":[],"mappings":"2BA0Ba,OAAO,oBAAoB,EAAE,YAAY;2BACzC,OAAO,oBAAoB,EAAE,YAAY;4BACzC,OAAO,qBAAqB,EAAE,aAAa;qCAC3C,OAAO,2BAA2B,EAAE,sBAAsB;;;;;wBAKzD,MAAM;;;;;;;;;;;;;;;;;;;;;;WAIN,MAAM,EAAE;;;;;;;;;;;;;AAbtB;;;;;GAKG;AAEH;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qCA7BW,YAAY,kBACZ,sBAAsB,GAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,YAItE,kBAAkB,GAChB,YAAY,CA8ExB"}

package/dist/entities/DieType.d.ts

@@ -1,35 +0,0 @@
-export type DieTypeKey = keyof typeof DieType;
-export type DieTypeValue = (typeof DieType)[keyof typeof DieType];
-/**
- * *
- */
-export type DieType = string;
-/**
- * @module @platonic-dice/core/src/entities/DieType
- * @description
- * Enum for die types used in rolling functions.
- *
- * @readonly
- * @enum {string}
- *
- * @example
- * import { DieType } from "@platonic-dice/core/src/entities";
- * const result = roll(DieType.D20);
- */
-export const DieType: Readonly<{
-    D4: "d4";
-    D6: "d6";
-    D8: "d8";
-    D10: "d10";
-    D12: "d12";
-    D20: "d20";
-}>;
-/**
- * Checks whether a given value is a valid `DieType`.
- *
- * @function isValidDieType
- * @param {DieTypeValue | null | undefined} dieType
- * @returns {boolean}
- */
-export function isValidDieType(dieType: DieTypeValue | null | undefined): boolean;
-//# sourceMappingURL=DieType.d.ts.map

package/dist/entities/DieType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DieType.d.ts","sourceRoot":"","sources":["../../src/entities/DieType.js"],"names":[],"mappings":"yBAmCa,MAAM,OAAO,OAAO;2BACpB,CAAA,OAAO,OAAO,EAAC,MAAM,OAAO,OAAO,CAAC;;;;sBA7BvC,MAAM;AANhB;;;;;;;;;;;GAWG;AACH;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAHW,YAAY,GAAG,IAAI,GAAG,SAAS,GAC7B,OAAO,CAKnB"}

package/dist/entities/ModifiedTestConditions.d.ts

@@ -1,89 +0,0 @@
-export type TestTypeValue = import("./TestType").TestTypeValue;
-export type DieTypeValue = import("./DieType").DieTypeValue;
-export type RollModifierFunction = import("./RollModifier").RollModifierFunction;
-export type RollModifierInstance = import("./RollModifier").RollModifierInstance;
-export type BaseTestCondition = {
-    modifiedRange: {
-        min: number;
-        max: number;
-    };
-};
-export type TargetConditions = BaseTestCondition & {
-    target: number;
-};
-export type WithinConditions = BaseTestCondition & {
-    min: number;
-    max: number;
-};
-export type SpecificListConditions = BaseTestCondition & {
-    values: number[];
-};
-export type SkillConditions = BaseTestCondition & {
-    target: number;
-    critical_success?: number;
-    critical_failure?: number;
-};
-export type Conditions = TargetConditions | SkillConditions | WithinConditions | SpecificListConditions;
-export type ModifiedTestConditionsInstance = InstanceType<typeof ModifiedTestConditions>;
-/**
- * Represents a set of validated test conditions for modified rolls.
- *
- * This class is similar to {@link TestConditions} but validates numeric
- * targets against the achievable range after applying a modifier.
- */
-export class ModifiedTestConditions {
-    /**
-     * @param {TestTypeValue} testType - The test type.
-     * @param {Conditions} conditions - The test conditions object.
-     * @param {DieTypeValue} dieType - The base die type.
-     * @param {RollModifierFunction | RollModifierInstance} modifier - The modifier to apply.
-     * @throws {TypeError|RangeError} If the test type or conditions are invalid.
-     */
-    constructor(testType: TestTypeValue, conditions: Conditions, dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance);
-    /** @type {TestTypeValue} */
-    testType: TestTypeValue;
-    /** @type {Conditions} */
-    conditions: Conditions;
-    /** @type {DieTypeValue} */
-    dieType: DieTypeValue;
-    /** @type {RollModifierInstance} */
-    modifier: RollModifierInstance;
-    /** @type {{ min: number, max: number }} */
-    modifiedRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * Validates that the test conditions still conform to spec.
-     * @throws {TypeError} If the test conditions are invalid.
-     */
-    validate(): void;
-}
-/**
- * Validates test conditions against a modified range.
- *
- * @private
- * @param {Conditions & Record<string, any>} c - Conditions with modifiedRange
- * @param {TestTypeValue} testType
- * @returns {boolean}
- */
-export function areValidModifiedTestConditions(c: Conditions & Record<string, any>, testType: TestTypeValue): boolean;
-/**
- * @typedef {import("./TestType").TestTypeValue} TestTypeValue
- * @typedef {import("./DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./RollModifier").RollModifierFunction} RollModifierFunction
- * @typedef {import("./RollModifier").RollModifierInstance} RollModifierInstance
- */
-/**
- * Computes the achievable range for a die + modifier combination.
- *
- * @private
- * @param {DieTypeValue} dieType
- * @param {RollModifierInstance} modifier
- * @returns {{ min: number, max: number }}
- */
-export function computeModifiedRange(dieType: DieTypeValue, modifier: RollModifierInstance): {
-    min: number;
-    max: number;
-};
-//# sourceMappingURL=ModifiedTestConditions.d.ts.map

package/dist/entities/ModifiedTestConditions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModifiedTestConditions.d.ts","sourceRoot":"","sources":["../../src/entities/ModifiedTestConditions.js"],"names":[],"mappings":"4BAyBa,OAAO,YAAY,EAAE,aAAa;2BAClC,OAAO,WAAW,EAAE,YAAY;mCAChC,OAAO,gBAAgB,EAAE,oBAAoB;mCAC7C,OAAO,gBAAgB,EAAE,oBAAoB;;mBAsN5C;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;;+BAI7B,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;+BACtC,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;qCAChD,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE;8BACxC,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE;yBAI5F,gBAAgB,GAAG,eAAe,GAAG,gBAAgB,GAAG,sBAAsB;6CAI9E,YAAY,CAAC,OAAO,sBAAsB,CAAC;AA1MxD;;;;;GAKG;AACH;IACE;;;;;;OAMG;IACH,sBANW,aAAa,cACb,UAAU,WACV,YAAY,YACZ,oBAAoB,GAAG,oBAAoB,EAmErD;IAVC,4BAA4B;IAC5B,UADW,aAAa,CACA;IACxB,yBAAyB;IACzB,YADW,UAAU,CACO;IAC5B,2BAA2B;IAC3B,SADW,YAAY,CACD;IACtB,mCAAmC;IACnC,UADW,oBAAoB,CACZ;IACnB,2CAA2C;IAC3C,eADW;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CACb;IAG5B;;;OAGG;IACH,iBASC;CACF;AAED;;;;;;;GAOG;AACH,kDAJW,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAChC,aAAa,GACX,OAAO,CAiFnB;AAtND;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,8CAJW,YAAY,YACZ,oBAAoB,GAClB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAgBxC"}

package/dist/entities/Outcome.d.ts

@@ -1,26 +0,0 @@
-export type OutcomeKey = keyof typeof Outcome;
-export type OutcomeValue = (typeof Outcome)[keyof typeof Outcome];
-export type Outcome = string;
-/**
- * @module @platonic-dice/core/src/entities/Outcome
- * @description
- * Enum for possible roll outcomes.
- *
- * @readonly
- * @enum {string}
- */
-export const Outcome: Readonly<{
-    Success: "success";
-    Failure: "failure";
-    CriticalSuccess: "critical_success";
-    CriticalFailure: "critical_failure";
-}>;
-/**
- * Checks whether a given value is a valid `Outcome`.
- *
- * @function isValidOutcome
- * @param {OutcomeValue | null | undefined} outcome
- * @returns {boolean}
- */
-export function isValidOutcome(outcome: OutcomeValue | null | undefined): boolean;
-//# sourceMappingURL=Outcome.d.ts.map

package/dist/entities/Outcome.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome.d.ts","sourceRoot":"","sources":["../../src/entities/Outcome.js"],"names":[],"mappings":"yBA6Ba,MAAM,OAAO,OAAO;2BACpB,CAAA,OAAO,OAAO,EAAC,MAAM,OAAO,OAAO,CAAC;sBAvBvC,MAAM;AANhB;;;;;;;GAOG;AACH;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wCAHW,YAAY,GAAG,IAAI,GAAG,SAAS,GAC7B,OAAO,CAKnB"}

package/dist/entities/RollModifier.d.ts

@@ -1,115 +0,0 @@
-export type RollModifierFunction = (n: number) => number;
-export type DiceModifier = {
-    /**
-     * Function or {@link RollModifier} applied to each individual die.
-     */
-    each?: RollModifierFunction | RollModifier | null | undefined;
-    /**
-     * Function or {@link RollModifier} applied to the total (sum) of all dice.
-     */
-    net?: RollModifierFunction | RollModifier | null | undefined;
-};
-export type RollModifierInstance = InstanceType<typeof RollModifier>;
-/**
- * @module @platonic-dice/core/src/entities/RollModifier
- * @description
- * Represents a numeric modifier applied to dice rolls.
- *
- * A `RollModifier` wraps a pure function `(n: number) => number`
- * that takes a base roll and returns a modified value.
- *
- * @example
- * const bonus = new RollModifier(n => n + 2);
- * const result = bonus.apply(10); // 12
- */
-/**
- * @typedef {(n: number) => number} RollModifierFunction
- * @description
- * A function that takes a single numeric input (the base roll or the total sum)
- * and returns a numeric result. Implementations SHOULD:
- *  - declare exactly one parameter (helps static checks: `fn.length === 1`)
- *  - accept a number and return a number (ideally integer for dice use-cases)
- *
- * Examples:
- * - Per-die modifier: `(n) => n + 1`
- * - Net modifier: `(sum) => Math.floor(sum * 1.5)`
- *
- * Notes:
- * - The runtime `isValidRollModifier` performs a light validation:
- *   checks the function arity and performs a test call `fn(1)` to ensure
- *   a numeric, integer-like result is returned. Keep modifiers pure.
- */
-/**
- * @typedef {Object} DiceModifier
- * @property {RollModifierFunction | RollModifier | null | undefined} [each]
- *   Function or {@link RollModifier} applied to each individual die.
- * @property {RollModifierFunction | RollModifier | null | undefined} [net]
- *   Function or {@link RollModifier} applied to the total (sum) of all dice.
- *
- * @description
- * Represents the composite modifier structure used by {@link rollDiceMod}.
- * Each field is optional and defaults to the identity modifier if omitted.
- *
- * @example
- * const modifier = {
- *   each: (n) => n + 1,
- *   net: (sum) => sum + 2,
- * };
- *
- * const mod2 = {
- *   each: new RollModifier((n) => n * 2),
- * };
- */
-/**
- * Represents a numeric modifier applied to dice rolls.
- */
-export class RollModifier {
-    /**
-     * @param {RollModifierFunction} fn - Modifier function.
-     * @throws {TypeError} If the function is not a valid roll modifier.
-     */
-    constructor(fn: RollModifierFunction);
-    /** @type {RollModifierFunction} */
-    fn: RollModifierFunction;
-    /**
-     * Applies this modifier to a roll result.
-     * @param {number} baseValue - The base roll result.
-     * @returns {number} - The modified roll result.
-     */
-    apply(baseValue: number): number;
-    /**
-     * Validates that this modifier still conforms to spec.
-     * (Useful if modifiers are loaded dynamically or serialized.)
-     * @throws {TypeError} If the modifier is invalid.
-     */
-    validate(): void;
-}
-/**
- * Checks whether a given function is a valid roll modifier.
- *
- * @function isValidRollModifier
- * @param {Function | null} m
- * @returns {boolean}
- */
-export function isValidRollModifier(m: Function | null): boolean;
-/**
- * This function ensures all modifiers conform to the correct structure:
- *  - A {@link RollModifier} instance → returned as-is.
- *  - A function `(n: number) => number` → wrapped in a new {@link RollModifier}.
- *  - `null` or `undefined` → treated as an identity modifier.
- *
- * @function normaliseRollModifier
- * @param {RollModifier | ((n: number) => number) | null | undefined} m
- *   The input modifier to normalise.
- * @returns {RollModifier}
- *   A valid {@link RollModifier} instance.
- * @throws {TypeError}
- *   If the input is invalid (not a RollModifier, function, or null/undefined).
- *
- * @example
- * const rm1 = normaliseRollModifier(); // → identity modifier
- * const rm2 = normaliseRollModifier(x => x + 1); // → RollModifier wrapping function
- * const rm3 = normaliseRollModifier(new RollModifier(x => x * 2)); // → same instance
- */
-export function normaliseRollModifier(m: RollModifier | ((n: number) => number) | null | undefined): RollModifier;
-//# sourceMappingURL=RollModifier.d.ts.map

package/dist/entities/RollModifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RollModifier.d.ts","sourceRoot":"","sources":["../../src/entities/RollModifier.js"],"names":[],"mappings":"mCAca,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM;;;;;WAmBpB,oBAAoB,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS;;;;UAEtD,oBAAoB,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS;;mCAwGvD,YAAY,CAAC,OAAO,YAAY,CAAC;AA3I9C;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,gBAHW,oBAAoB,EAY9B;IAFC,mCAAmC;IACnC,IADW,oBAAoB,CACnB;IAGd;;;;OAIG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAIC;CACF;AAED;;;;;;GAMG;AACH,uCAHW,WAAW,IAAI,GACb,OAAO,CAWnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAZW,YAAY,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAEvD,YAAY,CAgBxB"}

package/dist/entities/RollType.d.ts

@@ -1,24 +0,0 @@
-export type RollTypeKey = keyof typeof RollType;
-export type RollTypeValue = (typeof RollType)[keyof typeof RollType];
-export type RollType = string;
-/**
- * @module @platonic-dice/core/src/entities/RollType
- * @description
- * Enum for roll modes (normal, advantage, disadvantage).
- *
- * @readonly
- * @enum {string}
- */
-export const RollType: Readonly<{
-    Advantage: "advantage";
-    Disadvantage: "disadvantage";
-}>;
-/**
- * Checks whether a given value is a valid `RollType`.
- *
- * @function isValidRollType
- * @param {RollTypeValue | null | undefined} rollType
- * @returns {boolean}
- */
-export function isValidRollType(rollType: RollTypeValue | null | undefined): boolean;
-//# sourceMappingURL=RollType.d.ts.map

package/dist/entities/RollType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RollType.d.ts","sourceRoot":"","sources":["../../src/entities/RollType.js"],"names":[],"mappings":"0BA2Ba,MAAM,OAAO,QAAQ;4BACrB,CAAA,OAAO,QAAQ,EAAC,MAAM,OAAO,QAAQ,CAAC;uBArBzC,MAAM;AANhB;;;;;;;GAOG;AACH;;;GAGG;AAEH;;;;;;GAMG;AACH,0CAHW,aAAa,GAAG,IAAI,GAAG,SAAS,GAC9B,OAAO,CAKnB"}