@platonic-dice/core 2.2.2 → 3.0.2

package/dist/entities/TestConditions.d.ts

@@ -1,97 +0,0 @@
-export type BaseTestCondition = {
-    dieType: DieTypeValue;
-};
-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 TestTypeValue = import("./TestType").TestTypeValue;
-export type DieTypeValue = import("./DieType").DieTypeValue;
-/**
- * Represents any valid dice roll test condition.
- *
- * This is a union type of all the internal test condition shapes:
- * - `TargetConditions` – single target value
- * - `SkillConditions` – target with optional critical thresholds
- * - `WithinConditions` – min/max range
- * - `SpecificListConditions` – array of specific allowed values
- */
-export type Conditions = TargetConditions | SkillConditions | WithinConditions | SpecificListConditions;
-export type TestConditionsInstance = InstanceType<typeof TestConditions>;
-/**
- * @typedef {import("./TestType").TestTypeValue} TestTypeValue
- * @typedef {import("./DieType").DieTypeValue} DieTypeValue
- */
-/**
- * Represents a set of conditions for a dice roll test.
- */
-export class TestConditions {
-    /**
-     * @param {TestTypeValue} testType - The test type.
-     * @param {Conditions} conditions - The test conditions object.
-     * @param {DieTypeValue} dieType - The die type to validate numeric ranges.
-     * @throws {TypeError|RangeError} If the test type or conditions are invalid.
-     */
-    constructor(testType: TestTypeValue, conditions: Conditions, dieType: DieTypeValue);
-    /** @type {TestTypeValue} */
-    testType: TestTypeValue;
-    /** @type {Conditions} */
-    conditions: Conditions;
-    /** @type {DieTypeValue} */
-    dieType: DieTypeValue;
-    /**
-     * Validates that the test conditions still conforms to spec.
-     * (Useful if they are loaded dynamically or serialized.)
-     * @throws {TypeError} If the test conditions are invalid.
-     */
-    validate(): void;
-}
-/**
- * Master validation function for all test conditions.
- *
- * @function areValidTestConditions
- * @param {Conditions} c
- * @param {TestTypeValue} testType
- * @returns {boolean}
- */
-export function areValidTestConditions(c: Conditions, testType: TestTypeValue): boolean;
-/**
- * Normalises any input into a {@link TestConditions} instance.
- * Supports both pre-existing instances and plain objects.
- * Automatically validates all conditions for the specified die type.
- *
- * @function normaliseTestConditions
- * @param {TestConditions | { testType: TestTypeValue, [key: string]: any }} tc
- *   A {@link TestConditions} instance or plain object with `testType` and other fields.
- * @param {DieTypeValue} dieType
- *   The die type (e.g., `'d6'`, `'d20'`) used for validation.
- * @returns {TestConditions}
- *   A validated {@link TestConditions} instance.
- * @throws {TypeError}
- *   If the input is neither a TestConditions instance nor a plain object.
- *
- * @example
- * // Passing a plain object
- * const conditions = normaliseTestConditions({ testType: 'atLeast', target: 4 }, 'd6');
- *
- * @example
- * // Passing an existing TestConditions instance
- * const existing = new TestConditions('exact', { target: 3 }, 'd6');
- * const conditions2 = normaliseTestConditions(existing, 'd6');
- */
-export function normaliseTestConditions(tc: TestConditions | {
-    testType: TestTypeValue;
-    [key: string]: any;
-}, dieType: DieTypeValue): TestConditions;
-//# sourceMappingURL=TestConditions.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TestConditions.d.ts","sourceRoot":"","sources":["../../src/entities/TestConditions.js"],"names":[],"mappings":";aAiMc,YAAY;;+BAKb,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;+BAEtC,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;qCAEhD,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE;8BAExC,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE;4BA5L5F,OAAO,YAAY,EAAE,aAAa;2BAClC,OAAO,WAAW,EAAE,YAAY;;;;;;;;;;yBA4JhC,gBAAgB,GAAG,eAAe,GAAG,gBAAgB,GAAG,sBAAsB;qCAI9E,YAAY,CAAC,OAAO,cAAc,CAAC;AAlKhD;;;GAGG;AAEH;;GAEG;AACH;IACE;;;;;OAKG;IACH,sBALW,aAAa,cACb,UAAU,WACV,YAAY,EAgDtB;IANC,4BAA4B;IAC5B,UADW,aAAa,CACA;IACxB,yBAAyB;IACzB,YADW,UAAU,CACO;IAC5B,2BAA2B;IAC3B,SADW,YAAY,CACD;IAGxB;;;;OAIG;IACH,iBASC;CACF;AAED;;;;;;;GAOG;AACH,0CAJW,UAAU,YACV,aAAa,GACX,OAAO,CAwBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,4CAlBW,cAAc,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,WAEhE,YAAY,GAEV,cAAc,CA0B1B"}

package/dist/entities/TestType.d.ts

@@ -1,28 +0,0 @@
-export type TestTypeKey = keyof typeof TestType;
-export type TestTypeValue = (typeof TestType)[keyof typeof TestType];
-export type TestType = string;
-/**
- * @module @platonic-dice/core/src/entities/TestType
- * @description
- * Enum for test evaluation types (used in {@link TestConditions}).
- *
- * @readonly
- * @enum {string}
- */
-export const TestType: Readonly<{
-    Exact: "exact";
-    AtLeast: "at_least";
-    AtMost: "at_most";
-    Within: "within";
-    InList: "in_list";
-    Skill: "skill";
-}>;
-/**
- * Checks whether a given value is a valid `TestType`.
- *
- * @function isValidTestType
- * @param {TestTypeValue | null | undefined} testType
- * @returns {boolean}
- */
-export function isValidTestType(testType: TestTypeValue | null | undefined): boolean;
-//# sourceMappingURL=TestType.d.ts.map

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

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

package/dist/entities/index.d.ts

@@ -1,19 +0,0 @@
-import { DieType } from "./DieType.js";
-import { isValidDieType } from "./DieType.js";
-import { Outcome } from "./Outcome.js";
-import { isValidOutcome } from "./Outcome.js";
-import { RollModifier } from "./RollModifier.js";
-import { isValidRollModifier } from "./RollModifier.js";
-import { normaliseRollModifier } from "./RollModifier.js";
-import { RollType } from "./RollType.js";
-import { isValidRollType } from "./RollType.js";
-import { TestConditions } from "./TestConditions.js";
-import { areValidTestConditions } from "./TestConditions.js";
-import { normaliseTestConditions } from "./TestConditions.js";
-import { ModifiedTestConditions } from "./ModifiedTestConditions.js";
-import { areValidModifiedTestConditions } from "./ModifiedTestConditions.js";
-import { computeModifiedRange } from "./ModifiedTestConditions.js";
-import { TestType } from "./TestType.js";
-import { isValidTestType } from "./TestType.js";
-export { DieType, isValidDieType, Outcome, isValidOutcome, RollModifier, isValidRollModifier, normaliseRollModifier, RollType, isValidRollType, TestConditions, areValidTestConditions, normaliseTestConditions, ModifiedTestConditions, areValidModifiedTestConditions, computeModifiedRange, TestType, isValidTestType };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/entities/index.js"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-declare const _exports: typeof import("./roll") & typeof import("./rollDice") & typeof import("./rollMod") & typeof import("./rollDiceMod") & typeof import("./rollTest") & typeof import("./rollModTest") & typeof import("./analyseTest") & typeof import("./analyseModTest") & typeof import("./entities") & {
-    default: any;
-};
-export = _exports;
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"wBAyBU,cAAc,QAAQ,CAAC,GAChC,cAAuB,YAAY,CAAC,GACpC,cAAuB,WAAW,CAAC,GACnC,cAAuB,eAAe,CAAC,GACvC,cAAuB,YAAY,CAAC,GACpC,cAAuB,eAAe,CAAC,GACvC,cAAuB,eAAe,CAAC,GACvC,cAAuB,kBAAkB,CAAC,GAC1C,cAAuB,YAAY,CAAC,GACpC;IAAW,OAAO,EAAE,GAAG,CAAA;CAAE"}

package/dist/roll.d.ts

@@ -1,66 +0,0 @@
-export type DieTypeValue = import("./entities/DieType").DieTypeValue;
-export type RollTypeValue = import("./entities/RollType").RollTypeValue;
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/RollType").RollTypeValue} RollTypeValue
- */
-/**
- * Rolls a single die of the specified type, optionally applying advantage or disadvantage.
- *
- * @function roll
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D20`).
- * @param {RollTypeValue | undefined} [rollType=undefined] - Optional roll mode (`RollType.Advantage` or `RollType.Disadvantage`).
- * @returns {number} The rolled value (integer between 1 and the die's maximum face).
- * @throws {TypeError} If `dieType` or `rollType` are invalid.
- *
- * @example
- * const result = roll(DieType.D20, RollType.Advantage);
- */
-export function roll(dieType: DieTypeValue, rollType?: RollTypeValue | undefined): number;
-/**
- * Rolls a die with advantage.
- * @type {(dieType: DieTypeValue) => number}
- *
- * @example
- * const result = rollAdv(DieType.D10);
- */
-export const rollAdv: (dieType: DieTypeValue) => number;
-/**
- * Rolls a die with disadvantage.
- * @type {(dieType: DieTypeValue) => number}
- *
- * @example
- * const result = rollDis(DieType.D10);
- */
-export const rollDis: (dieType: DieTypeValue) => number;
-/**
- * Rolls a D4 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD4: (rollType?: RollTypeValue | undefined) => number;
-/**
- * Rolls a D6 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD6: (rollType?: RollTypeValue | undefined) => number;
-/**
- * Rolls a D8 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD8: (rollType?: RollTypeValue | undefined) => number;
-/**
- * Rolls a D10 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD10: (rollType?: RollTypeValue | undefined) => number;
-/**
- * Rolls a D12 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD12: (rollType?: RollTypeValue | undefined) => number;
-/**
- * Rolls a D20 die.
- * @type {(rollType?: RollTypeValue | undefined) => number}
- */
-export const rollD20: (rollType?: RollTypeValue | undefined) => number;
-//# sourceMappingURL=roll.d.ts.map

package/dist/roll.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"roll.d.ts","sourceRoot":"","sources":["../src/roll.js"],"names":[],"mappings":"2BA8Ba,OAAO,oBAAoB,EAAE,YAAY;4BACzC,OAAO,qBAAqB,EAAE,aAAa;AAFxD;;;GAGG;AAEH;;;;;;;;;;;GAWG;AACH,8BARW,YAAY,aACZ,aAAa,GAAG,SAAS,GACvB,MAAM,CAwBlB;AAMD;;;;;;GAMG;AACH,sBALU,CAAC,OAAO,EAAE,YAAY,KAAK,MAAM,CAKoB;AAE/D;;;;;;GAMG;AACH,sBALU,CAAC,OAAO,EAAE,YAAY,KAAK,MAAM,CAKuB;AAElE;;;GAGG;AACH,qBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEU;AAEpE;;;GAGG;AACH,qBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEU;AAEpE;;;GAGG;AACH,qBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEU;AAEpE;;;GAGG;AACH,sBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEY;AAEtE;;;GAGG;AACH,sBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEY;AAEtE;;;GAGG;AACH,sBAFU,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM,CAEY"}

package/dist/rollDice.d.ts

@@ -1,48 +0,0 @@
-declare namespace _exports {
-    export { DieTypeValue, RollDiceAlias };
-}
-declare namespace _exports {
-    export { rollDice };
-}
-export = _exports;
-type DieTypeValue = import("./entities/DieType").DieTypeValue;
-type RollDiceAlias = (dieType: import("./entities/DieType").DieTypeValue) => {
-    array: number[];
-    sum: number;
-};
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- */
-/**
- * Rolls one or more dice of the specified type.
- *
- * @function rollDice
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D6`, `DieType.D20`).
- * @param {Object} [options] - Optional configuration.
- * @param {number} [options.count=1] - Number of dice to roll. Must be a positive integer.
- * @returns {{ array: number[], sum: number }} An object containing:
- *   - `array`: an array of individual die rolls.
- *   - `sum`: the total sum of all rolls.
- * @throws {TypeError} If `dieType` is invalid.
- * @throws {TypeError} If `count` is not a positive integer.
- *
- * @example
- * const result = rollDice(DieType.D6, { count: 5 });
- * console.log(result.sum);   // e.g., 18
- * console.log(result.array); // e.g., [2, 5, 3, 1, 7]
- *
- * @example
- * // Roll a single d20
- * const result = rollDice(DieType.D20);
- *
- * @example
- * // Roll 3d6
- * const result = rollDice(DieType.D6, { count: 3 });
- */
-declare function rollDice(dieType: DieTypeValue, { count }?: {
-    count?: number | undefined;
-}): {
-    array: number[];
-    sum: number;
-};
-//# sourceMappingURL=rollDice.d.ts.map

package/dist/rollDice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rollDice.d.ts","sourceRoot":"","sources":["../src/rollDice.js"],"names":[],"mappings":";;;;;;;oBAsBa,OAAO,oBAAoB,EAAE,YAAY;qBAmDzC,CAAC,OAAO,EAAE,OAAO,oBAAoB,EAAE,YAAY,KAAK;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;AApDrG;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,mCAtBW,YAAY,cAEpB;IAAyB,KAAK;CAC9B,GAAU;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAoC5C"}

package/dist/rollDiceMod.d.ts

@@ -1,54 +0,0 @@
-export type DieTypeValue = import("./entities/DieType").DieTypeValue;
-export type RollModifierFunction = import("./entities/RollModifier").RollModifierFunction;
-export type RollModifierInstance = import("./entities/RollModifier").RollModifierInstance;
-export type DiceModifier = import("./entities/RollModifier").DiceModifier;
-export type rollDiceModModifier = RollModifierInstance | RollModifierFunction | DiceModifier;
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/RollModifier").RollModifierFunction} RollModifierFunction
- * @typedef {import("./entities/RollModifier").RollModifierInstance} RollModifierInstance
- * @typedef {import("./entities/RollModifier").DiceModifier} DiceModifier
- */
-/**
- * @typedef {RollModifierInstance | RollModifierFunction | DiceModifier} rollDiceModModifier
- */
-/**
- * Rolls multiple dice with optional per-die (`each`) and net (`net`) modifiers.
- *
- * @function rollDiceMod
- * @param {DieTypeValue} dieType - The die type (e.g., `DieType.D6`).
- * @param {rollDiceModModifier} [modifier={}] - The modifier(s) to apply.
- * @param {{ count?: number }} [options={}] - Optional roll count (default: 1).
- * @returns {{
- *   base: { array: number[], sum: number },
- *   modified: { each: { array: number[], sum: number }, net: { value: number } }
- * }}
- * @throws {TypeError} If `count` is invalid.
- * @throws {TypeError} If any modifier is invalid.
- */
-export function rollDiceMod(dieType: DieTypeValue, modifier?: rollDiceModModifier, { count }?: {
-    count?: number;
-}): {
-    base: {
-        array: number[];
-        sum: number;
-    };
-    modified: {
-        each: {
-            array: number[];
-            sum: number;
-        };
-        net: {
-            value: number;
-        };
-    };
-};
-/** @type {(dieType: DieTypeValue, modifier?: rollDiceModModifier, options?: { count?: number }) => number[]} */
-export const rollDiceModArr: (dieType: DieTypeValue, modifier?: rollDiceModModifier, options?: {
-    count?: number;
-}) => number[];
-/** @type {(dieType: DieTypeValue, modifier?: rollDiceModModifier, options?: { count?: number }) => number} */
-export const rollDiceModNet: (dieType: DieTypeValue, modifier?: rollDiceModModifier, options?: {
-    count?: number;
-}) => number;
-//# sourceMappingURL=rollDiceMod.d.ts.map

package/dist/rollDiceMod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rollDiceMod.d.ts","sourceRoot":"","sources":["../src/rollDiceMod.js"],"names":[],"mappings":"2BAgCa,OAAO,oBAAoB,EAAE,YAAY;mCACzC,OAAO,yBAAyB,EAAE,oBAAoB;mCACtD,OAAO,yBAAyB,EAAE,oBAAoB;2BACtD,OAAO,yBAAyB,EAAE,YAAY;kCAI9C,oBAAoB,GAAG,oBAAoB,GAAG,YAAY;AARvE;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,qCAVW,YAAY,aACZ,mBAAmB,cACnB;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAChB;IACR,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,QAAQ,EAAE;QAAE,IAAI,EAAE;YAAE,KAAK,EAAE,MAAM,EAAE,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,EAAE;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAC7E,CA4CH;AA8BD,gHAAgH;AAChH,6BADW,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,EAAE,CAClE;AAE1C,8GAA8G;AAC9G,6BADW,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,CACtE"}

package/dist/rollMod.d.ts

@@ -1,52 +0,0 @@
-declare namespace _exports {
-    export { DieTypeValue, RollTypeValue, RollModifierFunction, RollModifierInstance, DieModifierAlias };
-}
-declare namespace _exports {
-    export { rollMod };
-}
-export = _exports;
-type DieTypeValue = import("./entities/DieType").DieTypeValue;
-type RollTypeValue = import("./entities/RollType").RollTypeValue;
-type RollModifierFunction = import("./entities/RollModifier").RollModifierFunction;
-type RollModifierInstance = import("./entities/RollModifier").RollModifierInstance;
-type DieModifierAlias = (rollType?: RollTypeValue | undefined) => number;
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/RollType").RollTypeValue} RollTypeValue
- * @typedef {import("./entities/RollModifier").RollModifierFunction} RollModifierFunction
- * @typedef {import("./entities/RollModifier").RollModifierInstance} RollModifierInstance
- */
-/**
- * Rolls a single modified die by applying a modifier function or RollModifier.
- *
- * This function first rolls a base value using {@link roll}, then applies
- * the provided modifier — either a function `(n) => number` or a
- * {@link RollModifier} instance — to produce the final result.
- *
- * @function rollMod
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D20`).
- * @param {RollModifierFunction|RollModifierInstance} modifier - The modifier to apply.
- *   Can be either:
- *   - A RollModifierFunction `(n: number) => number`
- *   - A {@link RollModifier} instance
- * @param {RollTypeValue | undefined} [rollType=undefined] - Optional roll mode (`RollType.Advantage` or `RollType.Disadvantage`).
- * @returns {{ base: number, modified: number }} - The unmodified roll (`base`) and the modified result (`modified`).
- * @throws {TypeError} If the modifier is invalid (not a function or RollModifier).
- * @throws {TypeError} If the `dieType` or `rollType` are invalid (delegated to {@link roll}).
- *
- * @example
- * const result = rollMod(DieType.D20, (n) => n + 2);
- * console.log(result); // { base: 14, modified: 16 }
- *
- * @example
- * const bonus = new RollModifier((n) => Math.min(n + 3, 20));
- * const result = rollMod(DieType.D20, bonus);
- *
- * @example
- * const result = rollMod(DieType.D10, (n) => Math.floor(n / 2), RollType.Advantage);
- */
-declare function rollMod(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, rollType?: RollTypeValue | undefined): {
-    base: number;
-    modified: number;
-};
-//# sourceMappingURL=rollMod.d.ts.map

package/dist/rollMod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rollMod.d.ts","sourceRoot":"","sources":["../src/rollMod.js"],"names":[],"mappings":";;;;;;;oBAuBa,OAAO,oBAAoB,EAAE,YAAY;qBACzC,OAAO,qBAAqB,EAAE,aAAa;4BAC3C,OAAO,yBAAyB,EAAE,oBAAoB;4BACtD,OAAO,yBAAyB,EAAE,oBAAoB;wBA8CtD,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,SAAS,KAAK,MAAM;AAlD7D;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,kCArBW,YAAY,YACZ,oBAAoB,GAAC,oBAAoB,aAIzC,aAAa,GAAG,SAAS,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAsB9C"}

package/dist/rollModTest.d.ts

@@ -1,72 +0,0 @@
-export type DieTypeValue = import("./entities/DieType").DieTypeValue;
-export type OutcomeValue = import("./entities/Outcome").OutcomeValue;
-export type RollTypeValue = import("./entities/RollType").RollTypeValue;
-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;
-/**
- * Rolls a die with a modifier and evaluates the modified result against test conditions.
- *
- * @function rollModTest
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D20`).
- * @param {RollModifierFunction|RollModifierInstance} modifier - The modifier to apply to the roll.
- *   Can be either:
- *   - A function `(n: number) => number`
- *   - A {@link RollModifier} instance
- * @param {TestConditionsInstance|{ testType: TestTypeValue, [key: string]: any }} testConditions
- *   Can be:
- *   - A `TestConditions` instance
- *   - A plain object `{ testType, ...conditions }`
- * @param {RollTypeValue} [rollType=undefined] - Optional roll mode (`RollType.Advantage` or `RollType.Disadvantage`).
- * @param {Object} [options={}] - Optional configuration.
- * @param {boolean} [options.useNaturalCrits] - If true, natural max/min rolls on the die trigger
- *   critical success/failure (for Skill tests) or success/failure (for other test types).
- *   If undefined, defaults to true for Skill test type and false for all others.
- * @returns {{ base: number, modified: number, outcome: OutcomeValue }}
- *   - `base`: The raw die roll
- *   - `modified`: The roll after applying the modifier
- *   - `outcome`: The success/failure result based on test conditions
- * @throws {TypeError} If `dieType`, `modifier`, or `testConditions` are invalid.
- *
- * @example
- * const result = rollModTest(
- *   DieType.D20,
- *   (n) => n + 2,
- *   { testType: TestType.AtLeast, target: 15 }
- * );
- * console.log(result); // { base: 14, modified: 16, outcome: "success" }
- *
- * @example
- * // With natural crits enabled (TTRPG style)
- * const result = rollModTest(
- *   DieType.D20,
- *   (n) => n + 5,
- *   { testType: TestType.Skill, target: 15, critical_success: 25, critical_failure: 2 },
- *   undefined,
- *   { useNaturalCrits: true }
- * );
- * // If base roll is 20, outcome is always "critical_success"
- * // If base roll is 1, outcome is always "critical_failure"
- *
- * @example
- * // With advantage - compares outcomes, not just base rolls
- * const result = rollModTest(
- *   DieType.D20,
- *   (n) => n + 3,
- *   { testType: TestType.Skill, target: 12, critical_success: 20, critical_failure: 1 },
- *   RollType.Advantage
- * );
- * // Rolls twice, returns the result with the better outcome
- */
-export function rollModTest(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
-    testType: TestTypeValue;
-    [key: string]: any;
-}, rollType?: RollTypeValue, options?: {
-    useNaturalCrits?: boolean | undefined;
-}): {
-    base: number;
-    modified: number;
-    outcome: OutcomeValue;
-};
-//# sourceMappingURL=rollModTest.d.ts.map

package/dist/rollModTest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rollModTest.d.ts","sourceRoot":"","sources":["../src/rollModTest.js"],"names":[],"mappings":"2BAoCa,OAAO,oBAAoB,EAAE,YAAY;2BACzC,OAAO,oBAAoB,EAAE,YAAY;4BACzC,OAAO,qBAAqB,EAAE,aAAa;mCAC3C,OAAO,yBAAyB,EAAE,oBAAoB;mCACtD,OAAO,yBAAyB,EAAE,oBAAoB;4BACtD,OAAO,qBAAqB,EAAE,aAAa;qCAC3C,OAAO,2BAA2B,EAAE,sBAAsB;AAyBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,qCAlDW,YAAY,YACZ,oBAAoB,GAAC,oBAAoB,kBAIzC,sBAAsB,GAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,aAItE,aAAa,YAErB;IAA0B,eAAe;CAGzC,GAAU;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAsHrE"}

package/dist/rollTest.d.ts

@@ -1,59 +0,0 @@
-declare namespace _exports {
-    export { DieTypeValue, OutcomeValue, RollTypeValue, TestTypeValue, TestConditionsInstance, RollTestOptions };
-}
-declare namespace _exports {
-    export { rollTest };
-}
-export = _exports;
-type DieTypeValue = import("./entities/DieType").DieTypeValue;
-type OutcomeValue = import("./entities/Outcome").OutcomeValue;
-type RollTypeValue = import("./entities/RollType").RollTypeValue;
-type TestTypeValue = import("./entities/TestType").TestTypeValue;
-type TestConditionsInstance = import("./entities/TestConditions").TestConditionsInstance;
-type RollTestOptions = {
-    /**
-     * - If true, rolling the die's maximum value
-     * triggers CriticalSuccess (for Skill tests) or Success (for AtLeast/AtMost tests),
-     * and rolling 1 triggers CriticalFailure (for Skill tests) or Failure (for AtLeast)
-     * or Success (for AtMost). If undefined, defaults to true for TestType.Skill
-     * and false for all other test types.
-     */
-    useNaturalCrits?: boolean | undefined;
-};
-/**
- * @typedef {import("./entities/DieType").DieTypeValue} DieTypeValue
- * @typedef {import("./entities/Outcome").OutcomeValue} OutcomeValue
- * @typedef {import("./entities/RollType").RollTypeValue} RollTypeValue
- * @typedef {import("./entities/TestType").TestTypeValue} TestTypeValue
- * @typedef {import("./entities/TestConditions").TestConditionsInstance} TestConditionsInstance
- */
-/**
- * @typedef {Object} RollTestOptions
- * @property {boolean} [useNaturalCrits] - If true, rolling the die's maximum value
- *   triggers CriticalSuccess (for Skill tests) or Success (for AtLeast/AtMost tests),
- *   and rolling 1 triggers CriticalFailure (for Skill tests) or Failure (for AtLeast)
- *   or Success (for AtMost). If undefined, defaults to true for TestType.Skill
- *   and false for all other test types.
- */
-/**
- * Rolls a die and evaluates it against specified test conditions.
- *
- * @function rollTest
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D6`, `DieType.D20`).
- * @param {TestConditionsInstance|{ testType: TestTypeValue, [key: string]: any }} testConditions
- *   Can be:
- *   - A `TestConditions` instance.
- *   - A plain object `{ testType, ...conditions }`.
- * @param {RollTypeValue} [rollType=undefined] - Optional roll mode (`RollType.Advantage` or `RollType.Disadvantage`).
- * @param {RollTestOptions} [options={}] - Optional configuration for natural crits
- * @returns {{ base: number, outcome: OutcomeValue }} The raw roll and its evaluated outcome.
- * @throws {TypeError} If `dieType` or `testConditions` are invalid.
- */
-declare function rollTest(dieType: DieTypeValue, testConditions: TestConditionsInstance | {
-    testType: TestTypeValue;
-    [key: string]: any;
-}, rollType?: RollTypeValue, options?: RollTestOptions): {
-    base: number;
-    outcome: OutcomeValue;
-};
-//# sourceMappingURL=rollTest.d.ts.map

package/dist/rollTest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rollTest.d.ts","sourceRoot":"","sources":["../src/rollTest.js"],"names":[],"mappings":";;;;;;;oBA6Ba,OAAO,oBAAoB,EAAE,YAAY;oBACzC,OAAO,oBAAoB,EAAE,YAAY;qBACzC,OAAO,qBAAqB,EAAE,aAAa;qBAC3C,OAAO,qBAAqB,EAAE,aAAa;8BAC3C,OAAO,2BAA2B,EAAE,sBAAsB;;;;;;;;;;;AALvE;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH,mCAVW,YAAY,kBACZ,sBAAsB,GAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,aAItE,aAAa,YACb,eAAe,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CA4BnD"}

package/dist/utils/determineOutcome.d.ts

@@ -1,45 +0,0 @@
-export type OutcomeValue = import("../entities/Outcome").OutcomeValue;
-export type TestConditionsInstance = import("../entities/TestConditions").TestConditionsInstance;
-export type Conditions = import("../entities/TestConditions").Conditions;
-export type TestTypeValue = import("../entities/TestType").TestTypeValue;
-export type DieTypeValue = import("../entities/DieType").DieTypeValue;
-export type TestConditionsLike = {
-    testType: TestTypeValue;
-    dieType: DieTypeValue;
-} & Conditions;
-/**
- * @typedef {import("../entities/Outcome").OutcomeValue} OutcomeValue
- * @typedef {import("../entities/TestConditions").TestConditionsInstance} TestConditionsInstance
- * @typedef {import("../entities/TestConditions").Conditions} Conditions
- * @typedef {import("../entities/TestType").TestTypeValue} TestTypeValue
- * @typedef {import("../entities/DieType").DieTypeValue} DieTypeValue
- */
-/**
- * @private
- * @typedef {{ testType: TestTypeValue, dieType: DieTypeValue } & Conditions} TestConditionsLike
- */
-/**
- * Determines the outcome of a roll based on provided {@link TestConditions}.
- * Returns standard {@link Outcome} values including success, failure, and criticals.
- *
- * @function determineOutcome
- * @param {number} value - The rolled (possibly modified) result.
- * @param {TestConditionsInstance|TestConditionsLike} testConditions - The conditions defining success/failure thresholds.
- * @returns {OutcomeValue} The resulting outcome.
- * @throws {TypeError} If the provided conditions or test type are invalid.
- *
- * @example
- * const test = new TestConditions(TestType.AtLeast, { target: 12 });
- * const outcome = determineOutcome(14, test);
- * console.log(outcome); // "success"
- *
- * @example
- * const skill = new TestConditions(TestType.Skill, {
- *   target: 10,
- *   critical_success: 20,
- *   critical_failure: 1
- * });
- * console.log(determineOutcome(1, skill)); // "critical_failure"
- */
-export function determineOutcome(value: number, testConditions: TestConditionsInstance | TestConditionsLike): OutcomeValue;
-//# sourceMappingURL=determineOutcome.d.ts.map

package/dist/utils/determineOutcome.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"determineOutcome.d.ts","sourceRoot":"","sources":["../../src/utils/determineOutcome.js"],"names":[],"mappings":"2BAWa,OAAO,qBAAqB,EAAE,YAAY;qCAC1C,OAAO,4BAA4B,EAAE,sBAAsB;yBAC3D,OAAO,4BAA4B,EAAE,UAAU;4BAC/C,OAAO,sBAAsB,EAAE,aAAa;2BAC5C,OAAO,qBAAqB,EAAE,YAAY;iCAK1C;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG,UAAU;AAV5E;;;;;;GAMG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wCAlBW,MAAM,kBACN,sBAAsB,GAAC,kBAAkB,GACvC,YAAY,CAmDxB"}

package/dist/utils/generateResult.d.ts

@@ -1,30 +0,0 @@
-export type DieTypeValue = import("../entities/DieType").DieTypeValue;
-/**
- * Generates a single roll result for a given die type.
- *
- * @function generateResult
- * @param {DieTypeValue} dieType - The type of die to roll (e.g., "d6", "d20").
- * @returns {number} The result of rolling the die.
- * @throws {TypeError} If the die type is invalid.
- *
- * @example
- * const result = generateResult("d6");
- * console.log(result); // 1..6
- */
-export function generateResult(dieType: DieTypeValue): number;
-/**
- * @typedef {import("../entities/DieType").DieTypeValue} DieTypeValue
- */
-/**
- * Returns the number of sides on a die given its type.
- *
- * @function numSides
- * @param {DieTypeValue} dieType - The die type (e.g., "d6", "d20").
- * @returns {number} Number of sides.
- * @throws {TypeError} If the die type is invalid.
- *
- * @example
- * console.log(numSides("d6")); // 6
- */
-export function numSides(dieType: DieTypeValue): number;
-//# sourceMappingURL=generateResult.d.ts.map

package/dist/utils/generateResult.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateResult.d.ts","sourceRoot":"","sources":["../../src/utils/generateResult.js"],"names":[],"mappings":"2BASa,OAAO,qBAAqB,EAAE,YAAY;AAqBvD;;;;;;;;;;;GAWG;AACH,wCARW,YAAY,GACV,MAAM,CAUlB;AArCD;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,kCAPW,YAAY,GACV,MAAM,CAWlB"}

package/dist/utils/index.d.ts

@@ -1,8 +0,0 @@
-import { determineOutcome } from "./determineOutcome.js";
-import { generateResult } from "./generateResult.js";
-import { numSides } from "./generateResult.js";
-import { createOutcomeMap } from "./outcomeMapper.js";
-import { clearOutcomeMapCache } from "./outcomeMapper.js";
-import { getOutcomeMapCacheSize } from "./outcomeMapper.js";
-export { determineOutcome, generateResult, numSides, createOutcomeMap, clearOutcomeMapCache, getOutcomeMapCacheSize };
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.js"],"names":[],"mappings":""}