@dicelette/core 1.20.0 → 1.20.1

package/dist/index.js

@@ -43,6 +43,7 @@ __export(index_exports, {
   generateRandomStat: () => generateRandomStat,
   generateStatsDice: () => generateStatsDice,
   getEngine: () => getEngine,
+  getEngineId: () => getEngineId2,
   isNumber: () => isNumber,
   randomInt: () => randomInt,
   replaceExpByRandom: () => replaceExpByRandom,
@@ -57,98 +58,20 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/dice.ts
-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, "\\$&");
-}
-function standardizeDice(dice) {
-  return dice.replace(
-    /(\[[^\]]+\])|([^[]+)/g,
-    (match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize()
-  );
-}
-function generateStatsDice(originalDice, stats, dollarValue) {
-  let dice = originalDice.standardize();
-  if (stats && Object.keys(stats).length > 0) {
-    const allStats = Object.keys(stats);
-    for (const stat of allStats) {
-      const regex = new RegExp(`(?!\\[)${escapeRegex(stat.standardize())}(?!\\])`, "gi");
-      if (dice.match(regex)) {
-        const statValue = stats[stat];
-        dice = dice.replace(regex, statValue.toString());
-      }
-    }
-  }
-  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
-  return replaceFormulaInDice(dice);
-}
-function replaceFormulaInDice(dice) {
-  const formula = /(?<formula>\{{2}(.+?)}{2})/gim;
-  let match;
-  let modifiedDice = dice;
-  while ((match = formula.exec(dice)) !== null) {
-    if (match.groups?.formula) {
-      const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
-      try {
-        const result = (0, import_mathjs.evaluate)(formulae);
-        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
-      } catch (error) {
-        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
-      }
-    }
-  }
-  return cleanedDice(modifiedDice);
-}
-function cleanedDice(dice) {
-  return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+").replaceAll("=>", ">=").replaceAll("=<", "<=").trimEnd();
-}
-function isNumber(value) {
-  return value !== void 0 && (typeof value === "number" || !Number.isNaN(Number(value)) && typeof value === "string" && value.trim().length > 0);
-}
-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 ?? 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, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+var import_mathjs = require("mathjs");
+function getCompare(dice, compareRegex, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))[><=!]+\d+\}?)|\{(.*)([><=!]+).*\}/))
     return { dice, compare: void 0 };
   dice = dice.replace(SIGN_REGEX_SPACE, "");
   let compare;
   const calc = compareRegex[1];
-  const sign = calc.match(/[+-\/*^]/)?.[0];
+  const sign = calc.match(/[+-/*^]/)?.[0];
   const compareSign = compareRegex[0].match(SIGN_REGEX)?.[0];
   if (sign) {
     const toCalc = calc.replace(SIGN_REGEX, "").replace(/\s/g, "").replace(/;(.*)/, "");
     const rCompare = rollCompare(toCalc, engine);
-    const total = (0, import_mathjs2.evaluate)(rCompare.value.toString());
+    const total = (0, import_mathjs.evaluate)(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
       sign: compareSign,
@@ -167,18 +90,18 @@ function getCompare(dice, compareRegex, engine = import_rpg_dice_roller2.NumberG
   }
   return { dice, compare };
 }
-function rollCompare(value, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function rollCompare(value, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   if (isNumber(value)) return { value: Number.parseInt(value, 10) };
   const rollComp = roll(value, engine);
   if (!rollComp?.total)
-    return { value: (0, import_mathjs2.evaluate)(value), diceResult: value };
+    return { value: (0, import_mathjs.evaluate)(value), diceResult: value };
   return {
     dice: value,
     value: rollComp.total,
     diceResult: rollComp?.result
   };
 }
-function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let customDice = dice;
   const compareValue = diceTypeRandomParse(customCritical.value, template, engine);
@@ -210,7 +133,7 @@ function getModifier(dice) {
   }
   return modificator;
 }
-function roll(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   dice = standardizeDice(dice).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
   if (!dice.includes("d")) return void 0;
   dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
@@ -226,11 +149,11 @@ function roll(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nod
   if (dice.match(/\d+?#(.*)/)) {
     const diceArray = dice.split("#");
     const numberOfDice = Number.parseInt(diceArray[0], 10);
-    let diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
+    const 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_roller2.DiceRoller();
-    import_rpg_dice_roller2.NumberGenerator.generator.engine = engine;
+    const roller2 = new import_rpg_dice_roller.DiceRoller();
+    import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
     for (let i = 0; i < numberOfDice; i++) {
       try {
         roller2.roll(diceToRoll);
@@ -247,8 +170,8 @@ function roll(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nod
       total: roller2.total
     };
   }
-  const roller = new import_rpg_dice_roller2.DiceRoller();
-  import_rpg_dice_roller2.NumberGenerator.generator.engine = engine;
+  const roller = new import_rpg_dice_roller.DiceRoller();
+  import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
   const diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
   try {
     roller.roll(diceWithoutComment);
@@ -268,7 +191,7 @@ function roll(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nod
 }
 function calculator(sign, value, total) {
   if (sign === "^") sign = "**";
-  return (0, import_mathjs2.evaluate)(`${total} ${sign} ${value}`);
+  return (0, import_mathjs.evaluate)(`${total} ${sign} ${value}`);
 }
 function inverseSign(sign) {
   switch (sign) {
@@ -288,7 +211,7 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   const { formule, diceAll } = replaceText(
     element,
     diceResult.total ?? 0,
@@ -298,7 +221,7 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = impo
   const invertedSign = res ? compareResult.compare.sign : inverseSign(compareResult.compare.sign);
   let evaluateRoll;
   try {
-    evaluateRoll = (0, import_mathjs2.evaluate)(compareResult.dice);
+    evaluateRoll = (0, import_mathjs.evaluate)(compareResult.dice);
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
   } catch (error) {
     const evaluateRoll2 = roll(compareResult.dice, engine);
@@ -307,13 +230,13 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = impo
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
   }
 }
-function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   let results = "";
   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);
+    res = (0, import_mathjs.evaluate)(toCompare);
   } catch (error) {
     res = roll(toCompare, engine);
   }
@@ -322,7 +245,7 @@ function compareSignFormule(toRoll, compareRegex, element, diceResult, engine =
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
-      const toEvaluate = (0, import_mathjs2.evaluate)(
+      const toEvaluate = (0, import_mathjs.evaluate)(
         `${diceResult2.total}${diceResult2.compare.sign}${diceResult2.compare.value}`
       );
       const sign = toEvaluate ? "\u2713" : "\u2715";
@@ -344,7 +267,7 @@ function formatComment(dice) {
   const commentsMatch = commentsRegex.exec(dice);
   return commentsMatch?.groups?.comments ? `__${commentsMatch.groups.comments}__ \u2014 ` : "";
 }
-function sharedRolls(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
   if (dice.match(/\d+?#(.*?)/))
     throw new DiceTypeError(
       dice,
@@ -380,7 +303,13 @@ function sharedRolls(dice, engine = import_rpg_dice_roller2.NumberGenerator.engi
     let toRoll = element.replace(SYMBOL_DICE, `${diceResult.total}`);
     const compareRegex = toRoll.match(SIGN_REGEX_SPACE);
     if (compareRegex) {
-      const compareResult = compareSignFormule(toRoll, compareRegex, element, diceResult, engine);
+      const compareResult = compareSignFormule(
+        toRoll,
+        compareRegex,
+        element,
+        diceResult,
+        engine
+      );
       toRoll = compareResult.dice;
       results.push(compareResult.results);
     } else {
@@ -390,7 +319,7 @@ function sharedRolls(dice, engine = import_rpg_dice_roller2.NumberGenerator.engi
         diceResult.dice
       );
       try {
-        const evaluated = (0, import_mathjs2.evaluate)(toRoll);
+        const evaluated = (0, import_mathjs.evaluate)(toRoll);
         results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
         total += Number.parseInt(evaluated, 10);
       } catch (error) {
@@ -416,6 +345,222 @@ function sharedRolls(dice, engine = import_rpg_dice_roller2.NumberGenerator.engi
   };
 }
 
+// src/errors.ts
+var DiceTypeError = class extends Error {
+  dice;
+  cause;
+  method;
+  constructor(dice, cause, method) {
+    super(dice);
+    this.name = "Invalid_Dice_Type";
+    this.dice = dice;
+    this.cause = cause;
+    this.method = method;
+  }
+};
+var FormulaError = class extends Error {
+  formula;
+  cause;
+  method;
+  constructor(formula, cause, method) {
+    super(formula);
+    this.name = "Invalid_Formula";
+    this.formula = formula;
+    this.cause = cause;
+    this.method = method;
+  }
+};
+var MaxGreater = class extends Error {
+  name;
+  value;
+  max;
+  constructor(value, max) {
+    super(value.toString());
+    this.name = "Max_Greater";
+    this.value = value;
+    this.max = max;
+  }
+};
+var EmptyObjectError = class extends Error {
+  name;
+  constructor() {
+    super();
+    this.name = "Empty_Object";
+  }
+};
+var TooManyDice = class extends Error {
+  name;
+  constructor() {
+    super();
+    this.name = "Too_Many_Dice";
+  }
+};
+var TooManyStats = class extends Error {
+  name;
+  constructor() {
+    super();
+    this.name = "Too_Many_Stats";
+  }
+};
+var NoStatisticsError = class extends Error {
+  name;
+  constructor() {
+    super();
+    this.name = "No_Statistics";
+  }
+};
+
+// src/interfaces/constant.ts
+var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/;
+var SIGN_REGEX = /[><=!]+/;
+var SIGN_REGEX_SPACE = /[><=!]+(\S+)/;
+var SYMBOL_DICE = "&";
+var DETECT_CRITICAL = /\{\*?c[fs]:[<>=!]+(.+?)}/gim;
+
+// src/interfaces/zod.ts
+var import_zod = require("zod");
+var statisticValueSchema = import_zod.z.object({
+  max: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
+  min: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
+  combinaison: import_zod.z.string().transform((str) => str.trim() || void 0).optional(),
+  exclude: import_zod.z.boolean().optional()
+}).superRefine((data, ctx) => {
+  if (data.max !== void 0 && data.min !== void 0 && data.max <= data.min) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Max_Greater; ${data.min}; ${data.max}`,
+      path: ["max"]
+    });
+  }
+});
+var statisticSchema = import_zod.z.record(import_zod.z.string(), statisticValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
+  message: "TooManyStats"
+});
+var criticalSchema = import_zod.z.object({
+  success: import_zod.z.string().or(import_zod.z.number().min(0)).optional(),
+  failure: import_zod.z.string().or(import_zod.z.number().min(0)).optional()
+}).transform((values) => {
+  if (values.success === "") values.success = void 0;
+  if (values.failure === "") values.failure = void 0;
+  if (values.failure === 0) values.failure = void 0;
+  if (values.success === 0) values.success = void 0;
+  values.success = Number.parseInt(values.success, 10);
+  values.failure = Number.parseInt(values.failure, 10);
+  return values;
+});
+var criticalValueSchema = import_zod.z.object({
+  sign: import_zod.z.enum(["<", ">", "<=", ">=", "!=", "=="]),
+  value: import_zod.z.string(),
+  onNaturalDice: import_zod.z.boolean().optional(),
+  affectSkill: import_zod.z.boolean().optional()
+});
+var damageSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
+  message: "TooManyDice"
+});
+var customCriticalSchema = import_zod.z.record(import_zod.z.string(), criticalValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 22, {
+  message: "TooManyDice"
+});
+var templateSchema = import_zod.z.object({
+  charName: import_zod.z.boolean().optional(),
+  statistics: statisticSchema,
+  total: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
+  forceDistrib: import_zod.z.boolean().optional(),
+  diceType: import_zod.z.string().optional(),
+  critical: criticalSchema.optional(),
+  customCritical: customCriticalSchema,
+  damage: damageSchema
+});
+
+// src/utils.ts
+var import_mathjs2 = require("mathjs");
+var import_uniformize = require("uniformize");
+var import_rpg_dice_roller2 = require("@dice-roller/rpg-dice-roller");
+var import_random_js = require("random-js");
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function standardizeDice(dice) {
+  return dice.replace(
+    /(\[[^\]]+\])|([^[]+)/g,
+    (_match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize()
+  );
+}
+function generateStatsDice(originalDice, stats, dollarValue) {
+  let dice = originalDice.standardize();
+  if (stats && Object.keys(stats).length > 0) {
+    const allStats = Object.keys(stats);
+    for (const stat of allStats) {
+      const regex = new RegExp(`(?!\\[)${escapeRegex(stat.standardize())}(?!\\])`, "gi");
+      if (dice.match(regex)) {
+        const statValue = stats[stat];
+        dice = dice.replace(regex, statValue.toString());
+      }
+    }
+  }
+  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
+  return replaceFormulaInDice(dice);
+}
+function replaceFormulaInDice(dice) {
+  const formula = /(?<formula>\{{2}(.+?)}{2})/gim;
+  let match;
+  let modifiedDice = dice;
+  while ((match = formula.exec(dice)) !== null) {
+    if (match.groups?.formula) {
+      const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
+      try {
+        const result = (0, import_mathjs2.evaluate)(formulae);
+        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
+      } catch (error) {
+        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
+      }
+    }
+  }
+  return cleanedDice(modifiedDice);
+}
+function cleanedDice(dice) {
+  return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+").replaceAll("=>", ">=").replaceAll("=<", "<=").trimEnd();
+}
+function isNumber(value) {
+  return value !== void 0 && (typeof value === "number" || !Number.isNaN(Number(value)) && typeof value === "string" && value.trim().length > 0);
+}
+function replaceExpByRandom(dice, engine = import_rpg_dice_roller2.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 ?? randomInt(1, 999, engine).toString();
+  });
+}
+function randomInt(min, max, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto, rng) {
+  if (!rng) rng = new import_random_js.Random(engine || void 0);
+  return rng.integer(min, max);
+}
+function getEngineId2(engine) {
+  if (engine === import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) return "nodeCrypto";
+  if (engine === import_rpg_dice_roller2.NumberGenerator.engines.nativeMath) return "nativeMath";
+  if (engine === import_rpg_dice_roller2.NumberGenerator.engines.browserCrypto) return "browserCrypto";
+  try {
+    const e = engine;
+    if (e && typeof e === "object") {
+      if (typeof e.name === "string" && e.name) return e.name;
+      if (e.constructor?.name) return e.constructor.name;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function getEngine(engine) {
+  switch (engine) {
+    case "nativeMath":
+      return import_rpg_dice_roller2.NumberGenerator.engines.nativeMath;
+    case "browserCrypto":
+      return import_rpg_dice_roller2.NumberGenerator.engines.browserCrypto;
+    case "nodeCrypto":
+      return import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto;
+    default:
+      return import_rpg_dice_roller2.NumberGenerator.engines.nativeMath;
+  }
+}
+
 // src/verify_template.ts
 var import_mathjs3 = require("mathjs");
 var import_random_js2 = require("random-js");
@@ -449,8 +594,8 @@ function diceRandomParse(value, template, engine = import_rpg_dice_roller3.Numbe
   for (const name of statNames) {
     const regex = new RegExp(escapeRegex(name.standardize()), "gi");
     if (value.match(regex)) {
-      let max = void 0;
-      let min = void 0;
+      let max;
+      let min;
       const foundStat = template.statistics?.[name];
       if (foundStat) {
         max = foundStat.max;
@@ -542,8 +687,7 @@ function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_r
       engine
     );
     const rolled = roll(cleanedDice2, engine);
-    if (!rolled)
-      throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
+    if (!rolled) throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
   }
   if (statistiqueTemplate.customCritical) {
     if (!statistiqueTemplate.diceType) {
@@ -618,141 +762,15 @@ function testStatCombinaison(template, engine = import_rpg_dice_roller3.NumberGe
 }
 function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   let randomStatValue = total + 1;
+  const random = new import_random_js2.Random(engine || import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto);
   while (randomStatValue >= total || randomStatValue === 0) {
-    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);
-    else randomStatValue = random2.integer(1, total);
+    if (max && min) randomStatValue = randomInt(min, max, engine, random);
+    else if (max) randomStatValue = randomInt(1, max, engine, random);
+    else if (min) randomStatValue = randomInt(min, total, engine, random);
+    else randomStatValue = randomInt(1, total, engine, random);
   }
   return randomStatValue;
 }
-
-// src/errors.ts
-var DiceTypeError = class extends Error {
-  dice;
-  cause;
-  method;
-  constructor(dice, cause, method) {
-    super(dice);
-    this.name = "Invalid_Dice_Type";
-    this.dice = dice;
-    this.cause = cause;
-    this.method = method;
-  }
-};
-var FormulaError = class extends Error {
-  formula;
-  cause;
-  method;
-  constructor(formula, cause, method) {
-    super(formula);
-    this.name = "Invalid_Formula";
-    this.formula = formula;
-    this.cause = cause;
-    this.method = method;
-  }
-};
-var MaxGreater = class extends Error {
-  name;
-  value;
-  max;
-  constructor(value, max) {
-    super(value.toString());
-    this.name = "Max_Greater";
-    this.value = value;
-    this.max = max;
-  }
-};
-var EmptyObjectError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Empty_Object";
-  }
-};
-var TooManyDice = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Dice";
-  }
-};
-var TooManyStats = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Stats";
-  }
-};
-var NoStatisticsError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "No_Statistics";
-  }
-};
-
-// src/interfaces/constant.ts
-var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/;
-var SIGN_REGEX = /[><=!]+/;
-var SIGN_REGEX_SPACE = /[><=!]+(\S+)/;
-var SYMBOL_DICE = "&";
-var DETECT_CRITICAL = /\{\*?c[fs]:[<>=!]+(.+?)}/gim;
-
-// src/interfaces/zod.ts
-var import_zod = require("zod");
-var statisticValueSchema = import_zod.z.object({
-  max: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
-  min: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
-  combinaison: import_zod.z.string().transform((str) => str.trim() || void 0).optional(),
-  exclude: import_zod.z.boolean().optional()
-}).superRefine((data, ctx) => {
-  if (data.max !== void 0 && data.min !== void 0 && data.max <= data.min) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Max_Greater; ${data.min}; ${data.max}`,
-      path: ["max"]
-    });
-  }
-});
-var statisticSchema = import_zod.z.record(import_zod.z.string(), statisticValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
-  message: "TooManyStats"
-});
-var criticalSchema = import_zod.z.object({
-  success: import_zod.z.string().or(import_zod.z.number().min(0)).optional(),
-  failure: import_zod.z.string().or(import_zod.z.number().min(0)).optional()
-}).transform((values) => {
-  if (values.success === "") values.success = void 0;
-  if (values.failure === "") values.failure = void 0;
-  if (values.failure === 0) values.failure = void 0;
-  if (values.success === 0) values.success = void 0;
-  values.success = Number.parseInt(values.success, 10);
-  values.failure = Number.parseInt(values.failure, 10);
-  return values;
-});
-var criticalValueSchema = import_zod.z.object({
-  sign: import_zod.z.enum(["<", ">", "<=", ">=", "!=", "=="]),
-  value: import_zod.z.string(),
-  onNaturalDice: import_zod.z.boolean().optional(),
-  affectSkill: import_zod.z.boolean().optional()
-});
-var damageSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
-  message: "TooManyDice"
-});
-var customCriticalSchema = import_zod.z.record(import_zod.z.string(), criticalValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 22, {
-  message: "TooManyDice"
-});
-var templateSchema = import_zod.z.object({
-  charName: import_zod.z.boolean().optional(),
-  statistics: statisticSchema,
-  total: import_zod.z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
-  forceDistrib: import_zod.z.boolean().optional(),
-  diceType: import_zod.z.string().optional(),
-  critical: criticalSchema.optional(),
-  customCritical: customCriticalSchema,
-  damage: damageSchema
-});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   COMMENT_REGEX,
@@ -778,6 +796,7 @@ var templateSchema = import_zod.z.object({
   generateRandomStat,
   generateStatsDice,
   getEngine,
+  getEngineId,
   isNumber,
   randomInt,
   replaceExpByRandom,