@dicelette/core 1.23.1 → 1.24.1

package/dist/index.mjs

@@ -1,6 +1,341 @@
-// src/dice.ts
-import { DiceRoller, NumberGenerator } from "@dice-roller/rpg-dice-roller";
+// 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/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;
+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/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 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";
+
+// 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 (!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);
+    }
+    dice = result;
+  }
+  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
+  return replaceFormulaInDice(dice);
+}
+function replaceFormulaInDice(dice) {
+  const formula = /(?<formula>\{{2}(.+?)}{2})/gim;
+  let match;
+  let modifiedDice = dice;
+  while ((match = formula.exec(dice)) !== null) {
+    if (match.groups?.formula) {
+      const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
+      try {
+        const result = evaluate(formulae);
+        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
+      } catch (error) {
+        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
+      }
+    }
+  }
+  return cleanedDice(modifiedDice);
+}
+function cleanedDice(dice) {
+  return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+").replaceAll("=>", ">=").replaceAll("=<", "<=").trimEnd();
+}
+function isNumber(value) {
+  return value !== void 0 && (typeof value === "number" || !Number.isNaN(Number(value)) && typeof value === "string" && value.trim().length > 0);
+}
+function replaceExpByRandom(dice, engine = 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 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
 function isTrivialComparison(maxValue, minValue, compare) {
   const canSucceed = canComparisonSucceed(maxValue, compare, minValue);
   const canFail = canComparisonFail(maxValue, compare, minValue);
@@ -31,7 +366,26 @@ function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
       return true;
   }
 }
-function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCrypto, pity) {
+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, "");
@@ -42,7 +396,7 @@ function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCry
   if (sign) {
     const toCalc = calc.replace(SIGN_REGEX, "").replace(/\s/g, "").replace(/;(.*)/, "");
     const rCompare = rollCompare(toCalc, engine, pity);
-    const total = evaluate(rCompare.value.toString());
+    const total = evaluate2(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
       sign: compareSign,
@@ -61,156 +415,6 @@ function getCompare(dice, compareRegex, engine = NumberGenerator.engines.nodeCry
   }
   return { dice, compare };
 }
-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: 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 = 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 roll(dice, engine = NumberGenerator.engines.nodeCrypto, pity) {
-  dice = standardizeDice(replaceFormulaInDice(dice)).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
-  if (!dice.includes("d")) return void 0;
-  dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
-  const compareRegex = dice.match(SIGN_REGEX_SPACE);
-  let compare;
-  if (dice.includes(";")) return sharedRolls(dice, engine);
-  dice = fixParenthesis(dice);
-  const modificator = getModifier(dice);
-  if (compareRegex) {
-    const compareResult = getCompare(dice, compareRegex, engine, pity);
-    dice = compareResult.dice;
-    compare = compareResult.compare;
-  }
-  if (dice.match(/\d+?#(.*)/)) {
-    const diceArray = dice.split("#");
-    const numberOfDice = Number.parseInt(diceArray[0], 10);
-    const diceToRoll = diceArray[1].replace(COMMENT_REGEX, "");
-    const commentsMatch = diceArray[1].match(COMMENT_REGEX);
-    const comments = commentsMatch ? commentsMatch[2] : 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);
-      }
-    }
-    return {
-      dice: diceToRoll,
-      result: roller2.output,
-      comment: comments,
-      compare: compare ? compare : void 0,
-      modifier: modificator,
-      total: roller2.total
-    };
-  }
-  const roller = new DiceRoller();
-  NumberGenerator.generator.engine = engine;
-  const diceWithoutComment = dice.replace(COMMENT_REGEX, "").trimEnd();
-  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 = evaluate(`${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 = evaluate(`${res.total}${compare.sign}${compare.value}`);
-        }
-        if (res) {
-          return {
-            ...res,
-            dice,
-            comment,
-            compare,
-            modifier: modificator,
-            pityLogs: rerollCount
-          };
-        }
-      }
-    } else ;
-  }
-  return {
-    dice,
-    result: roller.output,
-    comment,
-    compare: compare ? compare : void 0,
-    modifier: modificator,
-    total: roller.total,
-    pityLogs: rerollCount > 0 ? rerollCount : void 0
-  };
-}
 function canComparisonSucceed(maxRollValue, compare, minRollValue) {
   switch (compare.sign) {
     case ">":
@@ -232,81 +436,22 @@ function canComparisonSucceed(maxRollValue, compare, minRollValue) {
       return true;
   }
 }
+
+// src/dice/exploding.ts
+import { evaluate as evaluate4 } from "mathjs";
+
+// src/dice/signs.ts
+import { NumberGenerator as NumberGenerator4 } from "@dice-roller/rpg-dice-roller";
+import { evaluate as evaluate3 } from "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 evaluate(`${total} ${sign} ${value}`);
-}
-function inverseSign(sign) {
-  switch (sign) {
-    case "<":
-      return ">";
-    case ">":
-      return "<";
-    case "<=":
-      return ">=";
-    case ">=":
-      return "<=";
-    case "=":
-      return "!=";
-    case "==":
-      return "!=";
-    case "!=":
-      return "==";
-  }
-}
-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 = 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 = NumberGenerator.engines.nodeCrypto, pity) {
-  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 = evaluate(toCompare);
-  } catch (error) {
-    res = roll(toCompare, engine, pity);
-  }
-  if (typeof res === "boolean") {
-    trivial = true;
-    if (compareResult.compare) compareResult.compare.trivial = true;
-    results = replaceInFormula(element, diceResult, compareResult, res, engine, pity);
-  } else if (res instanceof Object) {
-    const diceResult2 = res;
-    if (diceResult2.compare) {
-      const toEvaluate = 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, compare: compareResult.compare, trivial };
-}
 function replaceText(element, total, dice) {
   return {
     formule: element.replace(SYMBOL_DICE, `[${total}]`).replace(/%.*%/g, "").trim(),
@@ -327,390 +472,726 @@ function formatComment(dice) {
   else if (optional) finalComment = `__${optional}__ \u2014 `;
   return finalComment;
 }
-function sharedRolls(dice, engine = 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;
-  }
-  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;
+
+// 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;
   }
-  if (!diceResult || !diceResult.total) return void 0;
-  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 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);
-      if (!aggregatedCompare && compareResult.compare) aggregatedCompare = compareResult.compare;
-      if (compareResult.trivial) hasTrivialComparison = true;
-    } else {
-      const { formule, diceAll } = replaceText(
-        element,
-        diceResult.total,
-        diceResult.dice
+}
+function inverseSign(sign) {
+  switch (sign) {
+    case "<":
+      return ">";
+    case ">":
+      return "<";
+    case "<=":
+      return ">=";
+    case ">=":
+      return "<=";
+    case "=":
+      return "!=";
+    case "==":
+      return "!=";
+    case "!=":
+      return "==";
+  }
+}
+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 = evaluate3(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 = evaluate3(
+        `${diceResult2.total}${diceResult2.compare.sign}${diceResult2.compare.value}`
       );
-      try {
-        const evaluated = 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;
-      }
+      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;
     }
   }
-  if (hidden)
-    results.shift();
+  return { dice: compareResult.dice, results, compare: compareResult.compare, trivial };
+}
+
+// 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(evaluate4(valueStr));
+    } catch (_error) {
+      parsedValue = 0;
+    }
+  }
+  const normalizedSegment = "!";
+  const replacedDice = dice.replace(match[0], normalizedSegment);
   return {
-    dice: diceMain,
-    result: results.join(";"),
-    comment: mainComment,
-    compare: hasTrivialComparison && aggregatedCompare ? { ...aggregatedCompare, trivial: true } : aggregatedCompare,
-    modifier: diceResult.modifier,
-    total
+    dice: replacedDice,
+    originalDice: dice,
+    sign: normalizedSign,
+    value: parsedValue,
+    normalizedSegment,
+    originalSegment: match[0]
   };
 }
+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
+  );
+}
 
-// 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/extract.ts
+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;
+  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)
+      };
+    }
   }
-};
-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;
+  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);
   }
-};
-var MaxGreater = class extends Error {
-  name;
-  value;
-  max;
-  constructor(value, max) {
-    super(value.toString());
-    this.name = "Max_Greater";
-    this.value = value;
-    this.max = max;
+  return values;
+}
+function getRollBounds(dice, engine = NumberGenerator5.engines.nodeCrypto) {
+  try {
+    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;
+    return { min: minTotal, max: maxTotal };
+  } catch (error) {
   }
-};
-var EmptyObjectError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Empty_Object";
+  return void 0;
+}
+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;
+    }
   }
-};
-var TooManyDice = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Dice";
+  return toRoll;
+}
+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;
   }
-};
-var TooManyStats = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "Too_Many_Stats";
+  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);
   }
-};
-var NoStatisticsError = class extends Error {
-  name;
-  constructor() {
-    super();
-    this.name = "No_Statistics";
+  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;
+    }
   }
-};
-
-// 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;
+  return {
+    dice,
+    diceDisplay,
+    explodingSuccess,
+    isSharedRoll,
+    isSharedCurly,
+    isCurlyBulk,
+    bulkContent,
+    isSimpleCurly
+  };
+}
 
-// 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"]
-    });
+// 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 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 evaluate2 } 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;
+  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
+    );
+  }
+  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);
+    }
+  }
+  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
+        );
       }
-      if (!outsideText) {
-        continue;
+      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));
       }
-      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();
-        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)) {
-            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();
+    } catch (error) {
+      throw new DiceTypeError(diceToRoll, "roll", error);
+    }
+  }
+  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 {
-          result += token;
+          successCount = flatValues.filter(
+            (val) => matchComparison(mappedSign, val, mappedValue)
+          ).length;
         }
-        lastIndex = tokenRegex.lastIndex;
       }
-      result += outsideText.slice(lastIndex);
     }
-    dice = result;
   }
-  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
-  return replaceFormulaInDice(dice);
+  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
+  };
 }
-function replaceFormulaInDice(dice) {
-  const formula = /(?<formula>\{{2}(.+?)}{2})/gim;
-  let match;
-  let modifiedDice = dice;
-  while ((match = formula.exec(dice)) !== null) {
-    if (match.groups?.formula) {
-      const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
-      try {
-        const result = evaluate2(formulae);
-        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
-      } catch (error) {
-        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
-      }
+
+// 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 };
+  }
+  let isFail = evaluate7(`${roller.total}${compare.sign}${compare.value}`);
+  if (isFail) {
+    return { rerollCount: 0 };
+  }
+  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}`);
     }
   }
-  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 = 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();
-  });
+  return { rerollCount, result: res };
 }
-function randomInt(min, max, engine = NumberGenerator2.engines.nodeCrypto, rng) {
-  if (!rng) rng = new Random(engine || void 0);
-  return rng.integer(min, max);
-}
-function getEngineId(engine) {
-  if (engine === NumberGenerator2.engines.nodeCrypto) return "nodeCrypto";
-  if (engine === NumberGenerator2.engines.nativeMath) return "nativeMath";
-  if (engine === NumberGenerator2.engines.browserCrypto) return "browserCrypto";
+
+// 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 {
-    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;
+    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)
+      };
     }
-  } catch {
   }
-  return "unknown";
-}
-function getEngine(engine) {
-  switch (engine) {
-    case "nativeMath":
-      return NumberGenerator2.engines.nativeMath;
-    case "browserCrypto":
-      return NumberGenerator2.engines.browserCrypto;
-    case "nodeCrypto":
-      return NumberGenerator2.engines.nodeCrypto;
-    default:
-      return NumberGenerator2.engines.nativeMath;
+  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 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);
+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 evaluated = evaluate8(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;
+      }
     }
-    for (let j = 0; j <= bl; j++) v0[j] = v1[j];
   }
-  return v1[bl];
+  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 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 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}`;
+  }
 }
 
 // src/verify_template.ts
-import { evaluate as evaluate3 } from "mathjs";
+import { evaluate as evaluate9 } from "mathjs";
 import { Random as Random2 } from "random-js";
 import "uniformize";
-import { NumberGenerator as NumberGenerator3 } from "@dice-roller/rpg-dice-roller";
-function evalStatsDice(testDice, allStats, engine = NumberGenerator3.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);
@@ -730,7 +1211,7 @@ function evalStatsDice(testDice, allStats, engine = NumberGenerator3.engines.nod
     throw new DiceTypeError(dice, "evalStatsDice", error);
   }
 }
-function diceRandomParse(value, template, engine = NumberGenerator3.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);
@@ -752,7 +1233,7 @@ function diceRandomParse(value, template, engine = NumberGenerator3.engines.node
   }
   return replaceFormulaInDice(newDice);
 }
-function diceTypeRandomParse(dice, template, engine = NumberGenerator3.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(
@@ -774,7 +1255,7 @@ function evalCombinaison(combinaison, stats) {
       formula = formula.replace(regex, value.toString());
     }
     try {
-      newStats[stat] = evaluate3(formula);
+      newStats[stat] = evaluate9(formula);
     } catch (error) {
       throw new FormulaError(stat, "evalCombinaison", error);
     }
@@ -788,7 +1269,7 @@ function evalOneCombinaison(combinaison, stats) {
     formula = formula.replace(regex, value.toString());
   }
   try {
-    return evaluate3(formula);
+    return evaluate9(formula);
   } catch (error) {
     throw new FormulaError(combinaison, "evalOneCombinaison", error);
   }
@@ -800,7 +1281,7 @@ function convertNumber(number) {
   if (isNumber(number)) return Number.parseInt(number.toString(), 10);
   return void 0;
 }
-function verifyTemplateValue(template, verify = true, engine = NumberGenerator3.engines.nodeCrypto) {
+function verifyTemplateValue(template, verify = true, engine = NumberGenerator8.engines.nodeCrypto) {
   const parsedTemplate = templateSchema.parse(template);
   const { success, failure } = parsedTemplate.critical ?? {};
   const criticicalVal = {
@@ -855,7 +1336,7 @@ function verifyTemplateValue(template, verify = true, engine = NumberGenerator3.
   testStatCombinaison(statistiqueTemplate, engine);
   return statistiqueTemplate;
 }
-function testDiceRegistered(template, engine = NumberGenerator3.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();
@@ -871,7 +1352,7 @@ function testDiceRegistered(template, engine = NumberGenerator3.engines.nodeCryp
     }
   }
 }
-function testStatCombinaison(template, engine = NumberGenerator3.engines.nodeCrypto) {
+function testStatCombinaison(template, engine = NumberGenerator8.engines.nodeCrypto) {
   if (!template.statistics) return;
   const onlycombinaisonStats = Object.fromEntries(
     Object.entries(template.statistics).filter(
@@ -897,7 +1378,7 @@ function testStatCombinaison(template, engine = NumberGenerator3.engines.nodeCry
       formula = formula.replace(regex, randomStatValue.toString());
     }
     try {
-      evaluate3(formula);
+      evaluate9(formula);
     } catch (e) {
       error.push(stat);
     }
@@ -905,9 +1386,9 @@ function testStatCombinaison(template, engine = NumberGenerator3.engines.nodeCry
   if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
   return;
 }
-function generateRandomStat(total = 100, max, min, engine = NumberGenerator3.engines.nodeCrypto) {
+function generateRandomStat(total = 100, max, min, engine = NumberGenerator8.engines.nodeCrypto) {
   let randomStatValue = total + 1;
-  const random = new Random2(engine || NumberGenerator3.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);
@@ -928,9 +1409,9 @@ export {
   SIGN_REGEX,
   SIGN_REGEX_SPACE,
   SYMBOL_DICE,
+  SortOrder,
   TooManyDice,
   TooManyStats,
-  calculator,
   createCriticalCustom,
   diceRandomParse,
   diceTypeRandomParse,
@@ -946,6 +1427,7 @@ export {
   randomInt,
   replaceExpByRandom,
   replaceFormulaInDice,
+  replaceInFormula,
   roll,
   standardizeDice,
   templateSchema,