@dicelette/core 1.19.0 → 1.20.0

package/dist/index.d.mts

@@ -9,7 +9,7 @@ import { z } from 'zod';
  * Random stats = 6
  * result = "1d20>3"
  */
-declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate): string;
+declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Parse the string provided and turn it as a readable dice for dice parser
  * @param dice {string}
@@ -232,16 +232,25 @@ declare function isNumber(value: unknown): boolean;
  * Replace the `{exp}` in the dice.
  * If the `{exp}` has a default value in the form of `{exp || defaultValue}`, it will be replaced by the default value.
  * @param {string} dice
+ * @param engine
  * @returns {string} the dice with the {exp} replaced by a random value
  */
-declare function replaceExpByRandom(dice: string): string;
+declare function replaceExpByRandom(dice: string, engine?: Engine | null): string;
+/**
+ * Utility function to get the engine from its name
+ * @param engine {"nativeMath" | "browserCrypto" | "nodeCrypto"} The engine name
+ * @returns {Engine} The engine
+ * @public
+ */
+declare function getEngine(engine: "nativeMath" | "browserCrypto" | "nodeCrypto"): Engine;
+declare function randomInt(min: number, max: number, engine?: Engine | null): number;
 
 /**
  * Verify if the provided dice work with random value
  * @param testDice {string}
  * @param allStats {Record<string,number>}
  */
-declare function evalStatsDice(testDice: string, allStats?: Record<string, number>): string;
+declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null): string;
 /**
  * Generate a random dice and remove the formula (+ evaluate it)
  * Used for diceDamage only
@@ -249,13 +258,13 @@ declare function evalStatsDice(testDice: string, allStats?: Record<string, numbe
  * @param template {StatisticalTemplate}
  * @returns
  */
-declare function diceRandomParse(value: string, template: StatisticalTemplate): string;
+declare function diceRandomParse(value: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Same as damageDice but for DiceType
  * @param dice {string}
  * @param template {StatisticalTemplate}
  */
-declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate): string;
+declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Random the combinaison and evaluate it to check if everything is valid
  * @param combinaison {Record<string,string>}
@@ -274,17 +283,17 @@ declare function evalOneCombinaison(combinaison: string, stats: Record<string, n
  * @param {boolean} verify - If true, will roll the dices to check if everything is valid
  * @returns {StatisticalTemplate}
  */
-declare function verifyTemplateValue(template: unknown, verify?: boolean): StatisticalTemplate;
+declare function verifyTemplateValue(template: unknown, verify?: boolean, engine?: Engine | null): StatisticalTemplate;
 /**
  * Test each damage roll from the template.damage
  * @param {StatisticalTemplate} template
  */
-declare function testDiceRegistered(template: StatisticalTemplate): void;
+declare function testDiceRegistered(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Test all combinaison with generated random value
  * @param {StatisticalTemplate} template
  */
-declare function testStatCombinaison(template: StatisticalTemplate): void;
+declare function testStatCombinaison(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Generate a random stat based on the template and the statistical min and max
  * @param {number|undefined} total
@@ -292,7 +301,7 @@ declare function testStatCombinaison(template: StatisticalTemplate): void;
  * @param {number | undefined} min
  * @returns
  */
-declare function generateRandomStat(total?: number | undefined, max?: number, min?: number): number;
+declare function generateRandomStat(total?: number | undefined, max?: number, min?: number, engine?: Engine | null): number;
 
 declare class DiceTypeError extends Error {
     readonly dice: string;
@@ -384,4 +393,4 @@ interface StatisticalSchema extends StatisticalTemplate {
     $schema?: string;
 }
 
-export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, isNumber, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };
+export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, getEngine, isNumber, randomInt, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };

package/dist/index.d.ts

@@ -9,7 +9,7 @@ import { z } from 'zod';
  * Random stats = 6
  * result = "1d20>3"
  */
-declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate): string;
+declare function createCriticalCustom(dice: string, customCritical: CustomCritical, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Parse the string provided and turn it as a readable dice for dice parser
  * @param dice {string}
@@ -232,16 +232,25 @@ declare function isNumber(value: unknown): boolean;
  * Replace the `{exp}` in the dice.
  * If the `{exp}` has a default value in the form of `{exp || defaultValue}`, it will be replaced by the default value.
  * @param {string} dice
+ * @param engine
  * @returns {string} the dice with the {exp} replaced by a random value
  */
-declare function replaceExpByRandom(dice: string): string;
+declare function replaceExpByRandom(dice: string, engine?: Engine | null): string;
+/**
+ * Utility function to get the engine from its name
+ * @param engine {"nativeMath" | "browserCrypto" | "nodeCrypto"} The engine name
+ * @returns {Engine} The engine
+ * @public
+ */
+declare function getEngine(engine: "nativeMath" | "browserCrypto" | "nodeCrypto"): Engine;
+declare function randomInt(min: number, max: number, engine?: Engine | null): number;
 
 /**
  * Verify if the provided dice work with random value
  * @param testDice {string}
  * @param allStats {Record<string,number>}
  */
-declare function evalStatsDice(testDice: string, allStats?: Record<string, number>): string;
+declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null): string;
 /**
  * Generate a random dice and remove the formula (+ evaluate it)
  * Used for diceDamage only
@@ -249,13 +258,13 @@ declare function evalStatsDice(testDice: string, allStats?: Record<string, numbe
  * @param template {StatisticalTemplate}
  * @returns
  */
-declare function diceRandomParse(value: string, template: StatisticalTemplate): string;
+declare function diceRandomParse(value: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Same as damageDice but for DiceType
  * @param dice {string}
  * @param template {StatisticalTemplate}
  */
-declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate): string;
+declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
  * Random the combinaison and evaluate it to check if everything is valid
  * @param combinaison {Record<string,string>}
@@ -274,17 +283,17 @@ declare function evalOneCombinaison(combinaison: string, stats: Record<string, n
  * @param {boolean} verify - If true, will roll the dices to check if everything is valid
  * @returns {StatisticalTemplate}
  */
-declare function verifyTemplateValue(template: unknown, verify?: boolean): StatisticalTemplate;
+declare function verifyTemplateValue(template: unknown, verify?: boolean, engine?: Engine | null): StatisticalTemplate;
 /**
  * Test each damage roll from the template.damage
  * @param {StatisticalTemplate} template
  */
-declare function testDiceRegistered(template: StatisticalTemplate): void;
+declare function testDiceRegistered(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Test all combinaison with generated random value
  * @param {StatisticalTemplate} template
  */
-declare function testStatCombinaison(template: StatisticalTemplate): void;
+declare function testStatCombinaison(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Generate a random stat based on the template and the statistical min and max
  * @param {number|undefined} total
@@ -292,7 +301,7 @@ declare function testStatCombinaison(template: StatisticalTemplate): void;
  * @param {number | undefined} min
  * @returns
  */
-declare function generateRandomStat(total?: number | undefined, max?: number, min?: number): number;
+declare function generateRandomStat(total?: number | undefined, max?: number, min?: number, engine?: Engine | null): number;
 
 declare class DiceTypeError extends Error {
     readonly dice: string;
@@ -384,4 +393,4 @@ interface StatisticalSchema extends StatisticalTemplate {
     $schema?: string;
 }
 
-export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, isNumber, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };
+export { COMMENT_REGEX, type Compare, type ComparedValue, type Critical, type CustomCritical, type CustomCriticalMap, DETECT_CRITICAL, DiceTypeError, EmptyObjectError, FormulaError, MaxGreater, type Modifier, NoStatisticsError, type Resultat, SIGN_REGEX, SIGN_REGEX_SPACE, SYMBOL_DICE, type Sign, type Statistic, type StatisticalSchema, type StatisticalTemplate, TooManyDice, TooManyStats, calculator, createCriticalCustom, diceRandomParse, diceTypeRandomParse, escapeRegex, evalCombinaison, evalOneCombinaison, evalStatsDice, generateRandomStat, generateStatsDice, getEngine, isNumber, randomInt, replaceExpByRandom, replaceFormulaInDice, roll, standardizeDice, templateSchema, testDiceRegistered, testStatCombinaison, verifyTemplateValue };

package/dist/index.js

@@ -42,7 +42,9 @@ __export(index_exports, {
   evalStatsDice: () => evalStatsDice,
   generateRandomStat: () => generateRandomStat,
   generateStatsDice: () => generateStatsDice,
+  getEngine: () => getEngine,
   isNumber: () => isNumber,
+  randomInt: () => randomInt,
   replaceExpByRandom: () => replaceExpByRandom,
   replaceFormulaInDice: () => replaceFormulaInDice,
   roll: () => roll,
@@ -55,12 +57,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/dice.ts
-var import_rpg_dice_roller = require("@dice-roller/rpg-dice-roller");
+var import_rpg_dice_roller2 = require("@dice-roller/rpg-dice-roller");
 var import_mathjs2 = require("mathjs");
 
 // src/utils.ts
 var import_mathjs = require("mathjs");
 var import_uniformize = require("uniformize");
+var import_rpg_dice_roller = require("@dice-roller/rpg-dice-roller");
+var import_random_js = require("random-js");
 function escapeRegex(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -108,16 +112,32 @@ function cleanedDice(dice) {
 function isNumber(value) {
   return value !== void 0 && (typeof value === "number" || !Number.isNaN(Number(value)) && typeof value === "string" && value.trim().length > 0);
 }
-function replaceExpByRandom(dice) {
+function replaceExpByRandom(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   const diceRegex = /\{exp( ?\|\| ?(?<default>\d+))?}/gi;
   return dice.replace(diceRegex, (_match, _p1, _p2, _offset, _string, groups) => {
     const defaultValue = groups?.default;
-    return defaultValue ?? (0, import_mathjs.randomInt)(1, 999).toString();
+    return defaultValue ?? randomInt(1, 999, engine).toString();
   });
 }
+function getEngine(engine) {
+  switch (engine) {
+    case "nativeMath":
+      return import_rpg_dice_roller.NumberGenerator.engines.nativeMath;
+    case "browserCrypto":
+      return import_rpg_dice_roller.NumberGenerator.engines.browserCrypto;
+    case "nodeCrypto":
+      return import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto;
+    default:
+      return import_rpg_dice_roller.NumberGenerator.engines.nativeMath;
+  }
+}
+function randomInt(min, max, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+  const rng = new import_random_js.Random(engine || void 0);
+  return rng.integer(min, max);
+}
 
 // src/dice.ts
-function getCompare(dice, compareRegex) {
+function getCompare(dice, compareRegex, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))[><=!]+\d+\}?)|\{(.*)([><=!]+).*\}/))
     return { dice, compare: void 0 };
   dice = dice.replace(SIGN_REGEX_SPACE, "");
@@ -127,7 +147,7 @@ function getCompare(dice, compareRegex) {
   const compareSign = compareRegex[0].match(SIGN_REGEX)?.[0];
   if (sign) {
     const toCalc = calc.replace(SIGN_REGEX, "").replace(/\s/g, "").replace(/;(.*)/, "");
-    const rCompare = rollCompare(toCalc);
+    const rCompare = rollCompare(toCalc, engine);
     const total = (0, import_mathjs2.evaluate)(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
@@ -137,7 +157,7 @@ function getCompare(dice, compareRegex) {
       rollValue: rCompare.diceResult
     };
   } else {
-    const rcompare = rollCompare(calc);
+    const rcompare = rollCompare(calc, engine);
     compare = {
       sign: compareSign,
       value: rcompare.value,
@@ -147,9 +167,9 @@ function getCompare(dice, compareRegex) {
   }
   return { dice, compare };
 }
-function rollCompare(value) {
+function rollCompare(value, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   if (isNumber(value)) return { value: Number.parseInt(value, 10) };
-  const rollComp = roll(value);
+  const rollComp = roll(value, engine);
   if (!rollComp?.total)
     return { value: (0, import_mathjs2.evaluate)(value), diceResult: value };
   return {
@@ -158,16 +178,16 @@ function rollCompare(value) {
     diceResult: rollComp?.result
   };
 }
-function createCriticalCustom(dice, customCritical, template) {
+function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let customDice = dice;
-  const compareValue = diceTypeRandomParse(customCritical.value, template);
+  const compareValue = diceTypeRandomParse(customCritical.value, template, engine);
   if (compareValue.includes("$"))
     throw new DiceTypeError(compareValue, "createCriticalCustom");
   const comparaison = `${customCritical.sign}${compareValue}`;
   if (compareRegex) customDice = customDice.replace(SIGN_REGEX_SPACE, comparaison);
   else customDice += comparaison;
-  return diceTypeRandomParse(customDice, template);
+  return diceTypeRandomParse(customDice, template, engine);
 }
 function getModifier(dice) {
   const modifier = dice.matchAll(/(\+|-|%|\/|\^|\*|\*{2})(\d+)/gi);
@@ -190,15 +210,15 @@ function getModifier(dice) {
   }
   return modificator;
 }
-function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+function roll(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   dice = standardizeDice(dice).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
   if (!dice.includes("d")) return void 0;
   dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let compare;
-  if (dice.includes(";")) return sharedRolls(dice);
+  if (dice.includes(";")) return sharedRolls(dice, engine);
   if (compareRegex) {
-    const compareResult = getCompare(dice, compareRegex);
+    const compareResult = getCompare(dice, compareRegex, engine);
     dice = compareResult.dice;
     compare = compareResult.compare;
   }
@@ -209,8 +229,8 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
     let diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
     const commentsMatch = diceArray[1].match(COMMENT_REGEX);
     const comments = commentsMatch ? commentsMatch[2] : void 0;
-    const roller2 = new import_rpg_dice_roller.DiceRoller();
-    import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
+    const roller2 = new import_rpg_dice_roller2.DiceRoller();
+    import_rpg_dice_roller2.NumberGenerator.generator.engine = engine;
     for (let i = 0; i < numberOfDice; i++) {
       try {
         roller2.roll(diceToRoll);
@@ -227,8 +247,8 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
       total: roller2.total
     };
   }
-  const roller = new import_rpg_dice_roller.DiceRoller();
-  import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
+  const roller = new import_rpg_dice_roller2.DiceRoller();
+  import_rpg_dice_roller2.NumberGenerator.generator.engine = engine;
   const diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
   try {
     roller.roll(diceWithoutComment);
@@ -268,7 +288,7 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function replaceInFormula(element, diceResult, compareResult, res) {
+function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   const { formule, diceAll } = replaceText(
     element,
     diceResult.total ?? 0,
@@ -281,24 +301,24 @@ function replaceInFormula(element, diceResult, compareResult, res) {
     evaluateRoll = (0, import_mathjs2.evaluate)(compareResult.dice);
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
   } catch (error) {
-    const evaluateRoll2 = roll(compareResult.dice);
+    const evaluateRoll2 = roll(compareResult.dice, engine);
     if (evaluateRoll2)
       return `${validSign} ${diceAll}: ${evaluateRoll2.result.split(":").splice(1).join(":")}`;
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
   }
 }
-function compareSignFormule(toRoll, compareRegex, element, diceResult) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   let results = "";
-  const compareResult = getCompare(toRoll, compareRegex);
+  const compareResult = getCompare(toRoll, compareRegex, engine);
   const toCompare = `${compareResult.dice}${compareResult.compare?.sign}${compareResult.compare?.value}`;
   let res;
   try {
     res = (0, import_mathjs2.evaluate)(toCompare);
   } catch (error) {
-    res = roll(toCompare);
+    res = roll(toCompare, engine);
   }
   if (typeof res === "boolean") {
-    results = replaceInFormula(element, diceResult, compareResult, res);
+    results = replaceInFormula(element, diceResult, compareResult, res, engine);
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
@@ -324,7 +344,7 @@ function formatComment(dice) {
   const commentsMatch = commentsRegex.exec(dice);
   return commentsMatch?.groups?.comments ? `__${commentsMatch.groups.comments}__ \u2014 ` : "";
 }
-function sharedRolls(dice) {
+function sharedRolls(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
   if (dice.match(/\d+?#(.*?)/))
     throw new DiceTypeError(
       dice,
@@ -348,7 +368,7 @@ function sharedRolls(dice) {
   const commentsRegex = /\[(?<comments>.*?)\]/gi;
   const comments = formatComment(diceMain);
   diceMain = diceMain.replaceAll(commentsRegex, "").trim();
-  const diceResult = roll(diceMain);
+  const diceResult = roll(diceMain, engine);
   if (!diceResult || !diceResult.total) return void 0;
   results.push(`\u203B ${comments}${diceResult.result}`);
   let total = diceResult.total;
@@ -360,7 +380,7 @@ function sharedRolls(dice) {
     let toRoll = element.replace(SYMBOL_DICE, `${diceResult.total}`);
     const compareRegex = toRoll.match(SIGN_REGEX_SPACE);
     if (compareRegex) {
-      const compareResult = compareSignFormule(toRoll, compareRegex, element, diceResult);
+      const compareResult = compareSignFormule(toRoll, compareRegex, element, diceResult, engine);
       toRoll = compareResult.dice;
       results.push(compareResult.results);
     } else {
@@ -374,7 +394,7 @@ function sharedRolls(dice) {
         results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
         total += Number.parseInt(evaluated, 10);
       } catch (error) {
-        const evaluated = roll(toRoll);
+        const evaluated = roll(toRoll, engine);
         if (evaluated)
           results.push(
             `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
@@ -398,9 +418,10 @@ function sharedRolls(dice) {
 
 // src/verify_template.ts
 var import_mathjs3 = require("mathjs");
-var import_random_js = require("random-js");
+var import_random_js2 = require("random-js");
 var import_uniformize2 = require("uniformize");
-function evalStatsDice(testDice, allStats) {
+var import_rpg_dice_roller3 = require("@dice-roller/rpg-dice-roller");
+function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
     const names = Object.keys(allStats);
@@ -413,14 +434,14 @@ function evalStatsDice(testDice, allStats) {
     }
   }
   try {
-    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice))))
+    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine))
       throw new DiceTypeError(dice, "evalStatsDice", "no roll result");
     return testDice;
   } catch (error) {
     throw new DiceTypeError(dice, "evalStatsDice", error);
   }
 }
-function diceRandomParse(value, template) {
+function diceRandomParse(value, template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   if (!template.statistics) return replaceFormulaInDice(value.standardize());
   value = value.standardize();
   const statNames = Object.keys(template.statistics);
@@ -436,13 +457,13 @@ function diceRandomParse(value, template) {
         min = foundStat.min;
       }
       const total = template.total || 100;
-      const randomStatValue = generateRandomStat(total, max, min);
+      const randomStatValue = generateRandomStat(total, max, min, engine);
       newDice = value.replace(regex, randomStatValue.toString());
     }
   }
   return replaceFormulaInDice(newDice);
 }
-function diceTypeRandomParse(dice, template) {
+function diceTypeRandomParse(dice, template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   dice = replaceExpByRandom(dice);
   if (!template.statistics) return dice;
   const firstStatNotcombinaison = Object.keys(template.statistics).find(
@@ -452,7 +473,7 @@ function diceTypeRandomParse(dice, template) {
   const stats = template.statistics[firstStatNotcombinaison];
   const { min, max } = stats;
   const total = template.total || 100;
-  const randomStatValue = generateRandomStat(total, max, min);
+  const randomStatValue = generateRandomStat(total, max, min, engine);
   return replaceFormulaInDice(dice.replaceAll("$", randomStatValue.toString()));
 }
 function evalCombinaison(combinaison, stats) {
@@ -489,7 +510,7 @@ function convertNumber(number) {
   if (isNumber(number)) return Number.parseInt(number.toString(), 10);
   return void 0;
 }
-function verifyTemplateValue(template, verify = true) {
+function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   const parsedTemplate = templateSchema.parse(template);
   const { success, failure } = parsedTemplate.critical ?? {};
   const criticicalVal = {
@@ -517,9 +538,10 @@ function verifyTemplateValue(template, verify = true) {
     }
     const cleanedDice2 = diceTypeRandomParse(
       statistiqueTemplate.diceType,
-      statistiqueTemplate
+      statistiqueTemplate,
+      engine
     );
-    const rolled = roll(cleanedDice2);
+    const rolled = roll(cleanedDice2, engine);
     if (!rolled)
       throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
   }
@@ -532,34 +554,35 @@ function verifyTemplateValue(template, verify = true) {
       const cleanedDice2 = createCriticalCustom(
         statistiqueTemplate.diceType,
         custom,
-        statistiqueTemplate
+        statistiqueTemplate,
+        engine
       );
-      const rolled = roll(cleanedDice2);
+      const rolled = roll(cleanedDice2, engine);
       if (!rolled)
         throw new DiceTypeError(cleanedDice2, "verifyTemplateValue", "no roll result");
     }
   }
-  testDiceRegistered(statistiqueTemplate);
-  testStatCombinaison(statistiqueTemplate);
+  testDiceRegistered(statistiqueTemplate, engine);
+  testStatCombinaison(statistiqueTemplate, engine);
   return statistiqueTemplate;
 }
-function testDiceRegistered(template) {
+function testDiceRegistered(template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   if (!template.damage) return;
   if (Object.keys(template.damage).length === 0) throw new EmptyObjectError();
   if (Object.keys(template.damage).length > 25) throw new TooManyDice();
   for (const [name, dice] of Object.entries(template.damage)) {
     if (!dice) continue;
     const diceReplaced = replaceExpByRandom(dice);
-    const randomDiceParsed = diceRandomParse(diceReplaced, template);
+    const randomDiceParsed = diceRandomParse(diceReplaced, template, engine);
     try {
-      const rolled = roll(randomDiceParsed);
+      const rolled = roll(randomDiceParsed, engine);
       if (!rolled) throw new DiceTypeError(name, "no_roll_result", dice);
     } catch (error) {
       throw new DiceTypeError(name, "testDiceRegistered", error);
     }
   }
 }
-function testStatCombinaison(template) {
+function testStatCombinaison(template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   if (!template.statistics) return;
   const onlycombinaisonStats = Object.fromEntries(
     Object.entries(template.statistics).filter(
@@ -580,7 +603,7 @@ function testStatCombinaison(template) {
     for (const [other, data] of Object.entries(allOtherStats)) {
       const { max, min } = data;
       const total = template.total || 100;
-      const randomStatValue = generateRandomStat(total, max, min);
+      const randomStatValue = generateRandomStat(total, max, min, engine);
       const regex = new RegExp(other, "gi");
       formula = formula.replace(regex, randomStatValue.toString());
     }
@@ -593,10 +616,10 @@ function testStatCombinaison(template) {
   if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
   return;
 }
-function generateRandomStat(total = 100, max, min) {
+function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   let randomStatValue = total + 1;
   while (randomStatValue >= total || randomStatValue === 0) {
-    const random2 = new import_random_js.Random();
+    const random2 = new import_random_js2.Random(engine || void 0);
     if (max && min) randomStatValue = random2.integer(min, max);
     else if (max) randomStatValue = random2.integer(1, max);
     else if (min) randomStatValue = random2.integer(min, total);
@@ -754,7 +777,9 @@ var templateSchema = import_zod.z.object({
   evalStatsDice,
   generateRandomStat,
   generateStatsDice,
+  getEngine,
   isNumber,
+  randomInt,
   replaceExpByRandom,
   replaceFormulaInDice,
   roll,