@dicelette/core 1.23.0 → 1.24.0

package/dist/index.js

@@ -23,6 +23,7 @@ __export(index_exports, {
   COMMENT_REGEX: () => COMMENT_REGEX,
   DETECT_CRITICAL: () => DETECT_CRITICAL,
   DiceTypeError: () => DiceTypeError,
+  EXPLODING_SUCCESS_REGEX: () => EXPLODING_SUCCESS_REGEX,
   EmptyObjectError: () => EmptyObjectError,
   FormulaError: () => FormulaError,
   MaxGreater: () => MaxGreater,
@@ -31,9 +32,14 @@ __export(index_exports, {
   SIGN_REGEX: () => SIGN_REGEX,
   SIGN_REGEX_SPACE: () => SIGN_REGEX_SPACE,
   SYMBOL_DICE: () => SYMBOL_DICE,
+  SortOrder: () => SortOrder,
   TooManyDice: () => TooManyDice,
   TooManyStats: () => TooManyStats,
   calculator: () => calculator,
+  canComparisonFail: () => canComparisonFail,
+  canComparisonSucceed: () => canComparisonSucceed,
+  compareSignFormule: () => compareSignFormule,
+  countExplodingSuccesses: () => countExplodingSuccesses,
   createCriticalCustom: () => createCriticalCustom,
   diceRandomParse: () => diceRandomParse,
   diceTypeRandomParse: () => diceTypeRandomParse,
@@ -41,15 +47,29 @@ __export(index_exports, {
   evalCombinaison: () => evalCombinaison,
   evalOneCombinaison: () => evalOneCombinaison,
   evalStatsDice: () => evalStatsDice,
+  extractValuesFromOutput: () => extractValuesFromOutput,
+  fixParenthesis: () => fixParenthesis,
+  formatComment: () => formatComment,
   generateRandomStat: () => generateRandomStat,
   generateStatsDice: () => generateStatsDice,
+  getCompare: () => getCompare,
   getEngine: () => getEngine,
   getEngineId: () => getEngineId,
+  getModifier: () => getModifier,
+  getRollBounds: () => getRollBounds,
+  inverseSign: () => inverseSign,
   isNumber: () => isNumber,
+  isTrivialComparison: () => isTrivialComparison,
+  matchComparison: () => matchComparison,
+  normalizeExplodingSuccess: () => normalizeExplodingSuccess,
   randomInt: () => randomInt,
   replaceExpByRandom: () => replaceExpByRandom,
   replaceFormulaInDice: () => replaceFormulaInDice,
+  replaceInFormula: () => replaceInFormula,
+  replaceText: () => replaceText,
+  replaceUnwantedText: () => replaceUnwantedText,
   roll: () => roll,
+  rollCompare: () => rollCompare,
   standardizeDice: () => standardizeDice,
   templateSchema: () => templateSchema,
   testDiceRegistered: () => testDiceRegistered,
@@ -58,140 +78,178 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/dice.ts
-var import_rpg_dice_roller = require("@dice-roller/rpg-dice-roller");
+// src/dice/calculator.ts
 var import_mathjs = require("mathjs");
-function isTrivialComparison(maxValue, minValue, compare) {
-  const canSucceed = canComparisonSucceed(maxValue, compare, minValue);
-  const canFail = canComparisonFail(maxValue, compare, minValue);
-  return !canSucceed || !canFail;
-}
-function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
-  switch (compare.sign) {
-    case ">":
-      return minRollValue <= compare.value;
-    // failure if roll <= value
-    case ">=":
-      return minRollValue < compare.value;
-    // failure if roll < value
-    case "<":
-      return maxRollValue >= compare.value;
-    // failure if roll >= value
-    case "<=":
-      return maxRollValue > compare.value;
-    // failure if roll > value
-    case "=":
-    case "==":
-      return minRollValue !== compare.value || maxRollValue !== compare.value;
-    // can differ
-    case "!=":
-      return minRollValue <= compare.value && compare.value <= maxRollValue;
-    // equality possible
-    default:
-      return true;
-  }
-}
-function getCompare(dice, compareRegex, engine = import_rpg_dice_roller.NumberGenerator.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 = (0, import_mathjs.evaluate)(rCompare.value.toString());
-    dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
-    compare = {
-      sign: compareSign,
-      value: total,
-      originalDice: rCompare.dice,
-      rollValue: rCompare.diceResult
-    };
-  } else {
-    const rcompare = rollCompare(calc, engine, pity);
-    compare = {
-      sign: compareSign,
-      value: rcompare.value,
-      originalDice: rcompare.dice,
-      rollValue: rcompare.diceResult
-    };
-  }
-  return { dice, compare };
-}
-function rollCompare(value, engine = import_rpg_dice_roller.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: (0, import_mathjs.evaluate)(value), diceResult: value };
-    } catch (error) {
-      return { value: 0, diceResult: value };
-    }
-  }
-  return {
-    dice: value,
-    value: rollComp.total,
-    diceResult: rollComp?.result
-  };
-}
-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);
-  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);
-}
-function getModifier(dice) {
-  const modifier = dice.matchAll(/(\+|-|%|\/|\^|\*|\*{2})(\d+)/gi);
-  let modificator;
-  for (const mod of modifier) {
-    if (modificator) {
-      const sign = modificator.sign;
-      let value = modificator.value;
-      if (sign) value = calculator(sign, value, Number.parseInt(mod[2], 10));
-      modificator = {
-        sign: mod[1],
-        value
-      };
-    } else {
-      modificator = {
-        sign: mod[1],
-        value: Number.parseInt(mod[2], 10)
-      };
-    }
-  }
-  return modificator;
+function calculator(sign, value, total) {
+  if (sign === "^") sign = "**";
+  return (0, import_mathjs.evaluate)(`${total} ${sign} ${value}`);
 }
-function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
+
+// src/dice/compare.ts
+var import_rpg_dice_roller2 = require("@dice-roller/rpg-dice-roller");
+var import_mathjs3 = require("mathjs");
+
+// src/interfaces/constant.ts
+var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/gi;
+var SIGN_REGEX = /==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=/;
+var SIGN_REGEX_SPACE = /(==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=)(\S+)/;
+var SYMBOL_DICE = "&";
+var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
+var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
+
+// src/roll.ts
+var import_rpg_dice_roller = require("@dice-roller/rpg-dice-roller");
+var import_mathjs2 = require("mathjs");
+function roll(dice, engine = import_rpg_dice_roller.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);
+  if (dice.includes(";"))
+    return sharedRolls(dice, engine, pity, explodingSuccess, diceDisplay);
   dice = fixParenthesis(dice);
   const modificator = getModifier(dice);
-  if (compareRegex) {
+  if (compareRegex && !isCurlyBulk) {
     const compareResult = getCompare(dice, compareRegex, engine, pity);
     dice = compareResult.dice;
     compare = compareResult.compare;
   }
-  if (dice.match(/\d+?#(.*)/)) {
-    const diceArray = dice.split("#");
+  const bulkProcessContent = isCurlyBulk ? bulkContent : dice;
+  if (bulkProcessContent.match(/\d+?#(.*)/)) {
+    const diceArray = bulkProcessContent.split("#");
     const numberOfDice = Number.parseInt(diceArray[0], 10);
-    const diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
+    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, "");
+        }
+      }
+    }
+    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 import_rpg_dice_roller.DiceRoller();
+      import_rpg_dice_roller.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
+            );
+          }
+          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 = (0, import_mathjs2.evaluate)(
+              `${rollTotal}${activeCompare.sign}${activeCompare.value}`
+            );
+            if (isSuccess) successCount++;
+            results.push(formatOutput(rollOutput, isSuccess));
+          }
+        } 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;
+          }
+        }
+      }
+      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 import_rpg_dice_roller.DiceRoller();
     import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
     for (let i = 0; i < numberOfDice; i++) {
@@ -201,9 +259,10 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
         throw new DiceTypeError(diceToRoll, "roll", error);
       }
     }
+    const finalDice = isCurlyBulk ? `{${diceToRoll}}` : diceToRoll;
     return {
-      dice: diceToRoll,
-      result: roller2.output,
+      dice: finalDice,
+      result: replaceUnwantedText(roller2.output),
       comment: comments,
       compare: compare ? compare : void 0,
       modifier: modificator,
@@ -212,7 +271,8 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
   }
   const roller = new import_rpg_dice_roller.DiceRoller();
   import_rpg_dice_roller.NumberGenerator.generator.engine = engine;
-  const diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
+  let diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
+  if (sort) diceWithoutComment = `${diceWithoutComment}${sort}`;
   let diceRoll;
   try {
     diceRoll = roller.roll(diceWithoutComment);
@@ -235,7 +295,7 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
     const maxPossible = currentRoll ? currentRoll.maxTotal : null;
     const isComparisonPossible = maxPossible === null || canComparisonSucceed(maxPossible, compare);
     if (isComparisonPossible) {
-      let isFail = (0, import_mathjs.evaluate)(`${roller.total}${compare.sign}${compare.value}`);
+      let isFail = (0, import_mathjs2.evaluate)(`${roller.total}${compare.sign}${compare.value}`);
       if (!isFail) {
         const maxReroll = 100;
         while (!isFail && rerollCount < maxReroll) {
@@ -246,7 +306,7 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
           }
           rerollCount++;
           if (res && res.total !== void 0)
-            isFail = (0, import_mathjs.evaluate)(`${res.total}${compare.sign}${compare.value}`);
+            isFail = (0, import_mathjs2.evaluate)(`${res.total}${compare.sign}${compare.value}`);
         }
         if (res) {
           return {
@@ -255,21 +315,262 @@ function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.node
             comment,
             compare,
             modifier: modificator,
-            pityLogs: rerollCount
+            pityLogs: rerollCount,
+            trivial: res.trivial ?? (compare?.trivial ? true : void 0)
           };
         }
       }
-    } else ;
+    }
+  }
+  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
+  };
+}
+function sharedRolls(dice, engine = import_rpg_dice_roller.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
+      );
+      try {
+        const evaluated = (0, import_mathjs2.evaluate)(toRoll);
+        results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
+        total += Number.parseInt(evaluated, 10);
+      } 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;
+      }
+    }
+  }
+  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 replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller.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 = (0, import_mathjs2.evaluate)(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 rollCompare(value, engine = import_rpg_dice_roller.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: (0, import_mathjs2.evaluate)(value), diceResult: value };
+    } catch (error) {
+      return { value: 0, diceResult: value };
+    }
+  }
+  return {
+    dice: value,
+    value: rollComp.total,
+    diceResult: rollComp?.result
+  };
+}
+
+// src/dice/compare.ts
+function isTrivialComparison(maxValue, minValue, compare) {
+  const canSucceed = canComparisonSucceed(maxValue, compare, minValue);
+  const canFail = canComparisonFail(maxValue, compare, minValue);
+  return !canSucceed || !canFail;
+}
+function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
+  switch (compare.sign) {
+    case ">":
+      return minRollValue <= compare.value;
+    // failure if roll <= value
+    case ">=":
+      return minRollValue < compare.value;
+    // failure if roll < value
+    case "<":
+      return maxRollValue >= compare.value;
+    // failure if roll >= value
+    case "<=":
+      return maxRollValue > compare.value;
+    // failure if roll > value
+    case "=":
+    case "==":
+      return minRollValue !== compare.value || maxRollValue !== compare.value;
+    // can differ
+    case "!=":
+      return minRollValue <= compare.value && compare.value <= maxRollValue;
+    // equality possible
+    default:
+      return true;
+  }
+}
+function getCompare(dice, compareRegex, engine = import_rpg_dice_roller2.NumberGenerator.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 = (0, import_mathjs3.evaluate)(rCompare.value.toString());
+    dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
+    compare = {
+      sign: compareSign,
+      value: total,
+      originalDice: rCompare.dice,
+      rollValue: rCompare.diceResult
+    };
+  } else {
+    const rcompare = rollCompare(calc, engine, pity);
+    compare = {
+      sign: compareSign,
+      value: rcompare.value,
+      originalDice: rcompare.dice,
+      rollValue: rcompare.diceResult
+    };
   }
-  return {
-    dice,
-    result: roller.output,
-    comment,
-    compare: compare ? compare : void 0,
-    modifier: modificator,
-    total: roller.total,
-    pityLogs: rerollCount > 0 ? rerollCount : void 0
-  };
+  return { dice, compare };
 }
 function canComparisonSucceed(maxRollValue, compare, minRollValue) {
   switch (compare.sign) {
@@ -292,13 +593,62 @@ function canComparisonSucceed(maxRollValue, compare, minRollValue) {
       return true;
   }
 }
+
+// src/dice/exploding.ts
+var import_mathjs5 = require("mathjs");
+
+// src/dice/signs.ts
+var import_rpg_dice_roller3 = require("@dice-roller/rpg-dice-roller");
+var import_mathjs4 = require("mathjs");
+
+// src/dice/replace.ts
+function replaceUnwantedText(dice) {
+  return dice.replaceAll(/[{}]/g, "").replaceAll(/s[ad]/gi, "");
+}
 function fixParenthesis(dice) {
   const parenthesisRegex = /d\((\d+)\)/g;
   return dice.replaceAll(parenthesisRegex, (_match, p1) => `d${p1}`);
 }
-function calculator(sign, value, total) {
-  if (sign === "^") sign = "**";
-  return (0, import_mathjs.evaluate)(`${total} ${sign} ${value}`);
+function replaceText(element, total, dice) {
+  return {
+    formule: element.replace(SYMBOL_DICE, `[${total}]`).replace(/%.*%/g, "").trim(),
+    diceAll: element.replace(SYMBOL_DICE, `[${dice.replace(COMMENT_REGEX, "")}]`).replace(/%.*%/g, "").trim()
+  };
+}
+function formatComment(dice) {
+  const commentsRegex = /\[(?<comments>.*?)\]/;
+  const commentsMatch = commentsRegex.exec(dice);
+  const comments = commentsMatch?.groups?.comments ? `${commentsMatch.groups.comments}` : "";
+  const diceWithoutBrackets = dice.replace(commentsRegex, "");
+  const optionalCommentsRegex = /\s+(#|\/\/)(?<comment>.*)/;
+  const optionalComments = optionalCommentsRegex.exec(diceWithoutBrackets);
+  const optional = optionalComments?.groups?.comment ? `${optionalComments.groups.comment.trim()}` : "";
+  let finalComment = "";
+  if (comments && optional) finalComment = `__${comments} ${optional}__ \u2014 `;
+  else if (comments) finalComment = `__${comments}__ \u2014 `;
+  else if (optional) finalComment = `__${optional}__ \u2014 `;
+  return finalComment;
+}
+
+// src/dice/signs.ts
+function matchComparison(sign, val, value) {
+  switch (sign) {
+    case ">":
+      return val > value;
+    case ">=":
+      return val >= value;
+    case "<":
+      return val < value;
+    case "<=":
+      return val <= value;
+    case "=":
+    case "==":
+      return val === value;
+    case "!=":
+      return val !== value;
+    default:
+      return false;
+  }
 }
 function inverseSign(sign) {
   switch (sign) {
@@ -318,155 +668,169 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller.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 = (0, import_mathjs.evaluate)(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 compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller3.NumberGenerator.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 = (0, import_mathjs.evaluate)(toCompare);
+    res = (0, import_mathjs4.evaluate)(toCompare);
   } catch (error) {
     res = roll(toCompare, engine, pity);
   }
   if (typeof res === "boolean") {
+    const detectedTrivial = rollBounds && compareResult.compare ? isTrivialComparison(rollBounds.max, rollBounds.min, compareResult.compare) : false;
+    if (detectedTrivial && compareResult.compare) compareResult.compare.trivial = true;
+    if (detectedTrivial) trivial = true;
     results = replaceInFormula(element, diceResult, compareResult, res, engine, pity);
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
-      const toEvaluate = (0, import_mathjs.evaluate)(
+      const toEvaluate = (0, import_mathjs4.evaluate)(
         `${diceResult2.total}${diceResult2.compare.sign}${diceResult2.compare.value}`
       );
       const sign = toEvaluate ? "\u2713" : "\u2715";
       const invertedSign = toEvaluate ? diceResult2.compare.sign : inverseSign(diceResult2.compare.sign);
       const dice = replaceText(element, 0, diceResult2.dice).diceAll;
       results = `${sign} ${dice}: ${diceResult2.result.split(":").splice(1).join(":").trim()}${invertedSign}${diceResult2.compare.value}`;
+      if (diceResult2.compare.trivial) trivial = true;
     }
   }
-  return { dice: compareResult.dice, results };
+  return { dice: compareResult.dice, results, compare: compareResult.compare, trivial };
 }
-function replaceText(element, total, dice) {
+
+// src/dice/exploding.ts
+var EXPLODING_SUCCESS_REGEX = /(!(?:>>=|<<=|!==|!!==|>>|<<|==|!=))(-?\d+(?:\.\d+)?)/;
+function normalizeExplodingSuccess(dice) {
+  const match = dice.match(EXPLODING_SUCCESS_REGEX);
+  if (!match) return void 0;
+  const [, doubledSignRaw, valueStr] = match;
+  let doubledSign;
+  if (doubledSignRaw === "!!==") doubledSign = "==";
+  else if (doubledSignRaw === "!==") doubledSign = "!==";
+  else doubledSign = doubledSignRaw.replace(/^!/, "");
+  const signMap = {
+    ">>": ">",
+    "<<": "<",
+    ">>=": ">=",
+    "<<=": "<=",
+    "==": "=",
+    "!==": "!=",
+    "!!==": "="
+  };
+  const normalizedSign = signMap[doubledSign];
+  if (!normalizedSign) return void 0;
+  let parsedValue = Number.parseFloat(valueStr);
+  if (Number.isNaN(parsedValue)) {
+    try {
+      parsedValue = Number.parseFloat((0, import_mathjs5.evaluate)(valueStr));
+    } catch (_error) {
+      parsedValue = 0;
+    }
+  }
+  const normalizedSegment = "!";
+  const replacedDice = dice.replace(match[0], normalizedSegment);
   return {
-    formule: element.replace(SYMBOL_DICE, `[${total}]`).replace(/%.*%/g, "").trim(),
-    diceAll: element.replace(SYMBOL_DICE, `[${dice.replace(COMMENT_REGEX, "")}]`).replace(/%.*%/g, "").trim()
+    dice: replacedDice,
+    originalDice: dice,
+    sign: normalizedSign,
+    value: parsedValue,
+    normalizedSegment,
+    originalSegment: match[0]
   };
 }
-function formatComment(dice) {
-  const commentsRegex = /\[(?<comments>.*?)\]/;
-  const commentsMatch = commentsRegex.exec(dice);
-  const comments = commentsMatch?.groups?.comments ? `${commentsMatch.groups.comments}` : "";
-  const diceWithoutBrackets = dice.replace(commentsRegex, "");
-  const optionalCommentsRegex = /\s+(#|\/\/)(?<comment>.*)/;
-  const optionalComments = optionalCommentsRegex.exec(diceWithoutBrackets);
-  const optional = optionalComments?.groups?.comment ? `${optionalComments.groups.comment.trim()}` : "";
-  let finalComment = "";
-  if (comments && optional) finalComment = `__${comments} ${optional}__ \u2014 `;
-  else if (comments) finalComment = `__${comments}__ \u2014 `;
-  else if (optional) finalComment = `__${optional}__ \u2014 `;
-  return finalComment;
+function countExplodingSuccesses(diceRoll, sign, value) {
+  const rollsArray = Array.isArray(diceRoll) ? diceRoll : [diceRoll];
+  const flatValues = [];
+  for (const dr of rollsArray) {
+    const groups = dr.rolls ?? [];
+    for (const group of groups) {
+      const innerRolls = group.rolls ?? [];
+      for (const roll2 of innerRolls) {
+        if (typeof roll2.value === "number") flatValues.push(roll2.value);
+      }
+    }
+  }
+  return flatValues.reduce(
+    (acc, current) => acc + (matchComparison(sign, current, value) ? 1 : 0),
+    0
+  );
 }
-function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
-  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(";");
-  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;
+
+// src/dice/extract.ts
+var import_rpg_dice_roller4 = require("@dice-roller/rpg-dice-roller");
+function getModifier(dice) {
+  const modifier = dice.matchAll(/(\+|-|%|\/|\^|\*|\*{2})(\d+)/gi);
+  let modificator;
+  for (const mod of modifier) {
+    if (modificator) {
+      const sign = modificator.sign;
+      let value = modificator.value;
+      if (sign) value = calculator(sign, value, Number.parseInt(mod[2], 10));
+      modificator = {
+        sign: mod[1],
+        value
+      };
+    } else {
+      modificator = {
+        sign: mod[1],
+        value: Number.parseInt(mod[2], 10)
+      };
+    }
   }
-  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;
+  return modificator;
+}
+function extractValuesFromOutput(output) {
+  const values = [];
+  const regex = /\[([^\]]+)\]/g;
+  let match;
+  while ((match = regex.exec(output)) !== null) {
+    const segmentValues = match[1].split(",").map((v) => Number.parseInt(v.replace(/[!*]/g, "").trim(), 10)).filter((v) => !Number.isNaN(v));
+    values.push(...segmentValues);
   }
-  if (!diceResult || !diceResult.total) return void 0;
-  results.push(`\u203B ${comments}${diceResult.result}`);
-  let total = diceResult.total;
-  diceResult.comment = mainComment;
-  if (!total) return diceResult;
-  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
-      );
-      toRoll = compareResult.dice;
-      results.push(compareResult.results);
-    } else {
-      const { formule, diceAll } = replaceText(
-        element,
-        diceResult.total,
-        diceResult.dice
-      );
-      try {
-        const evaluated = (0, import_mathjs.evaluate)(toRoll);
-        results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
-        total += Number.parseInt(evaluated, 10);
-      } catch (error) {
-        const evaluated = roll(toRoll, engine, pity);
-        if (evaluated)
-          results.push(
-            `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
-          );
-        else results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
-        total += evaluated?.total ?? 0;
-      }
+  return values;
+}
+function getRollBounds(dice, engine = import_rpg_dice_roller4.NumberGenerator.engines.nodeCrypto) {
+  try {
+    const roller = new import_rpg_dice_roller4.DiceRoller();
+    import_rpg_dice_roller4.NumberGenerator.generator.engine = engine;
+    const rollResult = roller.roll(dice);
+    const instance = Array.isArray(rollResult) ? rollResult[0] : rollResult;
+    const { minTotal, maxTotal } = instance;
+    return { min: minTotal, max: maxTotal };
+  } catch (error) {
+  }
+  return void 0;
+}
+
+// src/engine.ts
+var import_rpg_dice_roller5 = require("@dice-roller/rpg-dice-roller");
+function getEngineId(engine) {
+  if (engine === import_rpg_dice_roller5.NumberGenerator.engines.nodeCrypto) return "nodeCrypto";
+  if (engine === import_rpg_dice_roller5.NumberGenerator.engines.nativeMath) return "nativeMath";
+  if (engine === import_rpg_dice_roller5.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_roller5.NumberGenerator.engines.nativeMath;
+    case "browserCrypto":
+      return import_rpg_dice_roller5.NumberGenerator.engines.browserCrypto;
+    case "nodeCrypto":
+      return import_rpg_dice_roller5.NumberGenerator.engines.nodeCrypto;
+    default:
+      return import_rpg_dice_roller5.NumberGenerator.engines.nativeMath;
   }
-  if (hidden)
-    results.shift();
-  return {
-    dice: diceMain,
-    result: results.join(";"),
-    comment: mainComment,
-    compare: diceResult.compare,
-    modifier: diceResult.modifier,
-    total
-  };
 }
 
 // src/errors.ts
@@ -534,13 +898,13 @@ var NoStatisticsError = class extends Error {
   }
 };
 
-// src/interfaces/constant.ts
-var COMMENT_REGEX = /\s+(#|\/{2}|\[|\/\*)(?<comment>.*)/gi;
-var SIGN_REGEX = /==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=/;
-var SIGN_REGEX_SPACE = /(==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=)(\S+)/;
-var SYMBOL_DICE = "&";
-var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
-var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
+// src/interfaces/index.ts
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["Ascending"] = "sa";
+  SortOrder2["Descending"] = "sd";
+  SortOrder2["None"] = "none";
+  return SortOrder2;
+})(SortOrder || {});
 
 // src/interfaces/zod.ts
 var import_zod = require("zod");
@@ -599,9 +963,9 @@ var templateSchema = import_zod.z.object({
 });
 
 // src/utils.ts
-var import_mathjs2 = require("mathjs");
+var import_mathjs6 = require("mathjs");
 var import_uniformize = require("uniformize");
-var import_rpg_dice_roller2 = require("@dice-roller/rpg-dice-roller");
+var import_rpg_dice_roller6 = require("@dice-roller/rpg-dice-roller");
 var import_random_js = require("random-js");
 function escapeRegex(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -636,11 +1000,29 @@ function generateStatsDice(originalDice, stats, dollarValue) {
         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 || keyStd.includes(tokenStd) || tokenStd.includes(keyStd) || keyStd.startsWith(tokenStd) || tokenStd.startsWith(keyStd)) {
+          if (tokenStd === keyStd) {
             bestKey = key;
             bestScore = 1;
             break;
@@ -674,7 +1056,7 @@ function replaceFormulaInDice(dice) {
     if (match.groups?.formula) {
       const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
       try {
-        const result = (0, import_mathjs2.evaluate)(formulae);
+        const result = (0, import_mathjs6.evaluate)(formulae);
         modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
       } catch (error) {
         throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
@@ -689,43 +1071,17 @@ function cleanedDice(dice) {
 function isNumber(value) {
   return value !== void 0 && (typeof value === "number" || !Number.isNaN(Number(value)) && typeof value === "string" && value.trim().length > 0);
 }
-function replaceExpByRandom(dice, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function replaceExpByRandom(dice, engine = import_rpg_dice_roller6.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) {
+function randomInt(min, max, engine = import_rpg_dice_roller6.NumberGenerator.engines.nodeCrypto, rng) {
   if (!rng) rng = new import_random_js.Random(engine || void 0);
   return rng.integer(min, max);
 }
-function getEngineId(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;
-  }
-}
 function levenshteinDistance(a, b) {
   if (a === b) return 0;
   const al = a.length;
@@ -753,13 +1109,24 @@ function similarityScore(a, b) {
   const max = Math.max(la, lb);
   return 1 - dist / max;
 }
+function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller6.NumberGenerator.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
-var import_mathjs3 = require("mathjs");
+var import_mathjs7 = require("mathjs");
 var import_random_js2 = require("random-js");
 var import_uniformize2 = require("uniformize");
-var import_rpg_dice_roller3 = require("@dice-roller/rpg-dice-roller");
-function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto, pity) {
+var import_rpg_dice_roller7 = require("@dice-roller/rpg-dice-roller");
+function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto, pity) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
     const names = Object.keys(allStats);
@@ -779,7 +1146,7 @@ function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller3.Numb
     throw new DiceTypeError(dice, "evalStatsDice", error);
   }
 }
-function diceRandomParse(value, template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function diceRandomParse(value, template, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   if (!template.statistics) return replaceFormulaInDice(value.standardize());
   value = value.standardize();
   const statNames = Object.keys(template.statistics);
@@ -801,7 +1168,7 @@ function diceRandomParse(value, template, engine = import_rpg_dice_roller3.Numbe
   }
   return replaceFormulaInDice(newDice);
 }
-function diceTypeRandomParse(dice, template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function diceTypeRandomParse(dice, template, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   dice = replaceExpByRandom(dice);
   if (!template.statistics) return dice;
   const firstStatNotcombinaison = Object.keys(template.statistics).find(
@@ -823,7 +1190,7 @@ function evalCombinaison(combinaison, stats) {
       formula = formula.replace(regex, value.toString());
     }
     try {
-      newStats[stat] = (0, import_mathjs3.evaluate)(formula);
+      newStats[stat] = (0, import_mathjs7.evaluate)(formula);
     } catch (error) {
       throw new FormulaError(stat, "evalCombinaison", error);
     }
@@ -837,7 +1204,7 @@ function evalOneCombinaison(combinaison, stats) {
     formula = formula.replace(regex, value.toString());
   }
   try {
-    return (0, import_mathjs3.evaluate)(formula);
+    return (0, import_mathjs7.evaluate)(formula);
   } catch (error) {
     throw new FormulaError(combinaison, "evalOneCombinaison", error);
   }
@@ -849,7 +1216,7 @@ function convertNumber(number) {
   if (isNumber(number)) return Number.parseInt(number.toString(), 10);
   return void 0;
 }
-function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   const parsedTemplate = templateSchema.parse(template);
   const { success, failure } = parsedTemplate.critical ?? {};
   const criticicalVal = {
@@ -904,7 +1271,7 @@ function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_r
   testStatCombinaison(statistiqueTemplate, engine);
   return statistiqueTemplate;
 }
-function testDiceRegistered(template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function testDiceRegistered(template, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   if (!template.damage) return;
   if (Object.keys(template.damage).length === 0) throw new EmptyObjectError();
   if (Object.keys(template.damage).length > 25) throw new TooManyDice();
@@ -920,7 +1287,7 @@ function testDiceRegistered(template, engine = import_rpg_dice_roller3.NumberGen
     }
   }
 }
-function testStatCombinaison(template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function testStatCombinaison(template, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   if (!template.statistics) return;
   const onlycombinaisonStats = Object.fromEntries(
     Object.entries(template.statistics).filter(
@@ -946,7 +1313,7 @@ function testStatCombinaison(template, engine = import_rpg_dice_roller3.NumberGe
       formula = formula.replace(regex, randomStatValue.toString());
     }
     try {
-      (0, import_mathjs3.evaluate)(formula);
+      (0, import_mathjs7.evaluate)(formula);
     } catch (e) {
       error.push(stat);
     }
@@ -954,9 +1321,9 @@ function testStatCombinaison(template, engine = import_rpg_dice_roller3.NumberGe
   if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
   return;
 }
-function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
+function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto) {
   let randomStatValue = total + 1;
-  const random = new import_random_js2.Random(engine || import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto);
+  const random = new import_random_js2.Random(engine || import_rpg_dice_roller7.NumberGenerator.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);
@@ -970,6 +1337,7 @@ function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roll
   COMMENT_REGEX,
   DETECT_CRITICAL,
   DiceTypeError,
+  EXPLODING_SUCCESS_REGEX,
   EmptyObjectError,
   FormulaError,
   MaxGreater,
@@ -978,9 +1346,14 @@ function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roll
   SIGN_REGEX,
   SIGN_REGEX_SPACE,
   SYMBOL_DICE,
+  SortOrder,
   TooManyDice,
   TooManyStats,
   calculator,
+  canComparisonFail,
+  canComparisonSucceed,
+  compareSignFormule,
+  countExplodingSuccesses,
   createCriticalCustom,
   diceRandomParse,
   diceTypeRandomParse,
@@ -988,15 +1361,29 @@ function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roll
   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,