@dicelette/core 1.22.2 → 1.23.0

package/README.md

@@ -8,6 +8,47 @@ This README documents the public API exported by the `core` package. It lists ty
 
 The `core` module provides small utilities to parse and evaluate dice notation, to generate and replace statistical values in dice expressions, and to validate statistical templates. The API is intended to be consumed by higher-level modules (bot, CLI, etc.).
 
+## Pity System
+
+The pity system is an optional feature that automatically re-rolls dice when a comparison fails, ensuring successful outcomes. This is useful in role-playing games where certain rolls must succeed (e.g., a critical save action).
+
+### How It Works
+
+When the `pity` parameter is set to `true` in the `roll()` function and the dice expression includes a comparison operator (e.g., `1d6>=5`), the system:
+
+1. Evaluates the initial roll against the comparison condition
+2. If the condition is **not met**, automatically re-rolls and repeats until success
+3. Tracks the number of re-rolls in the `pityLogs` field of the result
+
+### Limitations
+
+The pity system only activates when a **comparison is theoretically possible**. For example:
+
+- `1d6>=7` — **Ignored** (impossible: maximum roll is 6)
+- `1d6>=5` — **Active** (possible: can roll 5 or 6)
+- `2d6>=12` — **Active** (possible: can roll 12)
+- `1d20>20` — **Ignored** (impossible: maximum roll is 20, not greater than 20)
+
+### Example
+
+```javascript
+const result = roll("1d6>=5", null, true);
+// If first roll is 3, pity system re-rolls
+// If second roll is 2, pity system re-rolls again
+// If third roll is 6, comparison succeeds and stops
+// result.total = 6
+// result.pityLogs = 2 (number of re-rolls)
+```
+
+Without pity (`pity = false` or `undefined`), a roll of `1d6>=5` would return the result regardless of comparison outcome, with no re-rolls.
+
+### Usage Notes
+
+- The pity system only applies when the roll includes a comparison operator
+- The system has a safety limit of 100 re-rolls to prevent infinite loops
+- The `pityLogs` field is only present in the result if at least one re-roll occurred
+- Impossible comparisons are silently ignored (no error thrown)
+
 ## Public API
 
 Note: when a parameter `engine` is shown it usually defaults to the `NumberGenerator.engines.nodeCrypto` engine (from `@dice-roller/rpg-dice-roller`) unless otherwise specified.
@@ -21,6 +62,7 @@ Note: when a parameter `engine` is shown it usually defaults to the `NumberGener
 - compare?: ComparedValue — Optional comparison attached to the roll
 - modifier?: Modifier — Optional modifier applied to the roll
 - total?: number — Optional numeric total of the roll
+- pityLogs?: number — Optional count of re-rolls triggered by the pity system (see Pity System below)
 
 #### Interface: Compare
 - sign: "<" | ">" | ">=" | "<=" | "=" | "!=" | "=="
@@ -112,9 +154,10 @@ Note: when a parameter `engine` is shown it usually defaults to the `NumberGener
 
 ### Dice functions (`src/dice.ts`)
 
-#### Function: roll(dice: string, engine?: Engine | null): Resultat | undefined
+#### Function: roll(dice: string, engine?: Engine | null, pity?: boolean): Resultat | undefined
 - Parse a dice notation string and perform the roll(s) using `rpg-dice-roller`.
 - Supports comments, grouped/shared rolls, comparisons, modifiers and custom notation (see module docs).
+- If `pity` is `true` and the roll includes a comparison (e.g., `1d6>=5`), automatically re-rolls until the comparison succeeds (see Pity System below).
 - Returns `Resultat` when a dice expression is recognized, otherwise `undefined`.
 - Throws `DiceTypeError` when the expression cannot be parsed or rolled.
 

package/dist/index.d.mts

@@ -13,8 +13,10 @@ declare function createCriticalCustom(dice: string, customCritical: CustomCritic
 /**
  * Parse the string provided and turn it as a readable dice for dice parser
  * @param dice {string}
+ * @param engine
+ * @param pity
  */
-declare function roll(dice: string, engine?: Engine | null): Resultat | undefined;
+declare function roll(dice: string, engine?: Engine | null, pity?: boolean): Resultat | undefined;
 /**
  * Evaluate a formula and replace "^" by "**" if any
  * @param {Sign} sign
@@ -84,6 +86,7 @@ interface Resultat {
      * Total of the roll
      */
     total?: number;
+    pityLogs?: number;
 }
 interface Compare {
     /**
@@ -94,6 +97,11 @@ interface Compare {
      * Value of the comparison
      */
     value: number;
+    /**
+     * Indicate if the comparison is "trivial"
+     * aka if the comparaison is always true or always false
+     */
+    trivial?: boolean;
 }
 /**
  * Sign format for calculation of modifier
@@ -355,13 +363,16 @@ declare function getEngine(engine: "nativeMath" | "browserCrypto" | "nodeCrypto"
  * Verify if the provided dice work with random value
  * @param testDice {string}
  * @param allStats {Record<string,number>}
+ * @param engine
+ * @param pity
  */
-declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null): string;
+declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null, pity?: boolean): string;
 /**
  * Generate a random dice and remove the formula (+ evaluate it)
  * Used for diceDamage only
  * @param value {string}
  * @param template {StatisticalTemplate}
+ * @param engine
  * @returns
  */
 declare function diceRandomParse(value: string, template: StatisticalTemplate, engine?: Engine | null): string;
@@ -369,6 +380,7 @@ declare function diceRandomParse(value: string, template: StatisticalTemplate, e
  * Same as damageDice but for DiceType
  * @param dice {string}
  * @param template {StatisticalTemplate}
+ * @param engine
  */
 declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
@@ -387,17 +399,20 @@ declare function evalOneCombinaison(combinaison: string, stats: Record<string, n
  * Parse the provided JSON and verify each field to check if everything could work when rolling
  * @param {unknown} template
  * @param {boolean} verify - If true, will roll the dices to check if everything is valid
+ * @param engine
  * @returns {StatisticalTemplate}
  */
 declare function verifyTemplateValue(template: unknown, verify?: boolean, engine?: Engine | null): StatisticalTemplate;
 /**
  * Test each damage roll from the template.damage
  * @param {StatisticalTemplate} template
+ * @param engine
  */
 declare function testDiceRegistered(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Test all combinaison with generated random value
  * @param {StatisticalTemplate} template
+ * @param engine
  */
 declare function testStatCombinaison(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
@@ -405,6 +420,7 @@ declare function testStatCombinaison(template: StatisticalTemplate, engine?: Eng
  * @param {number|undefined} total
  * @param {number | undefined} max
  * @param {number | undefined} min
+ * @param engine
  * @returns
  */
 declare function generateRandomStat(total?: number | undefined, max?: number, min?: number, engine?: Engine | null): number;

package/dist/index.d.ts

@@ -13,8 +13,10 @@ declare function createCriticalCustom(dice: string, customCritical: CustomCritic
 /**
  * Parse the string provided and turn it as a readable dice for dice parser
  * @param dice {string}
+ * @param engine
+ * @param pity
  */
-declare function roll(dice: string, engine?: Engine | null): Resultat | undefined;
+declare function roll(dice: string, engine?: Engine | null, pity?: boolean): Resultat | undefined;
 /**
  * Evaluate a formula and replace "^" by "**" if any
  * @param {Sign} sign
@@ -84,6 +86,7 @@ interface Resultat {
      * Total of the roll
      */
     total?: number;
+    pityLogs?: number;
 }
 interface Compare {
     /**
@@ -94,6 +97,11 @@ interface Compare {
      * Value of the comparison
      */
     value: number;
+    /**
+     * Indicate if the comparison is "trivial"
+     * aka if the comparaison is always true or always false
+     */
+    trivial?: boolean;
 }
 /**
  * Sign format for calculation of modifier
@@ -355,13 +363,16 @@ declare function getEngine(engine: "nativeMath" | "browserCrypto" | "nodeCrypto"
  * Verify if the provided dice work with random value
  * @param testDice {string}
  * @param allStats {Record<string,number>}
+ * @param engine
+ * @param pity
  */
-declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null): string;
+declare function evalStatsDice(testDice: string, allStats?: Record<string, number>, engine?: Engine | null, pity?: boolean): string;
 /**
  * Generate a random dice and remove the formula (+ evaluate it)
  * Used for diceDamage only
  * @param value {string}
  * @param template {StatisticalTemplate}
+ * @param engine
  * @returns
  */
 declare function diceRandomParse(value: string, template: StatisticalTemplate, engine?: Engine | null): string;
@@ -369,6 +380,7 @@ declare function diceRandomParse(value: string, template: StatisticalTemplate, e
  * Same as damageDice but for DiceType
  * @param dice {string}
  * @param template {StatisticalTemplate}
+ * @param engine
  */
 declare function diceTypeRandomParse(dice: string, template: StatisticalTemplate, engine?: Engine | null): string;
 /**
@@ -387,17 +399,20 @@ declare function evalOneCombinaison(combinaison: string, stats: Record<string, n
  * Parse the provided JSON and verify each field to check if everything could work when rolling
  * @param {unknown} template
  * @param {boolean} verify - If true, will roll the dices to check if everything is valid
+ * @param engine
  * @returns {StatisticalTemplate}
  */
 declare function verifyTemplateValue(template: unknown, verify?: boolean, engine?: Engine | null): StatisticalTemplate;
 /**
  * Test each damage roll from the template.damage
  * @param {StatisticalTemplate} template
+ * @param engine
  */
 declare function testDiceRegistered(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
  * Test all combinaison with generated random value
  * @param {StatisticalTemplate} template
+ * @param engine
  */
 declare function testStatCombinaison(template: StatisticalTemplate, engine?: Engine | null): void;
 /**
@@ -405,6 +420,7 @@ declare function testStatCombinaison(template: StatisticalTemplate, engine?: Eng
  * @param {number|undefined} total
  * @param {number | undefined} max
  * @param {number | undefined} min
+ * @param engine
  * @returns
  */
 declare function generateRandomStat(total?: number | undefined, max?: number, min?: number, engine?: Engine | null): number;

package/dist/index.js

@@ -61,17 +61,47 @@ module.exports = __toCommonJS(index_exports);
 // src/dice.ts
 var import_rpg_dice_roller = require("@dice-roller/rpg-dice-roller");
 var import_mathjs = require("mathjs");
-function getCompare(dice, compareRegex, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
-  if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))[><=!]+\d+\}?)|\{(.*)([><=!]+).*\}/))
+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[1];
+  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);
+    const rCompare = rollCompare(toCalc, engine, pity);
     const total = (0, import_mathjs.evaluate)(rCompare.value.toString());
     dice = dice.replace(SIGN_REGEX_SPACE, `${compareSign}${total}`);
     compare = {
@@ -81,7 +111,7 @@ function getCompare(dice, compareRegex, engine = import_rpg_dice_roller.NumberGe
       rollValue: rCompare.diceResult
     };
   } else {
-    const rcompare = rollCompare(calc, engine);
+    const rcompare = rollCompare(calc, engine, pity);
     compare = {
       sign: compareSign,
       value: rcompare.value,
@@ -91,11 +121,19 @@ function getCompare(dice, compareRegex, engine = import_rpg_dice_roller.NumberGe
   }
   return { dice, compare };
 }
-function rollCompare(value, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+function rollCompare(value, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
   if (isNumber(value)) return { value: Number.parseInt(value, 10) };
-  const rollComp = roll(value, engine);
-  if (!rollComp?.total)
-    return { value: (0, import_mathjs.evaluate)(value), diceResult: value };
+  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,
@@ -134,20 +172,20 @@ function getModifier(dice) {
   }
   return modificator;
 }
-function roll(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+function roll(dice, engine = import_rpg_dice_roller.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);
+    const compareResult = getCompare(dice, compareRegex, engine, pity);
     dice = compareResult.dice;
     compare = compareResult.compare;
   }
-  dice = fixParenthesis(dice);
-  const modificator = getModifier(dice);
   if (dice.match(/\d+?#(.*)/)) {
     const diceArray = dice.split("#");
     const numberOfDice = Number.parseInt(diceArray[0], 10);
@@ -175,22 +213,85 @@ 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 diceRoll;
   try {
-    roller.roll(diceWithoutComment);
+    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 = (0, import_mathjs.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 = (0, import_mathjs.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
+    total: roller.total,
+    pityLogs: rerollCount > 0 ? rerollCount : void 0
   };
 }
+function canComparisonSucceed(maxRollValue, compare, minRollValue) {
+  switch (compare.sign) {
+    case ">":
+      return maxRollValue > compare.value;
+    case ">=":
+      return maxRollValue >= compare.value;
+    case "<":
+      return compare.value > (minRollValue ?? 1);
+    // Au moins minRollValue possible
+    case "<=":
+      return compare.value >= (minRollValue ?? 1);
+    // Au moins minRollValue possible
+    case "=":
+    case "==":
+      return maxRollValue >= compare.value && compare.value >= (minRollValue ?? 1);
+    case "!=":
+      return maxRollValue !== compare.value || (minRollValue ?? 1) !== compare.value;
+    default:
+      return true;
+  }
+}
 function fixParenthesis(dice) {
   const parenthesisRegex = /d\((\d+)\)/g;
   return dice.replaceAll(parenthesisRegex, (_match, p1) => `d${p1}`);
@@ -217,7 +318,7 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
   const { formule, diceAll } = replaceText(
     element,
     diceResult.total ?? 0,
@@ -230,13 +331,13 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = impo
     evaluateRoll = (0, import_mathjs.evaluate)(compareResult.dice);
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
   } catch (error) {
-    const evaluateRoll2 = roll(compareResult.dice, engine);
+    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) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
   let results = "";
   const compareResult = getCompare(toRoll, compareRegex, engine);
   const toCompare = `${compareResult.dice}${compareResult.compare?.sign}${compareResult.compare?.value}`;
@@ -244,10 +345,10 @@ function compareSignFormule(toRoll, compareRegex, element, diceResult, engine =
   try {
     res = (0, import_mathjs.evaluate)(toCompare);
   } catch (error) {
-    res = roll(toCompare, engine);
+    res = roll(toCompare, engine, pity);
   }
   if (typeof res === "boolean") {
-    results = replaceInFormula(element, diceResult, compareResult, res, engine);
+    results = replaceInFormula(element, diceResult, compareResult, res, engine, pity);
   } else if (res instanceof Object) {
     const diceResult2 = res;
     if (diceResult2.compare) {
@@ -271,17 +372,18 @@ function replaceText(element, total, dice) {
 function formatComment(dice) {
   const commentsRegex = /\[(?<comments>.*?)\]/;
   const commentsMatch = commentsRegex.exec(dice);
-  const optionalComments = OPTIONAL_COMMENT.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 = `__${commentsMatch?.groups?.comments} ${optionalComments?.groups?.comment.trim()}__ \u2014 `;
+  if (comments && optional) finalComment = `__${comments} ${optional}__ \u2014 `;
   else if (comments) finalComment = `__${comments}__ \u2014 `;
   else if (optional) finalComment = `__${optional}__ \u2014 `;
   return finalComment;
 }
-function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto) {
+function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engines.nodeCrypto, pity) {
   if (dice.match(/\d+?#(.*?)/))
     throw new DiceTypeError(
       dice,
@@ -292,8 +394,11 @@ function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engin
   const mainComment = /\s+#(?<comment>.*)/.exec(dice)?.groups?.comment?.trimEnd() ?? void 0;
   const split = dice.split(";");
   let diceMain = fixParenthesis(split[0]);
-  const toHideRegex = /(?<!\[[^\]]*)\((?<dice>[^)]+)\)/;
-  const toHide = toHideRegex.exec(diceMain)?.groups;
+  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;
@@ -301,14 +406,13 @@ function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engin
   } else if (toHide) {
     diceMain = "1d1";
     hidden = true;
+  } else {
+    diceMain = diceMainWithoutComments;
   }
-  const commentsRegex = /\[(?<comments>.*?)\]/gi;
-  const comments = formatComment(diceMain);
-  diceMain = diceMain.replace(commentsRegex, "").trim();
-  let diceResult = roll(diceMain, engine);
+  let diceResult = roll(diceMain, engine, pity);
   if (!diceResult || !diceResult.total) {
     if (hidden) {
-      diceResult = roll(fixParenthesis(split[0]));
+      diceResult = roll(fixParenthesis(split[0]), engine, pity);
       hidden = false;
     } else return void 0;
   }
@@ -343,7 +447,7 @@ function sharedRolls(dice, engine = import_rpg_dice_roller.NumberGenerator.engin
         results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
         total += Number.parseInt(evaluated, 10);
       } catch (error) {
-        const evaluated = roll(toRoll, engine);
+        const evaluated = roll(toRoll, engine, pity);
         if (evaluated)
           results.push(
             `\u25C8 ${comment}${diceAll}: ${evaluated.result.split(":").slice(1).join(":")}`
@@ -432,10 +536,10 @@ 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 SIGN_REGEX = /==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=/;
+var SIGN_REGEX_SPACE = /(==|!=|(?<![!<>])>=|(?<![!<>])<=|(?<!!)(?<![<>])>|(?<!!)(?<![<>])<|(?<!!)(?<![<>])=)(\S+)/;
 var SYMBOL_DICE = "&";
-var DETECT_CRITICAL = /\{\*?c[fs]:[<>=!]+(.+?)}/gim;
+var DETECT_CRITICAL = /\{\*?c[fs]:([<>=]|!=)+(.+?)}/gim;
 var OPTIONAL_COMMENT = /\s+(#|\/{2}|\[|\/\*)?(?<comment>.*)/gi;
 
 // src/interfaces/zod.ts
@@ -655,7 +759,7 @@ var import_mathjs3 = 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) {
+function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto, pity) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
     const names = Object.keys(allStats);
@@ -668,7 +772,7 @@ function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller3.Numb
     }
   }
   try {
-    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine))
+    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine, pity))
       throw new DiceTypeError(dice, "evalStatsDice", "no roll result");
     return testDice;
   } catch (error) {