@dicelette/core 1.24.0 → 1.24.2

package/dist/index.mjs

@@ -1,13 +1,104 @@
-// src/dice/calculator.ts
-import { evaluate } from "mathjs";
-function calculator(sign, value, total) {
-  if (sign === "^") sign = "**";
-  return evaluate(`${total} ${sign} ${value}`);
+// src/engine.ts
+import { NumberGenerator } from "@dice-roller/rpg-dice-roller";
+function getEngineId(engine) {
+  if (engine === NumberGenerator.engines.nodeCrypto) return "nodeCrypto";
+  if (engine === NumberGenerator.engines.nativeMath) return "nativeMath";
+  if (engine === 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 NumberGenerator.engines.nativeMath;
+    case "browserCrypto":
+      return NumberGenerator.engines.browserCrypto;
+    case "nodeCrypto":
+      return NumberGenerator.engines.nodeCrypto;
+    default:
+      return NumberGenerator.engines.nativeMath;
+  }
 }
 
-// src/dice/compare.ts
-import { NumberGenerator as NumberGenerator2 } from "@dice-roller/rpg-dice-roller";
-import { evaluate as evaluate3 } from "mathjs";
+// 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/index.ts
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["Ascending"] = "sa";
+  SortOrder2["Descending"] = "sd";
+  SortOrder2["None"] = "none";
+  return SortOrder2;
+})(SortOrder || {});
 
 // src/interfaces/constant.ts
 var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/gi;
@@ -17,418 +108,231 @@ var SYMBOL_DICE = "&";
 var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
 var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
 
+// src/interfaces/zod.ts
+import { z } from "zod";
+var statisticValueSchema = z.object({
+  max: z.number().transform((val) => val === 0 ? void 0 : val).optional(),
+  min: z.number().transform(
+    (val) => Number.isNaN(Number.parseInt(val, 10)) ? void 0 : val
+  ).optional(),
+  combinaison: z.string().transform((str) => str.trim() || void 0).optional(),
+  exclude: 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 = z.record(z.string(), statisticValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
+  message: "TooManyStats"
+});
+var criticalSchema = z.object({
+  success: z.string().or(z.number().min(0)).optional(),
+  failure: z.string().or(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 = z.object({
+  sign: z.enum(["<", ">", "<=", ">=", "!=", "=="]),
+  value: z.string(),
+  onNaturalDice: z.boolean().optional(),
+  affectSkill: z.boolean().optional()
+});
+var damageSchema = z.record(z.string(), z.string()).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
+  message: "TooManyDice"
+});
+var customCriticalSchema = z.record(z.string(), criticalValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 22, {
+  message: "TooManyDice"
+});
+var templateSchema = z.object({
+  charName: z.boolean().optional(),
+  statistics: statisticSchema,
+  total: z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
+  forceDistrib: z.boolean().optional(),
+  diceType: z.string().optional(),
+  critical: criticalSchema.optional(),
+  customCritical: customCriticalSchema,
+  damage: damageSchema
+});
+
 // src/roll.ts
-import { DiceRoller, NumberGenerator } from "@dice-roller/rpg-dice-roller";
+import { DiceRoller as DiceRoller3, NumberGenerator as NumberGenerator7 } from "@dice-roller/rpg-dice-roller";
+import { evaluate as evaluate8 } from "mathjs";
+
+// src/dice/bulk.ts
+import { DiceRoller as DiceRoller2, NumberGenerator as NumberGenerator6 } from "@dice-roller/rpg-dice-roller";
+import { evaluate as evaluate6 } from "mathjs";
+
+// src/dice/compare.ts
+import { NumberGenerator as NumberGenerator3 } from "@dice-roller/rpg-dice-roller";
 import { evaluate as evaluate2 } from "mathjs";
-function roll(dice, engine = NumberGenerator.engines.nodeCrypto, pity, sort) {
-  if (sort === "none" /* None */) sort = void 0;
-  dice = standardizeDice(replaceFormulaInDice(dice)).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
-  if (!dice.includes("d")) return void 0;
-  dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
-  const explodingSuccess = normalizeExplodingSuccess(dice);
-  if (explodingSuccess) dice = explodingSuccess.dice;
-  let diceDisplay;
-  if (dice.includes(";")) {
-    const mainDice = dice.split(";")[0];
-    diceDisplay = explodingSuccess?.originalDice ?? mainDice;
-  } else diceDisplay = explodingSuccess?.originalDice ?? dice;
-  const curlyBulkMatch = dice.match(/^\{(\d+#.*)\}$/);
-  const isCurlyBulk = !!curlyBulkMatch;
-  let bulkContent = "";
-  if (isCurlyBulk) bulkContent = curlyBulkMatch[1];
-  const compareRegex = dice.match(SIGN_REGEX_SPACE);
-  let compare;
-  if (dice.includes(";"))
-    return sharedRolls(dice, engine, pity, explodingSuccess, diceDisplay);
-  dice = fixParenthesis(dice);
-  const modificator = getModifier(dice);
-  if (compareRegex && !isCurlyBulk) {
-    const compareResult = getCompare(dice, compareRegex, engine, pity);
-    dice = compareResult.dice;
-    compare = compareResult.compare;
-  }
-  const bulkProcessContent = isCurlyBulk ? bulkContent : dice;
-  if (bulkProcessContent.match(/\d+?#(.*)/)) {
-    const diceArray = bulkProcessContent.split("#");
-    const numberOfDice = Number.parseInt(diceArray[0], 10);
-    let diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
-    const commentsMatch = diceArray[1].match(COMMENT_REGEX);
-    const comments = commentsMatch ? commentsMatch[2] : void 0;
-    let curlyCompare;
-    if (isCurlyBulk) {
-      const curlyCompareRegex = diceToRoll.match(SIGN_REGEX_SPACE);
-      if (curlyCompareRegex) {
-        const compareSign = curlyCompareRegex[0].match(SIGN_REGEX)?.[0];
-        const compareValue = curlyCompareRegex[2];
-        if (compareSign && compareValue) {
-          curlyCompare = {
-            sign: compareSign,
-            value: Number.parseInt(compareValue, 10)
-          };
-          diceToRoll = diceToRoll.replace(SIGN_REGEX_SPACE, "");
-        }
+
+// src/utils.ts
+import { evaluate } from "mathjs";
+import "uniformize";
+import { NumberGenerator as NumberGenerator2 } from "@dice-roller/rpg-dice-roller";
+import { Random } from "random-js";
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function standardizeDice(dice) {
+  return dice.replace(
+    /(\[[^\]]+])|([^[]+)/g,
+    (_match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize().replaceAll("df", "dF")
+  );
+}
+function generateStatsDice(originalDice, stats, dollarValue) {
+  let dice = originalDice.standardize();
+  if (stats && Object.keys(stats).length > 0) {
+    const statKeys = Object.keys(stats);
+    const partsRegex = /(\[[^\]]+])|([^[]+)/g;
+    let result = "";
+    let match;
+    while ((match = partsRegex.exec(dice)) !== null) {
+      const insideBrackets = match[1];
+      const outsideText = match[2];
+      if (insideBrackets) {
+        result += insideBrackets;
+        continue;
       }
-    }
-    if (sort) diceToRoll = `${diceToRoll}${sort}`;
-    const activeCompare = compare || curlyCompare || (explodingSuccess ? { sign: explodingSuccess.sign, value: explodingSuccess.value } : void 0);
-    let trivialComparisonDetected = false;
-    if (activeCompare) {
-      const results = [];
-      let successCount = 0;
-      const roller3 = new DiceRoller();
-      NumberGenerator.generator.engine = engine;
-      const formatOutput = (output, addStar) => {
-        const formatted = addStar && isCurlyBulk ? output.replace(
-          /\[([^\]]+)\]/,
-          (_m, content) => `[${content.split(",").map((d) => `${d.trim()}*`).join(", ")}]`
-        ) : output;
-        return curlyCompare ? formatted.replace(/^([^:]+):/, `$1${curlyCompare.sign}${curlyCompare.value}:`) : formatted;
-      };
-      for (let i = 0; i < numberOfDice; i++) {
-        try {
-          const individualRoll = roller3.roll(diceToRoll);
-          const rollInstance = Array.isArray(individualRoll) ? individualRoll[0] : individualRoll;
-          if (!trivialComparisonDetected && activeCompare) {
-            const { maxTotal, minTotal } = rollInstance;
-            trivialComparisonDetected = isTrivialComparison(
-              maxTotal,
-              minTotal,
-              activeCompare
-            );
+      if (!outsideText) {
+        continue;
+      }
+      const tokenRegex = /(\$?[\p{L}\p{N}_]+)/gu;
+      let lastIndex = 0;
+      let tokenMatch;
+      while ((tokenMatch = tokenRegex.exec(outsideText)) !== null) {
+        result += outsideText.slice(lastIndex, tokenMatch.index);
+        const token = tokenMatch[0];
+        const tokenStd = token.standardize();
+        const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
+        if (diceMatch) {
+          const diceCount = diceMatch[1] || "";
+          const afterD = diceMatch[2];
+          let foundStatAfterD = false;
+          for (const key of statKeys) {
+            const keyStd = key.standardize();
+            if (afterD === keyStd) {
+              result += `${diceCount}d${stats[key].toString()}`;
+              foundStatAfterD = true;
+              break;
+            }
           }
-          const rollOutput = rollInstance.output;
-          if (explodingSuccess) {
-            const successesForRoll = countExplodingSuccesses(
-              rollInstance,
-              explodingSuccess.sign,
-              explodingSuccess.value
-            );
-            successCount += successesForRoll;
-            let formattedRollOutput = rollOutput.replace(
-              explodingSuccess.normalizedSegment,
-              explodingSuccess.originalSegment
-            ).replace(/=\s*-?\d+(?:\.\d+)?$/, `= ${successesForRoll}`);
-            formattedRollOutput = formatOutput(formattedRollOutput, false);
-            results.push(formattedRollOutput);
-          } else {
-            const rollTotal = rollInstance.total;
-            const isSuccess = evaluate2(
-              `${rollTotal}${activeCompare.sign}${activeCompare.value}`
-            );
-            if (isSuccess) successCount++;
-            results.push(formatOutput(rollOutput, isSuccess));
+          if (foundStatAfterD) {
+            lastIndex = tokenRegex.lastIndex;
+            continue;
           }
-        } catch (error) {
-          throw new DiceTypeError(diceToRoll, "roll", error);
         }
-      }
-      const signSource = explodingSuccess?.originalDice ?? diceDisplay ?? dice;
-      const explodingMatch = signSource.match(EXPLODING_SUCCESS_REGEX);
-      if (explodingMatch) {
-        const [, doubledSignRaw, valueStr] = explodingMatch;
-        let doubledSign;
-        if (doubledSignRaw === "!!==") doubledSign = "==";
-        else if (doubledSignRaw === "!==") doubledSign = "!==";
-        else doubledSign = doubledSignRaw.replace(/^!/, "");
-        const signMap = {
-          ">>": ">",
-          "<<": "<",
-          ">>=": ">=",
-          "<<=": "<=",
-          "==": "=",
-          "!==": "!=",
-          "!!==": "="
-        };
-        const mappedSign = signMap[doubledSign];
-        const mappedValue = Number.parseFloat(valueStr);
-        if (mappedSign && !Number.isNaN(mappedValue)) {
-          const resultsString = replaceUnwantedText(results.join("; "));
-          const flatValues = resultsString.split(";").flatMap((segment) => extractValuesFromOutput(segment));
-          if (mappedSign === "!=") {
-            const equalsCount = flatValues.filter((val) => val === mappedValue).length;
-            successCount = flatValues.length - equalsCount;
-          } else {
-            successCount = flatValues.filter(
-              (val) => matchComparison(mappedSign, val, mappedValue)
-            ).length;
+        let bestKey = null;
+        let bestScore = 0;
+        for (const key of statKeys) {
+          const keyStd = key.standardize();
+          if (tokenStd === keyStd) {
+            bestKey = key;
+            bestScore = 1;
+            break;
+          }
+          const score = similarityScore(tokenStd, keyStd);
+          if (score > bestScore) {
+            bestScore = score;
+            bestKey = key;
           }
         }
+        if (bestKey && bestScore >= 0.6) {
+          const statValue = stats[bestKey];
+          result += statValue.toString();
+        } else {
+          result += token;
+        }
+        lastIndex = tokenRegex.lastIndex;
       }
-      if (compare && trivialComparisonDetected) compare.trivial = true;
-      const finalDice2 = isCurlyBulk ? `{${diceToRoll}${curlyCompare?.sign}${curlyCompare?.value}}` : diceToRoll;
-      const resultOutput2 = replaceUnwantedText(results.join("; "));
-      const finalTotal = explodingSuccess ? resultOutput2.split(";").flatMap((segment) => extractValuesFromOutput(segment)).filter(
-        (val) => matchComparison(explodingSuccess.sign, val, explodingSuccess.value)
-      ).length : successCount;
-      return {
-        dice: explodingSuccess ? diceDisplay : finalDice2,
-        result: resultOutput2,
-        comment: comments,
-        compare: isCurlyBulk ? void 0 : compare,
-        modifier: modificator,
-        total: finalTotal,
-        trivial: trivialComparisonDetected ? true : void 0
-      };
-    }
-    const roller2 = new DiceRoller();
-    NumberGenerator.generator.engine = engine;
-    for (let i = 0; i < numberOfDice; i++) {
-      try {
-        roller2.roll(diceToRoll);
-      } catch (error) {
-        throw new DiceTypeError(diceToRoll, "roll", error);
-      }
-    }
-    const finalDice = isCurlyBulk ? `{${diceToRoll}}` : diceToRoll;
-    return {
-      dice: finalDice,
-      result: replaceUnwantedText(roller2.output),
-      comment: comments,
-      compare: compare ? compare : void 0,
-      modifier: modificator,
-      total: roller2.total
-    };
-  }
-  const roller = new DiceRoller();
-  NumberGenerator.generator.engine = engine;
-  let diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
-  if (sort) diceWithoutComment = `${diceWithoutComment}${sort}`;
-  let diceRoll;
-  try {
-    diceRoll = roller.roll(diceWithoutComment);
-  } catch (error) {
-    throw new DiceTypeError(diceWithoutComment, "roll", error);
-  }
-  if (compare && diceRoll) {
-    const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
-    const maxDiceValue = currentRoll.maxTotal;
-    const minDiceValue = currentRoll.minTotal;
-    const trivial = isTrivialComparison(maxDiceValue, minDiceValue, compare);
-    compare.trivial = trivial ? true : void 0;
-  }
-  const commentMatch = dice.match(COMMENT_REGEX);
-  const comment = commentMatch ? commentMatch[2] : void 0;
-  let rerollCount = 0;
-  let res;
-  if (pity && compare) {
-    const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
-    const maxPossible = currentRoll ? currentRoll.maxTotal : null;
-    const isComparisonPossible = maxPossible === null || canComparisonSucceed(maxPossible, compare);
-    if (isComparisonPossible) {
-      let isFail = evaluate2(`${roller.total}${compare.sign}${compare.value}`);
-      if (!isFail) {
-        const maxReroll = 100;
-        while (!isFail && rerollCount < maxReroll) {
-          try {
-            res = roll(diceWithoutComment, engine, false);
-          } catch (error) {
-            throw new DiceTypeError(diceWithoutComment, "roll", error);
-          }
-          rerollCount++;
-          if (res && res.total !== void 0)
-            isFail = evaluate2(`${res.total}${compare.sign}${compare.value}`);
-        }
-        if (res) {
-          return {
-            ...res,
-            dice,
-            comment,
-            compare,
-            modifier: modificator,
-            pityLogs: rerollCount,
-            trivial: res.trivial ?? (compare?.trivial ? true : void 0)
-          };
-        }
-      }
+      result += outsideText.slice(lastIndex);
     }
+    dice = result;
   }
-  let resultOutput = replaceUnwantedText(roller.output);
-  if (explodingSuccess) {
-    const successes = countExplodingSuccesses(
-      diceRoll,
-      explodingSuccess.sign,
-      explodingSuccess.value
-    );
-    resultOutput = resultOutput.replace(/=\s*-?\d+(?:\.\d+)?$/, `= ${successes}`).replace(explodingSuccess.normalizedSegment, explodingSuccess.originalSegment);
-    return {
-      dice: diceDisplay,
-      result: resultOutput,
-      comment,
-      compare: compare ? compare : void 0,
-      modifier: modificator,
-      total: successes,
-      pityLogs: rerollCount > 0 ? rerollCount : void 0,
-      trivial: compare?.trivial ? true : void 0
-    };
-  }
-  return {
-    dice,
-    result: resultOutput,
-    comment,
-    compare: compare ? compare : void 0,
-    modifier: modificator,
-    total: roller.total,
-    pityLogs: rerollCount > 0 ? rerollCount : void 0,
-    trivial: compare?.trivial ? true : void 0
-  };
+  if (dollarValue) dice = dice.replaceAll(/\$\B/g, dollarValue);
+  return replaceFormulaInDice(dice);
 }
-function sharedRolls(dice, engine = NumberGenerator.engines.nodeCrypto, pity, explodingSuccessMain, diceDisplay) {
-  if (!explodingSuccessMain) {
-    explodingSuccessMain = normalizeExplodingSuccess(dice.split(";")[0] ?? dice);
-  }
-  if (explodingSuccessMain) {
-    dice = dice.replace(explodingSuccessMain.originalSegment, "!");
-  }
-  if (dice.match(/\d+?#(.*?)/))
-    throw new DiceTypeError(
-      dice,
-      "noBulkRoll",
-      "bulk roll are not allowed in shared rolls"
-    );
-  const results = [];
-  const mainComment = /\s+#(?<comment>.*)/.exec(dice)?.groups?.comment?.trimEnd() ?? void 0;
-  const split = dice.split(";");
-  const displayDice = diceDisplay ?? explodingSuccessMain?.originalDice ?? split[0];
-  let diceMain = fixParenthesis(split[0]);
-  const commentsRegex = /\[(?<comments>.*?)\]/gi;
-  const comments = formatComment(diceMain);
-  const diceMainWithoutComments = diceMain.replace(commentsRegex, "").trim();
-  const toHideRegex = /\((?<dice>[^)]+)\)/;
-  const toHide = toHideRegex.exec(diceMainWithoutComments)?.groups;
-  let hidden = false;
-  if (toHide?.dice) {
-    diceMain = toHide.dice;
-    hidden = true;
-  } else if (toHide) {
-    diceMain = "1d1";
-    hidden = true;
-  } else {
-    diceMain = diceMainWithoutComments;
-  }
-  const rollBounds = getRollBounds(diceMain, engine);
-  let diceResult = roll(diceMain, engine, pity);
-  if (!diceResult || !diceResult.total) {
-    if (hidden) {
-      diceResult = roll(fixParenthesis(split[0]), engine, pity);
-      hidden = false;
-    } else return void 0;
-  }
-  if (!diceResult || !diceResult.total) return void 0;
-  if (explodingSuccessMain && diceResult.result) {
-    const values = extractValuesFromOutput(diceResult.result);
-    diceResult.total = values.filter(
-      (v) => matchComparison(explodingSuccessMain.sign, v, explodingSuccessMain.value)
-    ).length;
-  }
-  let aggregatedCompare = diceResult.compare;
-  let hasTrivialComparison = diceResult.compare?.trivial === true;
-  results.push(`\u203B ${comments}${diceResult.result}`);
-  let total = diceResult.total;
-  diceResult.comment = mainComment;
-  if (!total) {
-    return {
-      dice: displayDice,
-      result: results.join(";"),
-      comment: mainComment,
-      compare: aggregatedCompare,
-      modifier: diceResult.modifier,
-      total,
-      trivial: hasTrivialComparison ? true : void 0
-    };
-  }
-  for (let element of split.slice(1)) {
-    const comment = formatComment(element);
-    element = element.replaceAll(commentsRegex, "").replaceAll(OPTIONAL_COMMENT, "").trim();
-    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,
-        pity,
-        rollBounds
-      );
-      toRoll = compareResult.dice;
-      results.push(compareResult.results);
-      if (!aggregatedCompare && compareResult.compare)
-        aggregatedCompare = compareResult.compare;
-      if (compareResult.trivial) hasTrivialComparison = true;
-    } else {
-      const { formule, diceAll } = replaceText(
-        element,
-        diceResult.total,
-        diceResult.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 evaluated = evaluate2(toRoll);
-        results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
-        total += Number.parseInt(evaluated, 10);
+        const result = evaluate(formulae);
+        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
       } catch (error) {
-        const evaluated = roll(toRoll, engine, pity);
-        if (evaluated) {
-          results.push(
-            `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
-          );
-          if (!aggregatedCompare && evaluated.compare)
-            aggregatedCompare = evaluated.compare;
-          if (evaluated.compare?.trivial) hasTrivialComparison = true;
-        } else results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
-        total += evaluated?.total ?? 0;
+        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
       }
     }
   }
-  if (hidden)
-    results.shift();
-  return {
-    dice: displayDice,
-    result: results.join(";"),
-    comment: mainComment,
-    compare: hasTrivialComparison && aggregatedCompare ? { ...aggregatedCompare, trivial: true } : aggregatedCompare,
-    modifier: diceResult.modifier,
-    total,
-    trivial: hasTrivialComparison ? true : void 0
-  };
+  return cleanedDice(modifiedDice);
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = NumberGenerator.engines.nodeCrypto, pity) {
-  const { formule, diceAll } = replaceText(
-    element,
-    diceResult.total ?? 0,
-    diceResult.dice
-  );
-  const validSign = res ? "\u2713" : "\u2715";
-  const invertedSign = res ? compareResult.compare.sign : inverseSign(compareResult.compare.sign);
-  let evaluateRoll;
-  try {
-    evaluateRoll = evaluate2(compareResult.dice);
-    return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
-  } catch (error) {
-    const evaluateRoll2 = roll(compareResult.dice, engine, pity);
-    if (evaluateRoll2)
-      return `${validSign} ${diceAll}: ${evaluateRoll2.result.split(":").splice(1).join(":")}`;
-    return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
-  }
+function cleanedDice(dice) {
+  return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+").replaceAll("=>", ">=").replaceAll("=<", "<=").trimEnd();
 }
-function rollCompare(value, engine = NumberGenerator.engines.nodeCrypto, pity) {
-  if (isNumber(value)) return { value: Number.parseInt(value, 10) };
-  if (!value || typeof value === "string" && value.trim() === "") {
-    return { value: 0, diceResult: value };
-  }
-  const rollComp = roll(value, engine, pity);
-  if (!rollComp?.total) {
-    try {
-      return { value: evaluate2(value), diceResult: value };
-    } catch (error) {
-      return { value: 0, diceResult: value };
+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 = NumberGenerator2.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 = NumberGenerator2.engines.nodeCrypto, rng) {
+  if (!rng) rng = new Random(engine || void 0);
+  return rng.integer(min, max);
+}
+function levenshteinDistance(a, b) {
+  if (a === b) return 0;
+  const al = a.length;
+  const bl = b.length;
+  if (al === 0) return bl;
+  if (bl === 0) return al;
+  const v0 = new Array(bl + 1);
+  const v1 = new Array(bl + 1);
+  for (let i = 0; i <= bl; i++) v0[i] = i;
+  for (let i = 0; i < al; i++) {
+    v1[0] = i + 1;
+    for (let j = 0; j < bl; j++) {
+      const cost = a[i] === b[j] ? 0 : 1;
+      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
     }
+    for (let j = 0; j <= bl; j++) v0[j] = v1[j];
   }
-  return {
-    dice: value,
-    value: rollComp.total,
-    diceResult: rollComp?.result
-  };
+  return v1[bl];
+}
+function similarityScore(a, b) {
+  const la = a.length;
+  const lb = b.length;
+  if (la === 0 && lb === 0) return 1;
+  const dist = levenshteinDistance(a, b);
+  const max = Math.max(la, lb);
+  return 1 - dist / max;
+}
+function createCriticalCustom(dice, customCritical, template, engine = NumberGenerator2.engines.nodeCrypto) {
+  const compareRegex = dice.match(SIGN_REGEX_SPACE);
+  let customDice = dice;
+  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, engine);
 }
 
 // src/dice/compare.ts
@@ -462,18 +366,37 @@ function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
       return true;
   }
 }
-function getCompare(dice, compareRegex, engine = NumberGenerator2.engines.nodeCrypto, pity) {
-  if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))([><=]|!=)+\d+\}?)|\{(.*)(([><=]|!=)+).*\}/))
-    return { dice, compare: void 0 };
-  dice = dice.replace(SIGN_REGEX_SPACE, "");
-  let compare;
-  const calc = compareRegex[2];
-  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(/;(.*)/, "");
+function rollCompare(value, engine = NumberGenerator3.engines.nodeCrypto, pity) {
+  if (isNumber(value)) return { value: Number.parseInt(value, 10) };
+  if (!value || typeof value === "string" && value.trim() === "") {
+    return { value: 0, diceResult: value };
+  }
+  const rollComp = roll(value, engine, pity);
+  if (!rollComp?.total) {
+    try {
+      return { value: evaluate2(value), diceResult: value };
+    } catch (error) {
+      return { value: 0, diceResult: value };
+    }
+  }
+  return {
+    dice: value,
+    value: rollComp.total,
+    diceResult: rollComp?.result
+  };
+}
+function getCompare(dice, compareRegex, engine = NumberGenerator3.engines.nodeCrypto, pity) {
+  if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))([><=]|!=)+\d+\}?)|\{(.*)(([><=]|!=)+).*\}/))
+    return { dice, compare: void 0 };
+  dice = dice.replace(SIGN_REGEX_SPACE, "");
+  let compare;
+  const calc = compareRegex[2];
+  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, pity);
-    const total = evaluate3(rCompare.value.toString());
+    const total = evaluate2(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
       sign: compareSign,
@@ -515,11 +438,11 @@ function canComparisonSucceed(maxRollValue, compare, minRollValue) {
 }
 
 // src/dice/exploding.ts
-import { evaluate as evaluate5 } from "mathjs";
+import { evaluate as evaluate4 } from "mathjs";
 
 // src/dice/signs.ts
-import { NumberGenerator as NumberGenerator3 } from "@dice-roller/rpg-dice-roller";
-import { evaluate as evaluate4 } from "mathjs";
+import { NumberGenerator as NumberGenerator4 } from "@dice-roller/rpg-dice-roller";
+import { evaluate as evaluate3 } from "mathjs";
 
 // src/dice/replace.ts
 function replaceUnwantedText(dice) {
@@ -588,14 +511,14 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = NumberGenerator3.engines.nodeCrypto, pity, rollBounds) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = NumberGenerator4.engines.nodeCrypto, pity, rollBounds) {
   let results = "";
   let trivial = false;
   const compareResult = getCompare(toRoll, compareRegex, engine);
   const toCompare = `${compareResult.dice}${compareResult.compare?.sign}${compareResult.compare?.value}`;
   let res;
   try {
-    res = evaluate4(toCompare);
+    res = evaluate3(toCompare);
   } catch (error) {
     res = roll(toCompare, engine, pity);
   }
@@ -607,7 +530,7 @@ function compareSignFormule(toRoll, compareRegex, element, diceResult, engine =
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
-      const toEvaluate = evaluate4(
+      const toEvaluate = evaluate3(
         `${diceResult2.total}${diceResult2.compare.sign}${diceResult2.compare.value}`
       );
       const sign = toEvaluate ? "\u2713" : "\u2715";
@@ -644,7 +567,7 @@ function normalizeExplodingSuccess(dice) {
   let parsedValue = Number.parseFloat(valueStr);
   if (Number.isNaN(parsedValue)) {
     try {
-      parsedValue = Number.parseFloat(evaluate5(valueStr));
+      parsedValue = Number.parseFloat(evaluate4(valueStr));
     } catch (_error) {
       parsedValue = 0;
     }
@@ -679,7 +602,16 @@ function countExplodingSuccesses(diceRoll, sign, value) {
 }
 
 // src/dice/extract.ts
-import { DiceRoller as DiceRoller2, NumberGenerator as NumberGenerator4 } from "@dice-roller/rpg-dice-roller";
+import { DiceRoller, NumberGenerator as NumberGenerator5 } from "@dice-roller/rpg-dice-roller";
+
+// src/dice/calculator.ts
+import { evaluate as evaluate5 } from "mathjs";
+function calculator(sign, value, total) {
+  if (sign === "^") sign = "**";
+  return evaluate5(`${total} ${sign} ${value}`);
+}
+
+// src/dice/extract.ts
 function getModifier(dice) {
   const modifier = dice.matchAll(/(\+|-|%|\/|\^|\*|\*{2})(\d+)/gi);
   let modificator;
@@ -711,10 +643,10 @@ function extractValuesFromOutput(output) {
   }
   return values;
 }
-function getRollBounds(dice, engine = NumberGenerator4.engines.nodeCrypto) {
+function getRollBounds(dice, engine = NumberGenerator5.engines.nodeCrypto) {
   try {
-    const roller = new DiceRoller2();
-    NumberGenerator4.generator.engine = engine;
+    const roller = new DiceRoller();
+    NumberGenerator5.generator.engine = engine;
     const rollResult = roller.roll(dice);
     const instance = Array.isArray(rollResult) ? rollResult[0] : rollResult;
     const { minTotal, maxTotal } = instance;
@@ -723,330 +655,543 @@ function getRollBounds(dice, engine = NumberGenerator4.engines.nodeCrypto) {
   }
   return void 0;
 }
-
-// src/engine.ts
-import { NumberGenerator as NumberGenerator5 } from "@dice-roller/rpg-dice-roller";
-function getEngineId(engine) {
-  if (engine === NumberGenerator5.engines.nodeCrypto) return "nodeCrypto";
-  if (engine === NumberGenerator5.engines.nativeMath) return "nativeMath";
-  if (engine === NumberGenerator5.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;
+function setSortOrder(toRoll, sort) {
+  const sortRegex = /(sa|sd|s)/i;
+  if (sort && !toRoll.match(sortRegex)) {
+    const modifierComparisonRegex = /([+\-*/%^]\d+|([><=!]+\d+f)|([><=]|!=)+\d+)$/;
+    const match = toRoll.match(modifierComparisonRegex);
+    if (match) {
+      const index = match.index;
+      toRoll = `${toRoll.slice(0, index)}${sort}${toRoll.slice(index)}`;
+    } else {
+      toRoll += sort;
     }
-  } catch {
   }
-  return "unknown";
+  return toRoll;
 }
-function getEngine(engine) {
-  switch (engine) {
-    case "nativeMath":
-      return NumberGenerator5.engines.nativeMath;
-    case "browserCrypto":
-      return NumberGenerator5.engines.browserCrypto;
-    case "nodeCrypto":
-      return NumberGenerator5.engines.nodeCrypto;
-    default:
-      return NumberGenerator5.engines.nativeMath;
+function prepareDice(diceInput) {
+  let dice = standardizeDice(replaceFormulaInDice(diceInput)).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
+  dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
+  const explodingSuccess = normalizeExplodingSuccess(dice);
+  if (explodingSuccess) dice = explodingSuccess.dice;
+  let diceDisplay;
+  if (dice.includes(";")) {
+    const mainDice = dice.split(";")[0];
+    diceDisplay = explodingSuccess?.originalDice ?? mainDice;
+  } else {
+    diceDisplay = explodingSuccess?.originalDice ?? dice;
+  }
+  const curlyBulkMatch = dice.match(/^\{(\d+#.*)\}$/);
+  const isCurlyBulk = !!curlyBulkMatch;
+  const bulkContent = isCurlyBulk ? curlyBulkMatch[1] : "";
+  const isSharedRoll = dice.includes(";");
+  let isSharedCurly = false;
+  if (isSharedRoll && dice.match(/^\{.*;\s*.*\}$/)) {
+    dice = dice.slice(1, -1);
+    isSharedCurly = true;
+    diceDisplay = diceDisplay.slice(1);
   }
+  let isSimpleCurly = false;
+  if (!isCurlyBulk && !isSharedRoll && dice.match(/^\{.*\}$/)) {
+    const innerContent = dice.slice(1, -1);
+    const hasModifiers = innerContent.match(/[+\-*/%^]/);
+    const hasComparison = innerContent.match(/(([><=!]+\d+f)|([><=]|!=)+\d+)/);
+    if (!(hasComparison && !hasModifiers)) {
+      dice = innerContent;
+      isSimpleCurly = true;
+    }
+  }
+  return {
+    dice,
+    diceDisplay,
+    explodingSuccess,
+    isSharedRoll,
+    isSharedCurly,
+    isCurlyBulk,
+    bulkContent,
+    isSimpleCurly
+  };
 }
 
-// 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;
+// src/dice/bulk.ts
+function handleBulkRolls(dice, isCurlyBulk, bulkContent, compare, explodingSuccess, diceDisplay, engine, sort) {
+  const bulkProcessContent = isCurlyBulk ? bulkContent : dice;
+  const diceArray = bulkProcessContent.split("#");
+  const numberOfDice = Number.parseInt(diceArray[0], 10);
+  let diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
+  const commentsMatch = diceArray[1].match(COMMENT_REGEX);
+  const comments = commentsMatch ? commentsMatch[2] : void 0;
+  let curlyCompare;
+  if (isCurlyBulk) {
+    const curlyCompareRegex = diceToRoll.match(SIGN_REGEX_SPACE);
+    if (curlyCompareRegex) {
+      const compareSign = curlyCompareRegex[0].match(SIGN_REGEX)?.[0];
+      const compareValue = curlyCompareRegex[2];
+      if (compareSign && compareValue) {
+        curlyCompare = {
+          sign: compareSign,
+          value: Number.parseInt(compareValue, 10)
+        };
+        diceToRoll = diceToRoll.replace(SIGN_REGEX_SPACE, "");
+      }
+    }
   }
-};
-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;
+  diceToRoll = setSortOrder(diceToRoll, sort);
+  const activeCompare = compare || curlyCompare || (explodingSuccess ? { sign: explodingSuccess.sign, value: explodingSuccess.value } : void 0);
+  if (activeCompare) {
+    return handleBulkRollsWithComparison(
+      numberOfDice,
+      diceToRoll,
+      comments,
+      activeCompare,
+      explodingSuccess,
+      diceDisplay,
+      isCurlyBulk,
+      curlyCompare,
+      compare,
+      engine
+    );
   }
-};
-var MaxGreater = class extends Error {
-  name;
-  value;
-  max;
-  constructor(value, max) {
-    super(value.toString());
-    this.name = "Max_Greater";
-    this.value = value;
-    this.max = max;
+  const roller = new DiceRoller2();
+  NumberGenerator6.generator.engine = engine;
+  for (let i = 0; i < numberOfDice; i++) {
+    try {
+      roller.roll(diceToRoll);
+    } catch (error) {
+      throw new DiceTypeError(diceToRoll, "roll", error);
+    }
   }
-};
-var EmptyObjectError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Empty_Object";
+  const finalDice = isCurlyBulk ? `{${diceToRoll}}` : diceToRoll;
+  const modificator = getModifier(dice);
+  return {
+    dice: finalDice,
+    result: replaceUnwantedText(roller.output),
+    comment: comments,
+    compare: compare ? compare : void 0,
+    modifier: modificator,
+    total: roller.total
+  };
+}
+function handleBulkRollsWithComparison(numberOfDice, diceToRoll, comments, activeCompare, explodingSuccess, diceDisplay, isCurlyBulk, curlyCompare, compare, engine) {
+  const results = [];
+  let successCount = 0;
+  const roller = new DiceRoller2();
+  NumberGenerator6.generator.engine = engine;
+  let trivialComparisonDetected = false;
+  const formatOutput = (output, addStar) => {
+    const formatted = addStar && isCurlyBulk ? output.replace(
+      /\[([^\]]+)\]/,
+      (_m, content) => `[${content.split(",").map((d) => `${d.trim()}*`).join(", ")}]`
+    ) : output;
+    return curlyCompare ? formatted.replace(/^([^:]+):/, `$1${curlyCompare.sign}${curlyCompare.value}:`) : formatted;
+  };
+  for (let i = 0; i < numberOfDice; i++) {
+    try {
+      const individualRoll = roller.roll(diceToRoll);
+      const rollInstance = Array.isArray(individualRoll) ? individualRoll[0] : individualRoll;
+      if (!trivialComparisonDetected && activeCompare) {
+        const { maxTotal, minTotal } = rollInstance;
+        trivialComparisonDetected = isTrivialComparison(
+          maxTotal,
+          minTotal,
+          activeCompare
+        );
+      }
+      const rollOutput = rollInstance.output;
+      if (explodingSuccess) {
+        const successesForRoll = countExplodingSuccesses(
+          rollInstance,
+          explodingSuccess.sign,
+          explodingSuccess.value
+        );
+        successCount += successesForRoll;
+        let formattedRollOutput = rollOutput.replace(explodingSuccess.normalizedSegment, explodingSuccess.originalSegment).replace(/=\s*-?\d+(?:\.\d+)?$/, `= ${successesForRoll}`);
+        formattedRollOutput = formatOutput(formattedRollOutput, false);
+        results.push(formattedRollOutput);
+      } else {
+        const rollTotal = rollInstance.total;
+        const isSuccess = evaluate6(
+          `${rollTotal}${activeCompare.sign}${activeCompare.value}`
+        );
+        if (isSuccess) successCount++;
+        results.push(formatOutput(rollOutput, isSuccess));
+      }
+    } catch (error) {
+      throw new DiceTypeError(diceToRoll, "roll", error);
+    }
   }
-};
-var TooManyDice = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Dice";
+  if (explodingSuccess) {
+    const signSource = explodingSuccess?.originalDice ?? diceDisplay;
+    const explodingMatch = signSource.match(EXPLODING_SUCCESS_REGEX);
+    if (explodingMatch) {
+      const [, doubledSignRaw, valueStr] = explodingMatch;
+      let doubledSign;
+      if (doubledSignRaw === "!!==") doubledSign = "==";
+      else if (doubledSignRaw === "!==") doubledSign = "!==";
+      else doubledSign = doubledSignRaw.replace(/^!/, "");
+      const signMap = {
+        ">>": ">",
+        "<<": "<",
+        ">=": ">=",
+        "<=": "<=",
+        "==": "=",
+        "!==": "!=",
+        "!!==": "="
+      };
+      const mappedSign = signMap[doubledSign];
+      const mappedValue = Number.parseFloat(valueStr);
+      if (mappedSign && !Number.isNaN(mappedValue)) {
+        const resultsString = replaceUnwantedText(results.join("; "));
+        const flatValues = resultsString.split(";").flatMap((segment) => extractValuesFromOutput(segment));
+        if (mappedSign === "!=") {
+          const equalsCount = flatValues.filter((val) => val === mappedValue).length;
+          successCount = flatValues.length - equalsCount;
+        } else {
+          successCount = flatValues.filter(
+            (val) => matchComparison(mappedSign, val, mappedValue)
+          ).length;
+        }
+      }
+    }
   }
-};
-var TooManyStats = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Stats";
+  if (compare && trivialComparisonDetected) compare.trivial = true;
+  const finalDice = isCurlyBulk ? `{${diceToRoll}${curlyCompare?.sign}${curlyCompare?.value}}` : diceToRoll;
+  const resultOutput = replaceUnwantedText(results.join("; "));
+  const finalTotal = explodingSuccess ? resultOutput.split(";").flatMap((segment) => extractValuesFromOutput(segment)).filter(
+    (val) => matchComparison(explodingSuccess.sign, val, explodingSuccess.value)
+  ).length : successCount;
+  const modificator = getModifier(diceDisplay);
+  return {
+    dice: explodingSuccess ? diceDisplay : finalDice,
+    result: resultOutput,
+    comment: comments,
+    compare: isCurlyBulk ? void 0 : compare,
+    modifier: modificator,
+    total: finalTotal,
+    trivial: trivialComparisonDetected ? true : void 0
+  };
+}
+
+// src/dice/pity.ts
+import { evaluate as evaluate7 } from "mathjs";
+function handlePitySystem(dice, compare, diceRoll, roller, engine) {
+  const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
+  const maxPossible = currentRoll ? currentRoll.maxTotal : null;
+  const isComparisonPossible = maxPossible === null || canComparisonSucceed(maxPossible, compare);
+  if (!isComparisonPossible) {
+    return { rerollCount: 0 };
   }
-};
-var NoStatisticsError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "No_Statistics";
+  let isFail = evaluate7(`${roller.total}${compare.sign}${compare.value}`);
+  if (isFail) {
+    return { rerollCount: 0 };
   }
-};
-
-// src/interfaces/index.ts
-var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
-  SortOrder2["Ascending"] = "sa";
-  SortOrder2["Descending"] = "sd";
-  SortOrder2["None"] = "none";
-  return SortOrder2;
-})(SortOrder || {});
-
-// src/interfaces/zod.ts
-import { z } from "zod";
-var statisticValueSchema = z.object({
-  max: z.number().transform((val) => val === 0 ? void 0 : val).optional(),
-  min: z.number().transform(
-    (val) => Number.isNaN(Number.parseInt(val, 10)) ? void 0 : val
-  ).optional(),
-  combinaison: z.string().transform((str) => str.trim() || void 0).optional(),
-  exclude: 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"]
-    });
+  const maxReroll = 100;
+  let rerollCount = 0;
+  let res;
+  while (!isFail && rerollCount < maxReroll) {
+    try {
+      res = roll(dice, engine, false);
+    } catch (error) {
+      throw new DiceTypeError(dice, "roll", error);
+    }
+    rerollCount++;
+    if (res && res.total !== void 0) {
+      isFail = evaluate7(`${res.total}${compare.sign}${compare.value}`);
+    }
   }
-});
-var statisticSchema = z.record(z.string(), statisticValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
-  message: "TooManyStats"
-});
-var criticalSchema = z.object({
-  success: z.string().or(z.number().min(0)).optional(),
-  failure: z.string().or(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 = z.object({
-  sign: z.enum(["<", ">", "<=", ">=", "!=", "=="]),
-  value: z.string(),
-  onNaturalDice: z.boolean().optional(),
-  affectSkill: z.boolean().optional()
-});
-var damageSchema = z.record(z.string(), z.string()).optional().refine((stats) => !stats || Object.keys(stats).length <= 25, {
-  message: "TooManyDice"
-});
-var customCriticalSchema = z.record(z.string(), criticalValueSchema).optional().refine((stats) => !stats || Object.keys(stats).length <= 22, {
-  message: "TooManyDice"
-});
-var templateSchema = z.object({
-  charName: z.boolean().optional(),
-  statistics: statisticSchema,
-  total: z.number().min(0).transform((val) => val === 0 ? void 0 : val).optional(),
-  forceDistrib: z.boolean().optional(),
-  diceType: z.string().optional(),
-  critical: criticalSchema.optional(),
-  customCritical: customCriticalSchema,
-  damage: damageSchema
-});
-
-// src/utils.ts
-import { evaluate as evaluate6 } from "mathjs";
-import "uniformize";
-import { NumberGenerator as NumberGenerator6 } from "@dice-roller/rpg-dice-roller";
-import { Random } from "random-js";
-function escapeRegex(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function standardizeDice(dice) {
-  return dice.replace(
-    /(\[[^\]]+])|([^[]+)/g,
-    (_match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize().replaceAll("df", "dF")
-  );
+  return { rerollCount, result: res };
 }
-function generateStatsDice(originalDice, stats, dollarValue) {
-  let dice = originalDice.standardize();
-  if (stats && Object.keys(stats).length > 0) {
-    const statKeys = Object.keys(stats);
-    const partsRegex = /(\[[^\]]+])|([^[]+)/g;
-    let result = "";
-    let match;
-    while ((match = partsRegex.exec(dice)) !== null) {
-      const insideBrackets = match[1];
-      const outsideText = match[2];
-      if (insideBrackets) {
-        result += insideBrackets;
-        continue;
-      }
-      if (!outsideText) {
-        continue;
-      }
-      const tokenRegex = /([\p{L}\p{N}_]+)/gu;
-      let lastIndex = 0;
-      let tokenMatch;
-      while ((tokenMatch = tokenRegex.exec(outsideText)) !== null) {
-        result += outsideText.slice(lastIndex, tokenMatch.index);
-        const token = tokenMatch[0];
-        const tokenStd = token.standardize();
-        const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
-        if (diceMatch) {
-          const diceCount = diceMatch[1] || "";
-          const afterD = diceMatch[2];
-          let foundStatAfterD = false;
-          for (const key of statKeys) {
-            const keyStd = key.standardize();
-            if (afterD === keyStd) {
-              result += `${diceCount}d${stats[key].toString()}`;
-              foundStatAfterD = true;
-              break;
-            }
-          }
-          if (foundStatAfterD) {
-            lastIndex = tokenRegex.lastIndex;
-            continue;
-          }
-        }
-        let bestKey = null;
-        let bestScore = 0;
-        for (const key of statKeys) {
-          const keyStd = key.standardize();
-          if (tokenStd === keyStd) {
-            bestKey = key;
-            bestScore = 1;
-            break;
-          }
-          const score = similarityScore(tokenStd, keyStd);
-          if (score > bestScore) {
-            bestScore = score;
-            bestKey = key;
-          }
-        }
-        if (bestKey && bestScore >= 0.6) {
-          const statValue = stats[bestKey];
-          result += statValue.toString();
-        } else {
-          result += token;
-        }
-        lastIndex = tokenRegex.lastIndex;
-      }
-      result += outsideText.slice(lastIndex);
+
+// src/roll.ts
+function roll(dice, engine = NumberGenerator7.engines.nodeCrypto, pity, sort) {
+  if (sort === "none" /* None */) sort = void 0;
+  const prepared = prepareDice(dice);
+  if (!prepared.dice.includes("d")) return void 0;
+  if (prepared.isSharedRoll) {
+    return sharedRolls(
+      prepared.dice,
+      engine,
+      pity,
+      prepared.explodingSuccess,
+      prepared.diceDisplay,
+      prepared.isSharedCurly
+    );
+  }
+  let processedDice = fixParenthesis(prepared.dice);
+  const modificator = getModifier(processedDice);
+  const compareRegex = processedDice.match(SIGN_REGEX_SPACE);
+  let compare;
+  if (compareRegex && !prepared.isCurlyBulk) {
+    const compareResult = getCompare(processedDice, compareRegex, engine, pity);
+    processedDice = compareResult.dice;
+    compare = compareResult.compare;
+  }
+  let finalDiceDisplay = prepared.diceDisplay;
+  if (prepared.isSimpleCurly && !prepared.diceDisplay.startsWith("{")) {
+    finalDiceDisplay = `{${prepared.diceDisplay}}`;
+  }
+  const bulkProcessContent = prepared.isCurlyBulk ? prepared.bulkContent : processedDice;
+  if (bulkProcessContent.match(/\d+?#(.*)/)) {
+    return handleBulkRolls(
+      processedDice,
+      prepared.isCurlyBulk,
+      prepared.bulkContent,
+      compare,
+      prepared.explodingSuccess,
+      prepared.diceDisplay,
+      engine,
+      sort
+    );
+  }
+  const roller = new DiceRoller3();
+  NumberGenerator7.generator.engine = engine;
+  let diceWithoutComment = processedDice.replace(COMMENT_REGEX, "").trimEnd();
+  diceWithoutComment = setSortOrder(diceWithoutComment, sort);
+  let diceRoll;
+  try {
+    diceRoll = roller.roll(diceWithoutComment);
+  } catch (error) {
+    throw new DiceTypeError(diceWithoutComment, "roll", error);
+  }
+  if (compare && diceRoll) {
+    const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
+    const trivial = isTrivialComparison(
+      currentRoll.maxTotal,
+      currentRoll.minTotal,
+      compare
+    );
+    compare.trivial = trivial ? true : void 0;
+  }
+  const commentMatch = processedDice.match(COMMENT_REGEX);
+  const comment = commentMatch ? commentMatch[2] : void 0;
+  let rerollCount = 0;
+  let pityResult;
+  if (pity && compare) {
+    const pityData = handlePitySystem(
+      diceWithoutComment,
+      compare,
+      diceRoll,
+      roller,
+      engine
+    );
+    rerollCount = pityData.rerollCount;
+    pityResult = pityData.result;
+    if (pityResult) {
+      return {
+        ...pityResult,
+        dice: prepared.isSimpleCurly ? finalDiceDisplay : processedDice,
+        comment,
+        compare,
+        modifier: modificator,
+        pityLogs: rerollCount,
+        trivial: pityResult.trivial ?? (compare?.trivial ? true : void 0)
+      };
     }
-    dice = result;
   }
-  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
-  return replaceFormulaInDice(dice);
+  let resultOutput = replaceUnwantedText(roller.output);
+  if (prepared.explodingSuccess) {
+    const successes = countExplodingSuccesses(
+      diceRoll,
+      prepared.explodingSuccess.sign,
+      prepared.explodingSuccess.value
+    );
+    resultOutput = resultOutput.replace(/=\s*-?\d+(?:\.\d+)?$/, `= ${successes}`).replace(
+      prepared.explodingSuccess.normalizedSegment,
+      prepared.explodingSuccess.originalSegment
+    );
+    return {
+      dice: prepared.isSimpleCurly ? finalDiceDisplay : prepared.diceDisplay,
+      result: resultOutput,
+      comment,
+      compare: compare ? compare : void 0,
+      modifier: modificator,
+      total: successes,
+      pityLogs: rerollCount > 0 ? rerollCount : void 0,
+      trivial: compare?.trivial ? true : void 0
+    };
+  }
+  return {
+    dice: prepared.isSimpleCurly ? finalDiceDisplay : processedDice,
+    result: resultOutput,
+    comment,
+    compare: compare ? compare : void 0,
+    modifier: modificator,
+    total: roller.total,
+    pityLogs: rerollCount > 0 ? rerollCount : void 0,
+    trivial: compare?.trivial ? true : void 0
+  };
 }
-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("}}", "");
+function sharedRolls(dice, engine = NumberGenerator7.engines.nodeCrypto, pity, explodingSuccessMain, diceDisplay, isSharedCurly) {
+  if (!explodingSuccessMain)
+    explodingSuccessMain = normalizeExplodingSuccess(dice.split(";")[0] ?? dice);
+  if (explodingSuccessMain) {
+    dice = dice.replace(explodingSuccessMain.originalSegment, "!");
+  }
+  if (dice.match(/\d+?#(.*?)/))
+    throw new DiceTypeError(
+      dice,
+      "noBulkRoll",
+      "bulk roll are not allowed in shared rolls"
+    );
+  const results = [];
+  const mainComment = /\s+#(?<comment>.*)/.exec(dice)?.groups?.comment?.trimEnd() ?? void 0;
+  const split = dice.split(";");
+  const displayDice = diceDisplay ?? explodingSuccessMain?.originalDice ?? split[0];
+  let diceMain = fixParenthesis(split[0]);
+  const commentsRegex = /\[(?<comments>.*?)\]/gi;
+  const comments = formatComment(diceMain);
+  const diceMainWithoutComments = diceMain.replace(commentsRegex, "").trim();
+  const toHideRegex = /\((?<dice>[^)]+)\)/;
+  const toHide = toHideRegex.exec(diceMainWithoutComments)?.groups;
+  let hidden = false;
+  if (toHide?.dice) {
+    diceMain = toHide.dice;
+    hidden = true;
+  } else if (toHide) {
+    diceMain = "1d1";
+    hidden = true;
+  } else {
+    diceMain = diceMainWithoutComments;
+  }
+  const rollBounds = getRollBounds(diceMain, engine);
+  let diceResult = roll(diceMain, engine, pity);
+  if (!diceResult || !diceResult.total) {
+    if (hidden) {
+      diceResult = roll(fixParenthesis(split[0]), engine, pity);
+      hidden = false;
+    } else return void 0;
+  }
+  if (!diceResult || !diceResult.total) return void 0;
+  if (explodingSuccessMain && diceResult.result) {
+    const values = extractValuesFromOutput(diceResult.result);
+    diceResult.total = values.filter(
+      (v) => matchComparison(explodingSuccessMain.sign, v, explodingSuccessMain.value)
+    ).length;
+  }
+  let aggregatedCompare = diceResult.compare;
+  let hasTrivialComparison = diceResult.compare?.trivial === true;
+  results.push(`\u203B ${comments}${diceResult.result}`);
+  let total = diceResult.total;
+  diceResult.comment = mainComment;
+  if (!total) {
+    return {
+      dice: displayDice,
+      result: results.join(";"),
+      comment: mainComment,
+      compare: aggregatedCompare,
+      modifier: diceResult.modifier,
+      total,
+      trivial: hasTrivialComparison ? true : void 0
+    };
+  }
+  for (let element of split.slice(1)) {
+    const comment = formatComment(element);
+    element = element.replaceAll(commentsRegex, "").replaceAll(OPTIONAL_COMMENT, "").trim();
+    let toRoll = element.replace(SYMBOL_DICE, `${diceResult.total}`);
+    const compareRegex = toRoll.match(SIGN_REGEX_SPACE);
+    if (compareRegex) {
+      if (isSharedCurly) {
+        const compareResult = compareSignFormule(
+          toRoll,
+          compareRegex,
+          element,
+          diceResult,
+          engine,
+          pity,
+          rollBounds
+        );
+        const { diceAll } = replaceText(element, diceResult.total, diceResult.dice);
+        let successCount = 0;
+        try {
+          const evaluated = evaluate8(toRoll);
+          successCount = evaluated ? 1 : 0;
+        } catch (error) {
+          const evaluated = roll(toRoll, engine, pity);
+          successCount = evaluated?.total ?? 0 ? 1 : 0;
+        }
+        results.push(`\u203B ${comment}${diceAll}: ${successCount}`);
+        total += successCount;
+        if (!aggregatedCompare && compareResult.compare)
+          aggregatedCompare = compareResult.compare;
+        if (compareResult.trivial) hasTrivialComparison = true;
+      } else {
+        const compareResult = compareSignFormule(
+          toRoll,
+          compareRegex,
+          element,
+          diceResult,
+          engine,
+          pity,
+          rollBounds
+        );
+        toRoll = compareResult.dice;
+        results.push(compareResult.results);
+        if (!aggregatedCompare && compareResult.compare)
+          aggregatedCompare = compareResult.compare;
+        if (compareResult.trivial) hasTrivialComparison = true;
+      }
+    } else {
+      const { formule, diceAll } = replaceText(
+        element,
+        diceResult.total,
+        diceResult.dice
+      );
       try {
-        const result = evaluate6(formulae);
-        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
+        const evaluated = evaluate8(toRoll);
+        results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
+        total += Number.parseInt(evaluated, 10);
       } catch (error) {
-        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
+        const evaluated = roll(toRoll, engine, pity);
+        if (evaluated) {
+          results.push(
+            `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
+          );
+          if (!aggregatedCompare && evaluated.compare)
+            aggregatedCompare = evaluated.compare;
+          if (evaluated.compare?.trivial) hasTrivialComparison = true;
+        } else results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
+        total += evaluated?.total ?? 0;
       }
     }
   }
-  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 = NumberGenerator6.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 = NumberGenerator6.engines.nodeCrypto, rng) {
-  if (!rng) rng = new Random(engine || void 0);
-  return rng.integer(min, max);
+  if (hidden)
+    results.shift();
+  return {
+    dice: displayDice,
+    result: results.join(";"),
+    comment: mainComment,
+    compare: hasTrivialComparison && aggregatedCompare ? { ...aggregatedCompare, trivial: true } : aggregatedCompare,
+    modifier: diceResult.modifier,
+    total,
+    trivial: hasTrivialComparison ? true : void 0
+  };
 }
-function levenshteinDistance(a, b) {
-  if (a === b) return 0;
-  const al = a.length;
-  const bl = b.length;
-  if (al === 0) return bl;
-  if (bl === 0) return al;
-  const v0 = new Array(bl + 1);
-  const v1 = new Array(bl + 1);
-  for (let i = 0; i <= bl; i++) v0[i] = i;
-  for (let i = 0; i < al; i++) {
-    v1[0] = i + 1;
-    for (let j = 0; j < bl; j++) {
-      const cost = a[i] === b[j] ? 0 : 1;
-      v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
-    }
-    for (let j = 0; j <= bl; j++) v0[j] = v1[j];
+function replaceInFormula(element, diceResult, compareResult, res, engine = NumberGenerator7.engines.nodeCrypto, pity) {
+  const { formule, diceAll } = replaceText(
+    element,
+    diceResult.total ?? 0,
+    diceResult.dice
+  );
+  const validSign = res ? "\u2713" : "\u2715";
+  const invertedSign = res ? compareResult.compare.sign : inverseSign(compareResult.compare.sign);
+  let evaluateRoll;
+  try {
+    evaluateRoll = evaluate8(compareResult.dice);
+    return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
+  } catch (error) {
+    const evaluateRoll2 = roll(compareResult.dice, engine, pity);
+    if (evaluateRoll2)
+      return `${validSign} ${diceAll}: ${evaluateRoll2.result.split(":").splice(1).join(":")}`;
+    return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
   }
-  return v1[bl];
-}
-function similarityScore(a, b) {
-  const la = a.length;
-  const lb = b.length;
-  if (la === 0 && lb === 0) return 1;
-  const dist = levenshteinDistance(a, b);
-  const max = Math.max(la, lb);
-  return 1 - dist / max;
-}
-function createCriticalCustom(dice, customCritical, template, engine = NumberGenerator6.engines.nodeCrypto) {
-  const compareRegex = dice.match(SIGN_REGEX_SPACE);
-  let customDice = dice;
-  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, engine);
 }
 
 // src/verify_template.ts
-import { evaluate as evaluate7 } from "mathjs";
+import { evaluate as evaluate9 } from "mathjs";
 import { Random as Random2 } from "random-js";
 import "uniformize";
-import { NumberGenerator as NumberGenerator7 } from "@dice-roller/rpg-dice-roller";
-function evalStatsDice(testDice, allStats, engine = NumberGenerator7.engines.nodeCrypto, pity) {
+import { NumberGenerator as NumberGenerator8 } from "@dice-roller/rpg-dice-roller";
+function evalStatsDice(testDice, allStats, engine = NumberGenerator8.engines.nodeCrypto, pity) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
     const names = Object.keys(allStats);
@@ -1066,7 +1211,7 @@ function evalStatsDice(testDice, allStats, engine = NumberGenerator7.engines.nod
     throw new DiceTypeError(dice, "evalStatsDice", error);
   }
 }
-function diceRandomParse(value, template, engine = NumberGenerator7.engines.nodeCrypto) {
+function diceRandomParse(value, template, engine = NumberGenerator8.engines.nodeCrypto) {
   if (!template.statistics) return replaceFormulaInDice(value.standardize());
   value = value.standardize();
   const statNames = Object.keys(template.statistics);
@@ -1088,7 +1233,7 @@ function diceRandomParse(value, template, engine = NumberGenerator7.engines.node
   }
   return replaceFormulaInDice(newDice);
 }
-function diceTypeRandomParse(dice, template, engine = NumberGenerator7.engines.nodeCrypto) {
+function diceTypeRandomParse(dice, template, engine = NumberGenerator8.engines.nodeCrypto) {
   dice = replaceExpByRandom(dice);
   if (!template.statistics) return dice;
   const firstStatNotcombinaison = Object.keys(template.statistics).find(
@@ -1110,7 +1255,7 @@ function evalCombinaison(combinaison, stats) {
       formula = formula.replace(regex, value.toString());
     }
     try {
-      newStats[stat] = evaluate7(formula);
+      newStats[stat] = evaluate9(formula);
     } catch (error) {
       throw new FormulaError(stat, "evalCombinaison", error);
     }
@@ -1124,7 +1269,7 @@ function evalOneCombinaison(combinaison, stats) {
     formula = formula.replace(regex, value.toString());
   }
   try {
-    return evaluate7(formula);
+    return evaluate9(formula);
   } catch (error) {
     throw new FormulaError(combinaison, "evalOneCombinaison", error);
   }
@@ -1136,7 +1281,7 @@ function convertNumber(number) {
   if (isNumber(number)) return Number.parseInt(number.toString(), 10);
   return void 0;
 }
-function verifyTemplateValue(template, verify = true, engine = NumberGenerator7.engines.nodeCrypto) {
+function verifyTemplateValue(template, verify = true, engine = NumberGenerator8.engines.nodeCrypto) {
   const parsedTemplate = templateSchema.parse(template);
   const { success, failure } = parsedTemplate.critical ?? {};
   const criticicalVal = {
@@ -1191,7 +1336,7 @@ function verifyTemplateValue(template, verify = true, engine = NumberGenerator7.
   testStatCombinaison(statistiqueTemplate, engine);
   return statistiqueTemplate;
 }
-function testDiceRegistered(template, engine = NumberGenerator7.engines.nodeCrypto) {
+function testDiceRegistered(template, engine = NumberGenerator8.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();
@@ -1207,7 +1352,7 @@ function testDiceRegistered(template, engine = NumberGenerator7.engines.nodeCryp
     }
   }
 }
-function testStatCombinaison(template, engine = NumberGenerator7.engines.nodeCrypto) {
+function testStatCombinaison(template, engine = NumberGenerator8.engines.nodeCrypto) {
   if (!template.statistics) return;
   const onlycombinaisonStats = Object.fromEntries(
     Object.entries(template.statistics).filter(
@@ -1233,7 +1378,7 @@ function testStatCombinaison(template, engine = NumberGenerator7.engines.nodeCry
       formula = formula.replace(regex, randomStatValue.toString());
     }
     try {
-      evaluate7(formula);
+      evaluate9(formula);
     } catch (e) {
       error.push(stat);
     }
@@ -1241,9 +1386,9 @@ function testStatCombinaison(template, engine = NumberGenerator7.engines.nodeCry
   if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
   return;
 }
-function generateRandomStat(total = 100, max, min, engine = NumberGenerator7.engines.nodeCrypto) {
+function generateRandomStat(total = 100, max, min, engine = NumberGenerator8.engines.nodeCrypto) {
   let randomStatValue = total + 1;
-  const random = new Random2(engine || NumberGenerator7.engines.nodeCrypto);
+  const random = new Random2(engine || NumberGenerator8.engines.nodeCrypto);
   while (randomStatValue >= total || randomStatValue === 0) {
     if (max && min) randomStatValue = randomInt(min, max, engine, random);
     else if (max) randomStatValue = randomInt(1, max, engine, random);
@@ -1256,7 +1401,6 @@ export {
   COMMENT_REGEX,
   DETECT_CRITICAL,
   DiceTypeError,
-  EXPLODING_SUCCESS_REGEX,
   EmptyObjectError,
   FormulaError,
   MaxGreater,
@@ -1268,11 +1412,6 @@ export {
   SortOrder,
   TooManyDice,
   TooManyStats,
-  calculator,
-  canComparisonFail,
-  canComparisonSucceed,
-  compareSignFormule,
-  countExplodingSuccesses,
   createCriticalCustom,
   diceRandomParse,
   diceTypeRandomParse,
@@ -1280,29 +1419,16 @@ export {
   evalCombinaison,
   evalOneCombinaison,
   evalStatsDice,
-  extractValuesFromOutput,
-  fixParenthesis,
-  formatComment,
   generateRandomStat,
   generateStatsDice,
-  getCompare,
   getEngine,
   getEngineId,
-  getModifier,
-  getRollBounds,
-  inverseSign,
   isNumber,
-  isTrivialComparison,
-  matchComparison,
-  normalizeExplodingSuccess,
   randomInt,
   replaceExpByRandom,
   replaceFormulaInDice,
   replaceInFormula,
-  replaceText,
-  replaceUnwantedText,
   roll,
-  rollCompare,
   standardizeDice,
   templateSchema,
   testDiceRegistered,