@dicelette/core 1.28.0 → 1.28.2

package/dist/index.js

@@ -60,6 +60,7 @@ __export(index_exports, {
   replaceFormulaInDice: () => replaceFormulaInDice,
   replaceInFormula: () => replaceInFormula,
   replaceUnknown: () => replaceUnknown,
+  resolveFormulaHint: () => resolveFormulaHint,
   roll: () => roll,
   standardizeDice: () => standardizeDice,
   templateSchema: () => templateSchema,
@@ -277,211 +278,259 @@ function includeDiceType(dice, diceType, userStats) {
 }
 
 // src/roll.ts
-var import_rpg_dice_roller7 = require("@dice-roller/rpg-dice-roller");
-var import_mathjs8 = require("mathjs");
+var import_rpg_dice_roller8 = require("@dice-roller/rpg-dice-roller");
+var import_mathjs10 = require("mathjs");
 
 // src/dice/bulk.ts
-var import_rpg_dice_roller6 = require("@dice-roller/rpg-dice-roller");
-var import_mathjs6 = require("mathjs");
+var import_rpg_dice_roller7 = require("@dice-roller/rpg-dice-roller");
+var import_mathjs8 = require("mathjs");
 
 // src/dice/compare.ts
-var import_rpg_dice_roller3 = require("@dice-roller/rpg-dice-roller");
+var import_rpg_dice_roller4 = require("@dice-roller/rpg-dice-roller");
 var import_mathjs2 = require("mathjs");
 
 // src/utils.ts
+var import_uniformize2 = require("uniformize");
+var import_rpg_dice_roller3 = require("@dice-roller/rpg-dice-roller");
+var import_random_js2 = require("random-js");
+
+// src/verify_template.ts
 var import_mathjs = require("mathjs");
+var import_random_js = require("random-js");
 var import_uniformize = require("uniformize");
 var import_rpg_dice_roller2 = require("@dice-roller/rpg-dice-roller");
-var import_random_js = require("random-js");
-
-// src/similarity.ts
-function calculateSimilarity(str1, str2) {
-  const longer = str1.length > str2.length ? str1 : str2;
-  const shorter = str1.length > str2.length ? str2 : str1;
-  if (longer.length === 0) return 1;
-  const distance = levenshteinDistance(longer, shorter);
-  return (longer.length - distance) / longer.length;
-}
-function levenshteinDistance(str1, str2) {
-  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
-  for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
-  for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
-  for (let j = 1; j <= str2.length; j++) {
-    for (let i = 1; i <= str1.length; i++) {
-      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-      matrix[j][i] = Math.min(
-        matrix[j][i - 1] + 1,
-        // insertion
-        matrix[j - 1][i] + 1,
-        // deletion
-        matrix[j - 1][i - 1] + cost
-        // substitution
-      );
+function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto, pity) {
+  let dice = testDice.trimEnd();
+  if (allStats && Object.keys(allStats).length > 0) {
+    const names = Object.keys(allStats);
+    for (const name of names) {
+      const regex = new RegExp(escapeRegex(name.standardize()), "gi");
+      if (dice.standardize().match(regex)) {
+        const statValue = allStats[name];
+        dice = dice.standardize().replace(regex, statValue.toString()).trimEnd();
+      }
     }
   }
-  return matrix[str2.length][str1.length];
-}
-function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH) {
-  const exact = normalizedStats.get(searchTerm);
-  if (exact) return exact;
-  const candidates = [];
-  for (const [normalizedKey, original] of normalizedStats) {
-    if (normalizedKey.startsWith(searchTerm))
-      candidates.push([original, calculateSimilarity(searchTerm, normalizedKey)]);
-  }
-  if (candidates.length === 1) return candidates[0][0];
-  if (candidates.length > 0) {
-    candidates.sort((a, b) => b[1] - a[1]);
-    if (candidates[0][1] >= similarityThreshold) return candidates[0][0];
-  }
-  let bestMatch;
-  let bestSimilarity = 0;
-  for (const [normalizedKey, original] of normalizedStats) {
-    const similarity = calculateSimilarity(searchTerm, normalizedKey);
-    if (similarity === 1) return original;
-    if (similarity > bestSimilarity && similarity >= similarityThreshold) {
-      bestSimilarity = similarity;
-      bestMatch = original;
-    }
+  try {
+    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine, pity))
+      throw new DiceTypeError(dice, "evalStatsDice", "no roll result");
+    return testDice;
+  } catch (error) {
+    throw new DiceTypeError(dice, "evalStatsDice", error);
   }
-  return bestMatch;
 }
-function findBestRecord(record, searchTerm, similarityThreshold = MIN_THRESHOLD_MATCH) {
-  const normalizeRecord = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(record)) {
-    normalizeRecord.set(key.standardize(), key);
+function diceRandomParse(value, template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+  if (!template.statistics) return replaceFormulaInDice(value.standardize());
+  value = value.standardize();
+  const statNames = Object.keys(template.statistics);
+  let newDice = value;
+  for (const name of statNames) {
+    const regex = new RegExp(escapeRegex(name.standardize()), "gi");
+    if (value.match(regex)) {
+      let max;
+      let min;
+      const foundStat = template.statistics?.[name];
+      if (foundStat) {
+        max = foundStat.max;
+        min = foundStat.min;
+      }
+      const total = template.total || 100;
+      const randomStatValue = generateRandomStat(total, max, min, engine);
+      newDice = value.replace(regex, randomStatValue.toString());
+    }
   }
-  return findBestStatMatch(
-    searchTerm.standardize(),
-    normalizeRecord,
-    similarityThreshold
-  ) || null;
+  return replaceFormulaInDice(newDice);
 }
-function replaceUnknown(dice, replacer) {
-  return dice.replaceAll(REMOVER_PATTERN.STAT_MATCHER, replacer).replaceAll("+0", "").replaceAll("-0", "");
+function diceTypeRandomParse(dice, template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+  dice = replaceExpByRandom(dice);
+  if (!template.statistics) return dice;
+  const firstStatNotcombinaison = Object.keys(template.statistics).find(
+    (stat) => !template.statistics?.[stat].combinaison
+  );
+  if (!firstStatNotcombinaison) return dice;
+  const stats = template.statistics[firstStatNotcombinaison];
+  const { min, max } = stats;
+  const total = template.total || 100;
+  const randomStatValue = generateRandomStat(total, max, min, engine);
+  return replaceFormulaInDice(dice.replaceAll("$", randomStatValue.toString()));
 }
-function verifyStatMatcherPattern(dice, replaceUnknow) {
-  if (REMOVER_PATTERN.STAT_MATCHER.test(dice)) {
-    if (replaceUnknow)
-      return replaceUnknown(dice, replaceUnknow);
-    const matched = dice.matchAll(new RegExp(REMOVER_PATTERN.STAT_MATCHER));
-    const stats = matched ? Array.from(matched, (m) => m?.[0]).map((s) => `\`${s}\``).join(", ") : "unknown";
-    throw new DiceTypeError("error.invalidDice.stats");
+function evalCombinaison(combinaison, stats) {
+  const newStats = {};
+  for (const [stat, combin] of Object.entries(combinaison)) {
+    let formula = combin.standardize();
+    for (const [statName, value] of Object.entries(stats)) {
+      const regex = new RegExp(statName.standardize(), "gi");
+      formula = formula.replace(regex, value.toString());
+    }
+    try {
+      newStats[stat] = (0, import_mathjs.evaluate)(formula);
+    } catch (error) {
+      throw new FormulaError(stat, "evalCombinaison", error);
+    }
   }
-  return dice.replaceAll("+0", "").replaceAll("-0", "");
+  return newStats;
 }
-
-// src/utils.ts
-function escapeRegex(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function evalOneCombinaison(combinaison, stats) {
+  let formula = combinaison.standardize();
+  for (const [statName, value] of Object.entries(stats)) {
+    const regex = new RegExp(statName.standardize(), "gi");
+    formula = formula.replace(regex, value.toString());
+  }
+  try {
+    return (0, import_mathjs.evaluate)(formula);
+  } catch (error) {
+    throw new FormulaError(combinaison, "evalOneCombinaison", error);
+  }
 }
-function standardizeDice(dice) {
-  return dice.replace(
-    /(\[[^\]]+])|([^[]+)/g,
-    (_match, insideBrackets, outsideText) => insideBrackets ? insideBrackets : outsideText.standardize().replaceAll("df", "dF")
-  );
+function convertNumber(number) {
+  if (number === void 0 || number === null) return void 0;
+  if (number.toString().length === 0 || Number.isNaN(Number.parseInt(number.toString(), 10)))
+    return void 0;
+  if (isNumber(number)) return Number.parseInt(number.toString(), 10);
+  return void 0;
 }
-function handleDiceAfterD(tokenStd, normalizedStats) {
-  const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
-  if (!diceMatch) return null;
-  const diceCount = diceMatch[1] || "";
-  const afterD = diceMatch[2];
-  const bestMatch = findBestStatMatch(afterD, normalizedStats, 1);
-  if (bestMatch) {
-    const [, value] = bestMatch;
-    return `${diceCount}d${value.toString()}`;
+function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+  const parsedTemplate = templateSchema.parse(template);
+  const { success, failure } = parsedTemplate.critical ?? {};
+  const criticicalVal = {
+    success: convertNumber(success),
+    failure: convertNumber(failure)
+  };
+  const statistiqueTemplate = {
+    diceType: parsedTemplate.diceType,
+    statistics: parsedTemplate.statistics,
+    critical: criticicalVal,
+    total: parsedTemplate.total,
+    charName: parsedTemplate.charName,
+    damage: parsedTemplate.damage,
+    customCritical: parsedTemplate.customCritical,
+    forceDistrib: parsedTemplate.forceDistrib
+  };
+  if (!verify) return statistiqueTemplate;
+  if (statistiqueTemplate.diceType) {
+    if (statistiqueTemplate.diceType.match(DETECT_CRITICAL)) {
+      throw new DiceTypeError(
+        statistiqueTemplate.diceType,
+        "critical_dice_type",
+        "contains critical detection: should be in custom critical instead"
+      );
+    }
+    const cleanedDice2 = diceTypeRandomParse(
+      statistiqueTemplate.diceType,
+      statistiqueTemplate,
+      engine
+    );
+    const rolled = roll(cleanedDice2, engine);
+    if (!rolled) throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
   }
-  return null;
-}
-function handleSimpleToken(tokenStd, token, normalizedStats, minThreshold) {
-  const bestMatch = findBestStatMatch(tokenStd, normalizedStats, minThreshold);
-  if (bestMatch) {
-    const [, value] = bestMatch;
-    return value.toString();
+  if (statistiqueTemplate.customCritical) {
+    if (!statistiqueTemplate.diceType) {
+      throw new DiceTypeError("no_dice_type", "no_dice_type", "no dice type");
+    }
+    const customCritical = statistiqueTemplate.customCritical;
+    for (const [, custom] of Object.entries(customCritical)) {
+      const cleanedDice2 = createCriticalCustom(
+        statistiqueTemplate.diceType,
+        custom,
+        statistiqueTemplate,
+        engine
+      );
+      const rolled = roll(cleanedDice2, engine);
+      if (!rolled)
+        throw new DiceTypeError(cleanedDice2, "verifyTemplateValue", "no roll result");
+    }
   }
-  return token;
+  testDiceRegistered(statistiqueTemplate, engine);
+  testStatCombinaison(statistiqueTemplate, engine);
+  return statistiqueTemplate;
 }
-function generateStatsDice(originalDice, stats, minThreshold = 0.6, dollarValue) {
-  let dice = originalDice.standardize();
-  if (stats && Object.keys(stats).length > 0) {
-    const normalizedStats = /* @__PURE__ */ new Map();
-    for (const [key, value] of Object.entries(stats)) {
-      const normalized = key.standardize();
-      normalizedStats.set(normalized, [key, value]);
+function testDiceRegistered(template, engine = import_rpg_dice_roller2.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();
+  for (const [name, dice] of Object.entries(template.damage)) {
+    if (!dice) continue;
+    const diceReplaced = replaceExpByRandom(dice);
+    const randomDiceParsed = diceRandomParse(diceReplaced, template, engine);
+    try {
+      const rolled = roll(randomDiceParsed, engine);
+      if (!rolled) throw new DiceTypeError(name, "no_roll_result", dice);
+    } catch (error) {
+      throw new DiceTypeError(name, "testDiceRegistered", error);
     }
-    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 tokenHasDollar = token.startsWith("$");
-        const tokenForCompare = tokenHasDollar ? token.slice(1) : token;
-        const tokenStd = tokenForCompare.standardize();
-        const diceReplacement = handleDiceAfterD(tokenStd, normalizedStats);
-        if (diceReplacement) {
-          result += diceReplacement;
-          lastIndex = tokenRegex.lastIndex;
-          continue;
-        }
-        result += handleSimpleToken(tokenStd, token, normalizedStats, minThreshold);
-        lastIndex = tokenRegex.lastIndex;
-      }
-      result += outsideText.slice(lastIndex);
+  }
+}
+function testStatCombinaison(template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+  if (!template.statistics) return;
+  const onlycombinaisonStats = Object.fromEntries(
+    Object.entries(template.statistics).filter(
+      ([_, value]) => value.combinaison !== void 0
+    )
+  );
+  const allOtherStats = Object.fromEntries(
+    Object.entries(template.statistics).filter(([_, value]) => !value.combinaison)
+  );
+  if (Object.keys(onlycombinaisonStats).length === 0) return;
+  const allStats = Object.keys(template.statistics).filter(
+    (stat) => !template.statistics[stat].combinaison
+  );
+  if (allStats.length === 0) throw new NoStatisticsError();
+  const error = [];
+  for (const [stat, value] of Object.entries(onlycombinaisonStats)) {
+    let formula = value.combinaison;
+    for (const [other, data] of Object.entries(allOtherStats)) {
+      const { max, min } = data;
+      const total = template.total || 100;
+      const randomStatValue = generateRandomStat(total, max, min, engine);
+      const regex = new RegExp(other, "gi");
+      formula = formula.replace(regex, randomStatValue.toString());
+    }
+    try {
+      (0, import_mathjs.evaluate)(formula);
+    } catch (e) {
+      error.push(stat);
     }
-    dice = result;
   }
-  if (dollarValue) dice = dice.replaceAll("$", dollarValue);
-  return replaceFormulaInDice(dice);
+  if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
+  return;
 }
-function replaceFormulaInDice(dice) {
-  const formula = /(?<formula>\{{2}(.+?)}{2})/gim;
-  let match;
-  let modifiedDice = dice;
-  while ((match = formula.exec(dice)) !== null) {
-    if (match.groups?.formula) {
-      const formulae = match.groups.formula.replaceAll("{{", "").replaceAll("}}", "");
-      try {
-        const result = (0, import_mathjs.evaluate)(formulae);
-        modifiedDice = modifiedDice.replace(match.groups.formula, result.toString());
-      } catch (error) {
-        throw new FormulaError(match.groups.formula, "replaceFormulasInDice", error);
-      }
-    }
+function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+  let randomStatValue = total + 1;
+  const random = new import_random_js.Random(engine || import_rpg_dice_roller2.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);
+    else if (min) randomStatValue = randomInt(min, total, engine, random);
+    else randomStatValue = randomInt(1, total, engine, random);
   }
-  return cleanedDice(modifiedDice);
+  return randomStatValue;
 }
-function cleanedDice(dice) {
-  return dice.replaceAll("+-", "-").replaceAll("--", "+").replaceAll("++", "+").replaceAll("=>", ">=").replaceAll("=<", "<=").trimEnd();
+
+// src/utils.ts
+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 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_roller3.NumberGenerator.engines.nodeCrypto) {
   const diceRegex = /\{exp( ?\|\| ?(?<default>\d+))?}/gi;
   return dice.replace(diceRegex, (_match, _p1, _p2, _offset, _string, groups) => {
     const defaultValue = groups?.default;
     return defaultValue ?? randomInt(1, 999, engine).toString();
   });
 }
-function randomInt(min, max, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto, rng) {
-  if (!rng) rng = new import_random_js.Random(engine || void 0);
+function randomInt(min, max, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto, rng) {
+  if (!rng) rng = new import_random_js2.Random(engine || void 0);
   return rng.integer(min, max);
 }
-function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller2.NumberGenerator.engines.nodeCrypto) {
+function createCriticalCustom(dice, customCritical, template, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto) {
   const compareRegex = dice.match(SIGN_REGEX_SPACE);
   let customDice = dice;
   const compareValue = diceTypeRandomParse(customCritical.value, template, engine);
@@ -524,7 +573,7 @@ function canComparisonFail(maxRollValue, compare, minRollValue = 1) {
       return true;
   }
 }
-function rollCompare(value, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto, pity) {
+function rollCompare(value, engine = import_rpg_dice_roller4.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 };
@@ -543,7 +592,7 @@ function rollCompare(value, engine = import_rpg_dice_roller3.NumberGenerator.eng
     diceResult: rollComp?.result
   };
 }
-function getCompare(dice, compareRegex, engine = import_rpg_dice_roller3.NumberGenerator.engines.nodeCrypto, pity) {
+function getCompare(dice, compareRegex, engine = import_rpg_dice_roller4.NumberGenerator.engines.nodeCrypto, pity) {
   if (dice.match(/((\{.*,(.*)+\}|([><=!]+\d+f))([><=]|!=)+\d+\}?)|\{(.*)(([><=]|!=)+).*\}/))
     return { dice, compare: void 0 };
   dice = dice.replace(SIGN_REGEX_SPACE, "");
@@ -599,7 +648,7 @@ function canComparisonSucceed(maxRollValue, compare, minRollValue) {
 var import_mathjs4 = require("mathjs");
 
 // src/dice/signs.ts
-var import_rpg_dice_roller4 = require("@dice-roller/rpg-dice-roller");
+var import_rpg_dice_roller5 = require("@dice-roller/rpg-dice-roller");
 var import_mathjs3 = require("mathjs");
 
 // src/dice/replace.ts
@@ -689,7 +738,7 @@ function inverseSign(sign) {
       return "==";
   }
 }
-function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller4.NumberGenerator.engines.nodeCrypto, pity, rollBounds) {
+function compareSignFormule(toRoll, compareRegex, element, diceResult, engine = import_rpg_dice_roller5.NumberGenerator.engines.nodeCrypto, pity, rollBounds) {
   let results = "";
   let trivial = false;
   const compareResult = getCompare(toRoll, compareRegex, engine);
@@ -750,43 +799,278 @@ function normalizeExplodingSuccess(dice) {
       parsedValue = 0;
     }
   }
-  const normalizedSegment = "!";
-  const replacedDice = dice.replace(match[0], normalizedSegment);
-  return {
-    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);
+  const normalizedSegment = "!";
+  const replacedDice = dice.replace(match[0], normalizedSegment);
+  return {
+    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/dice/extract.ts
+var import_rpg_dice_roller6 = require("@dice-roller/rpg-dice-roller");
+
+// src/similarities/generateStatsDice.ts
+var import_mathjs5 = require("mathjs");
+
+// src/similarities/similarity.ts
+function calculateSimilarity(str1, str2) {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  if (longer.length === 0) return 1;
+  const distance = levenshteinDistance(longer, shorter);
+  return (longer.length - distance) / longer.length;
+}
+function levenshteinDistance(str1, str2) {
+  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+  for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= str2.length; j++) {
+    for (let i = 1; i <= str1.length; i++) {
+      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+      matrix[j][i] = Math.min(
+        matrix[j][i - 1] + 1,
+        // insertion
+        matrix[j - 1][i] + 1,
+        // deletion
+        matrix[j - 1][i - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[str2.length][str1.length];
+}
+function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH) {
+  const exact = normalizedStats.get(searchTerm);
+  if (exact) return exact;
+  const candidates = [];
+  for (const [normalizedKey, original] of normalizedStats) {
+    if (normalizedKey.startsWith(searchTerm))
+      candidates.push([original, calculateSimilarity(searchTerm, normalizedKey)]);
+  }
+  if (candidates.length === 1) return candidates[0][0];
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => b[1] - a[1]);
+    if (candidates[0][1] >= similarityThreshold) return candidates[0][0];
+  }
+  let bestMatch;
+  let bestSimilarity = 0;
+  for (const [normalizedKey, original] of normalizedStats) {
+    const similarity = calculateSimilarity(searchTerm, normalizedKey);
+    if (similarity === 1) return original;
+    if (similarity > bestSimilarity && similarity >= similarityThreshold) {
+      bestSimilarity = similarity;
+      bestMatch = original;
+    }
+  }
+  return bestMatch;
+}
+function findBestRecord(record, searchTerm, similarityThreshold = MIN_THRESHOLD_MATCH) {
+  const normalizeRecord = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(record)) {
+    normalizeRecord.set(key.standardize(), key);
+  }
+  return findBestStatMatch(
+    searchTerm.standardize(),
+    normalizeRecord,
+    similarityThreshold
+  ) || null;
+}
+function replaceUnknown(dice, replacer) {
+  return dice.replaceAll(REMOVER_PATTERN.STAT_MATCHER, replacer).replaceAll("+0", "").replaceAll("-0", "");
+}
+function verifyStatMatcherPattern(dice, replaceUnknow) {
+  if (REMOVER_PATTERN.STAT_MATCHER.test(dice)) {
+    if (replaceUnknow)
+      return replaceUnknown(dice, replaceUnknow);
+    const matched = dice.matchAll(new RegExp(REMOVER_PATTERN.STAT_MATCHER));
+    const stats = matched ? Array.from(matched, (m) => m?.[0]).map((s) => `\`${s}\``).join(", ") : "unknown";
+    throw new DiceTypeError(stats, "unknown_stats");
+  }
+  return dice.replaceAll("+0", "").replaceAll("-0", "");
+}
+
+// src/similarities/generateStatsDice.ts
+function handleDiceAfterD(tokenStd, normalizedStats) {
+  const diceMatch = /^(\d*)d(.+)$/i.exec(tokenStd);
+  if (!diceMatch) return null;
+  const diceCount = diceMatch[1] || "";
+  const afterD = diceMatch[2];
+  const bestMatch = findBestStatMatch(afterD, normalizedStats, 1);
+  if (bestMatch) {
+    const [, value] = bestMatch;
+    return `${diceCount}d${value.toString()}`;
+  }
+  return null;
+}
+function handleSimpleToken(tokenStd, token, normalizedStats, minThreshold) {
+  const bestMatch = findBestStatMatch(tokenStd, normalizedStats, minThreshold);
+  if (bestMatch) {
+    const [, value] = bestMatch;
+    return value.toString();
+  }
+  return token;
+}
+function generateStatsDice(originalDice, stats, minThreshold = 0.6, dollarValue) {
+  let dice = originalDice.standardize();
+  if (stats && Object.keys(stats).length > 0) {
+    const normalizedStats = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(stats)) {
+      const normalized = key.standardize();
+      normalizedStats.set(normalized, [key, value]);
+    }
+    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 tokenHasDollar = token.startsWith("$");
+        const tokenForCompare = tokenHasDollar ? token.slice(1) : token;
+        const tokenStd = tokenForCompare.standardize();
+        const diceReplacement = handleDiceAfterD(tokenStd, normalizedStats);
+        if (diceReplacement) {
+          result += diceReplacement;
+          lastIndex = tokenRegex.lastIndex;
+          continue;
+        }
+        result += handleSimpleToken(tokenStd, token, normalizedStats, minThreshold);
+        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 = (0, import_mathjs5.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();
+}
+
+// src/similarities/resolveFormula.ts
+var import_mathjs6 = require("mathjs");
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return void 0;
+}
+function substituteFormulaTokens(expr, resolvedStats, similarityThreshold = MIN_THRESHOLD_MATCH) {
+  return expr.replace(/([\p{L}\p{M}._-]+)/gu, (token) => {
+    const match = findBestStatMatch(token, resolvedStats, similarityThreshold);
+    return match !== void 0 ? match.toString() : token;
+  });
+}
+function resolveFormulaHint(formula, allAttributes, similarityThreshold = MIN_THRESHOLD_MATCH) {
+  const trimmed = formula.trim();
+  if (!trimmed) return { kind: "not-formula" };
+  if (isNumber(trimmed)) return { kind: "not-formula" };
+  const resolved = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  for (const [name, val] of Object.entries(allAttributes)) {
+    const norm = name.standardize();
+    if (typeof val === "number") {
+      if (Number.isFinite(val)) resolved.set(norm, val);
+      continue;
+    }
+    const t = val.trim();
+    if (!t) continue;
+    if (isNumber(t)) {
+      const numeric = Number(t);
+      if (Number.isFinite(numeric)) resolved.set(norm, numeric);
+    } else {
+      pending.set(norm, t.standardize());
+    }
+  }
+  for (const [normName, expr2] of pending) {
+    pending.set(normName, substituteFormulaTokens(expr2, resolved, similarityThreshold));
+  }
+  let progress = true;
+  while (pending.size > 0 && progress) {
+    progress = false;
+    for (const [normName, expr2] of pending) {
+      try {
+        const result = toFiniteNumber((0, import_mathjs6.evaluate)(expr2));
+        if (result === void 0) continue;
+        resolved.set(normName, result);
+        pending.delete(normName);
+        progress = true;
+        for (const [otherNorm, otherExpr] of pending) {
+          pending.set(
+            otherNorm,
+            substituteFormulaTokens(otherExpr, resolved, similarityThreshold)
+          );
+        }
+      } catch {
       }
     }
   }
-  return flatValues.reduce(
-    (acc, current) => acc + (matchComparison(sign, current, value) ? 1 : 0),
-    0
-  );
+  const normFormula = trimmed.standardize();
+  const expr = substituteFormulaTokens(normFormula, resolved, similarityThreshold);
+  try {
+    const result = toFiniteNumber((0, import_mathjs6.evaluate)(expr));
+    if (result !== void 0) return { kind: "resolved", value: result };
+    return { kind: "error" };
+  } catch {
+    return { kind: "error" };
+  }
 }
 
-// src/dice/extract.ts
-var import_rpg_dice_roller5 = require("@dice-roller/rpg-dice-roller");
-
 // src/dice/calculator.ts
-var import_mathjs5 = require("mathjs");
+var import_mathjs7 = require("mathjs");
 function calculator(sign, value, total) {
   if (sign === "^") sign = "**";
-  return (0, import_mathjs5.evaluate)(`${total} ${sign} ${value}`);
+  return (0, import_mathjs7.evaluate)(`${total} ${sign} ${value}`);
 }
 
 // src/dice/extract.ts
@@ -821,10 +1105,10 @@ function extractValuesFromOutput(output) {
   }
   return values;
 }
-function getRollBounds(dice, engine = import_rpg_dice_roller5.NumberGenerator.engines.nodeCrypto) {
+function getRollBounds(dice, engine = import_rpg_dice_roller6.NumberGenerator.engines.nodeCrypto) {
   try {
-    const roller = new import_rpg_dice_roller5.DiceRoller();
-    import_rpg_dice_roller5.NumberGenerator.generator.engine = engine;
+    const roller = new import_rpg_dice_roller6.DiceRoller();
+    import_rpg_dice_roller6.NumberGenerator.generator.engine = engine;
     const rollResult = roller.roll(dice);
     const instance = Array.isArray(rollResult) ? rollResult[0] : rollResult;
     const { minTotal, maxTotal } = instance;
@@ -937,8 +1221,8 @@ function handleBulkRolls(dice, isCurlyBulk, bulkContent, compare, explodingSucce
       sort
     );
   }
-  const roller = new import_rpg_dice_roller6.DiceRoller();
-  import_rpg_dice_roller6.NumberGenerator.generator.engine = engine;
+  const roller = new import_rpg_dice_roller7.DiceRoller();
+  import_rpg_dice_roller7.NumberGenerator.generator.engine = engine;
   for (let i = 0; i < numberOfDice; i++) {
     try {
       roller.roll(diceToRoll);
@@ -960,8 +1244,8 @@ function handleBulkRolls(dice, isCurlyBulk, bulkContent, compare, explodingSucce
 function handleBulkRollsWithComparison(numberOfDice, diceToRoll, comments, activeCompare, explodingSuccess, diceDisplay, isCurlyBulk, curlyCompare, compare, engine, sort) {
   const results = [];
   let successCount = 0;
-  const roller = new import_rpg_dice_roller6.DiceRoller();
-  import_rpg_dice_roller6.NumberGenerator.generator.engine = engine;
+  const roller = new import_rpg_dice_roller7.DiceRoller();
+  import_rpg_dice_roller7.NumberGenerator.generator.engine = engine;
   let trivialComparisonDetected = false;
   const formatOutput = (output, addStar) => {
     const formatted = addStar && isCurlyBulk ? output.replace(
@@ -995,7 +1279,7 @@ function handleBulkRollsWithComparison(numberOfDice, diceToRoll, comments, activ
         results.push(formattedRollOutput);
       } else {
         const rollTotal = rollInstance.total;
-        const isSuccess = (0, import_mathjs6.evaluate)(
+        const isSuccess = (0, import_mathjs8.evaluate)(
           `${rollTotal}${activeCompare.sign}${activeCompare.value}`
         );
         if (isSuccess) successCount++;
@@ -1058,7 +1342,7 @@ function handleBulkRollsWithComparison(numberOfDice, diceToRoll, comments, activ
 }
 
 // src/dice/pity.ts
-var import_mathjs7 = require("mathjs");
+var import_mathjs9 = require("mathjs");
 function handlePitySystem(dice, compare, diceRoll, roller, engine) {
   const currentRoll = Array.isArray(diceRoll) ? diceRoll[0] : diceRoll;
   const maxPossible = currentRoll ? currentRoll.maxTotal : null;
@@ -1066,7 +1350,7 @@ function handlePitySystem(dice, compare, diceRoll, roller, engine) {
   if (!isComparisonPossible) {
     return { rerollCount: 0 };
   }
-  let isFail = (0, import_mathjs7.evaluate)(`${roller.total}${compare.sign}${compare.value}`);
+  let isFail = (0, import_mathjs9.evaluate)(`${roller.total}${compare.sign}${compare.value}`);
   if (isFail) {
     return { rerollCount: 0 };
   }
@@ -1081,14 +1365,14 @@ function handlePitySystem(dice, compare, diceRoll, roller, engine) {
     }
     rerollCount++;
     if (res && res.total !== void 0) {
-      isFail = (0, import_mathjs7.evaluate)(`${res.total}${compare.sign}${compare.value}`);
+      isFail = (0, import_mathjs9.evaluate)(`${res.total}${compare.sign}${compare.value}`);
     }
   }
   return { rerollCount, result: res };
 }
 
 // src/roll.ts
-function roll(dice, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto, pity, sort) {
+function roll(dice, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto, pity, sort) {
   if (sort === "none" /* None */) sort = void 0;
   const prepared = prepareDice(dice);
   if (!prepared.dice.includes("d")) return void 0;
@@ -1129,8 +1413,8 @@ function roll(dice, engine = import_rpg_dice_roller7.NumberGenerator.engines.nod
       sort
     );
   }
-  const roller = new import_rpg_dice_roller7.DiceRoller();
-  import_rpg_dice_roller7.NumberGenerator.generator.engine = engine;
+  const roller = new import_rpg_dice_roller8.DiceRoller();
+  import_rpg_dice_roller8.NumberGenerator.generator.engine = engine;
   let diceWithoutComment = processedDice.replace(COMMENT_REGEX, "").trimEnd();
   diceWithoutComment = setSortOrder(diceWithoutComment, sort);
   let diceRoll;
@@ -1207,7 +1491,7 @@ function roll(dice, engine = import_rpg_dice_roller7.NumberGenerator.engines.nod
     trivial: compare?.trivial ? true : void 0
   };
 }
-function sharedRolls(dice, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto, pity, explodingSuccessMain, diceDisplay, isSharedCurly, sort) {
+function sharedRolls(dice, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto, pity, explodingSuccessMain, diceDisplay, isSharedCurly, sort) {
   if (!explodingSuccessMain)
     explodingSuccessMain = normalizeExplodingSuccess(dice.split(";")[0] ?? dice);
   if (explodingSuccessMain) {
@@ -1242,13 +1526,13 @@ function sharedRolls(dice, engine = import_rpg_dice_roller7.NumberGenerator.engi
   const sortFromMain = getSortOrder(diceMain);
   const rollBounds = getRollBounds(diceMain, engine);
   let diceResult = roll(diceMain, engine, pity, sort);
-  if (!diceResult || !diceResult.total) {
+  if (!diceResult?.total) {
     if (hidden) {
       diceResult = roll(fixParenthesis(split[0]), engine, pity, sort);
       hidden = false;
     } else return void 0;
   }
-  if (!diceResult || !diceResult.total) return void 0;
+  if (!diceResult?.total) return void 0;
   if (explodingSuccessMain && diceResult.result) {
     const values = extractValuesFromOutput(diceResult.result);
     diceResult.total = values.filter(
@@ -1290,7 +1574,7 @@ function sharedRolls(dice, engine = import_rpg_dice_roller7.NumberGenerator.engi
         const { diceAll } = replaceText(element, diceResult.total, diceResult.dice);
         let successCount = 0;
         try {
-          const evaluated = (0, import_mathjs8.evaluate)(toRoll);
+          const evaluated = (0, import_mathjs10.evaluate)(toRoll);
           successCount = evaluated ? 1 : 0;
         } catch (error) {
           const evaluated = roll(toRoll, engine, pity);
@@ -1324,7 +1608,7 @@ function sharedRolls(dice, engine = import_rpg_dice_roller7.NumberGenerator.engi
         diceResult.dice
       );
       try {
-        const evaluated = (0, import_mathjs8.evaluate)(toRoll);
+        const evaluated = (0, import_mathjs10.evaluate)(toRoll);
         results.push(`\u25C8 ${comment}${diceAll}: ${formule} = ${evaluated}`);
         total += Number.parseInt(evaluated, 10);
       } catch (error) {
@@ -1353,7 +1637,7 @@ function sharedRolls(dice, engine = import_rpg_dice_roller7.NumberGenerator.engi
     trivial: hasTrivialComparison ? true : void 0
   };
 }
-function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller7.NumberGenerator.engines.nodeCrypto, pity) {
+function replaceInFormula(element, diceResult, compareResult, res, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto, pity) {
   const { formule, diceAll } = replaceText(
     element,
     diceResult.total ?? 0,
@@ -1363,7 +1647,7 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = impo
   const invertedSign = res ? compareResult.compare.sign : inverseSign(compareResult.compare.sign);
   let evaluateRoll;
   try {
-    evaluateRoll = (0, import_mathjs8.evaluate)(compareResult.dice);
+    evaluateRoll = (0, import_mathjs10.evaluate)(compareResult.dice);
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll}${invertedSign}${compareResult.compare?.value}`;
   } catch (error) {
     const evaluateRoll2 = roll(compareResult.dice, engine, pity);
@@ -1372,218 +1656,6 @@ function replaceInFormula(element, diceResult, compareResult, res, engine = impo
     return `${validSign} ${diceAll}: ${formule} = ${evaluateRoll2}${invertedSign}${compareResult.compare?.value}`;
   }
 }
-
-// src/verify_template.ts
-var import_mathjs9 = require("mathjs");
-var import_random_js2 = require("random-js");
-var import_uniformize2 = require("uniformize");
-var import_rpg_dice_roller8 = require("@dice-roller/rpg-dice-roller");
-function evalStatsDice(testDice, allStats, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto, pity) {
-  let dice = testDice.trimEnd();
-  if (allStats && Object.keys(allStats).length > 0) {
-    const names = Object.keys(allStats);
-    for (const name of names) {
-      const regex = new RegExp(escapeRegex(name.standardize()), "gi");
-      if (dice.standardize().match(regex)) {
-        const statValue = allStats[name];
-        dice = dice.standardize().replace(regex, statValue.toString()).trimEnd();
-      }
-    }
-  }
-  try {
-    if (!roll(replaceFormulaInDice(replaceExpByRandom(dice)), engine, pity))
-      throw new DiceTypeError(dice, "evalStatsDice", "no roll result");
-    return testDice;
-  } catch (error) {
-    throw new DiceTypeError(dice, "evalStatsDice", error);
-  }
-}
-function diceRandomParse(value, template, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto) {
-  if (!template.statistics) return replaceFormulaInDice(value.standardize());
-  value = value.standardize();
-  const statNames = Object.keys(template.statistics);
-  let newDice = value;
-  for (const name of statNames) {
-    const regex = new RegExp(escapeRegex(name.standardize()), "gi");
-    if (value.match(regex)) {
-      let max;
-      let min;
-      const foundStat = template.statistics?.[name];
-      if (foundStat) {
-        max = foundStat.max;
-        min = foundStat.min;
-      }
-      const total = template.total || 100;
-      const randomStatValue = generateRandomStat(total, max, min, engine);
-      newDice = value.replace(regex, randomStatValue.toString());
-    }
-  }
-  return replaceFormulaInDice(newDice);
-}
-function diceTypeRandomParse(dice, template, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto) {
-  dice = replaceExpByRandom(dice);
-  if (!template.statistics) return dice;
-  const firstStatNotcombinaison = Object.keys(template.statistics).find(
-    (stat) => !template.statistics?.[stat].combinaison
-  );
-  if (!firstStatNotcombinaison) return dice;
-  const stats = template.statistics[firstStatNotcombinaison];
-  const { min, max } = stats;
-  const total = template.total || 100;
-  const randomStatValue = generateRandomStat(total, max, min, engine);
-  return replaceFormulaInDice(dice.replaceAll("$", randomStatValue.toString()));
-}
-function evalCombinaison(combinaison, stats) {
-  const newStats = {};
-  for (const [stat, combin] of Object.entries(combinaison)) {
-    let formula = combin.standardize();
-    for (const [statName, value] of Object.entries(stats)) {
-      const regex = new RegExp(statName.standardize(), "gi");
-      formula = formula.replace(regex, value.toString());
-    }
-    try {
-      newStats[stat] = (0, import_mathjs9.evaluate)(formula);
-    } catch (error) {
-      throw new FormulaError(stat, "evalCombinaison", error);
-    }
-  }
-  return newStats;
-}
-function evalOneCombinaison(combinaison, stats) {
-  let formula = combinaison.standardize();
-  for (const [statName, value] of Object.entries(stats)) {
-    const regex = new RegExp(statName.standardize(), "gi");
-    formula = formula.replace(regex, value.toString());
-  }
-  try {
-    return (0, import_mathjs9.evaluate)(formula);
-  } catch (error) {
-    throw new FormulaError(combinaison, "evalOneCombinaison", error);
-  }
-}
-function convertNumber(number) {
-  if (number === void 0 || number === null) return void 0;
-  if (number.toString().length === 0 || Number.isNaN(Number.parseInt(number.toString(), 10)))
-    return void 0;
-  if (isNumber(number)) return Number.parseInt(number.toString(), 10);
-  return void 0;
-}
-function verifyTemplateValue(template, verify = true, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto) {
-  const parsedTemplate = templateSchema.parse(template);
-  const { success, failure } = parsedTemplate.critical ?? {};
-  const criticicalVal = {
-    success: convertNumber(success),
-    failure: convertNumber(failure)
-  };
-  const statistiqueTemplate = {
-    diceType: parsedTemplate.diceType,
-    statistics: parsedTemplate.statistics,
-    critical: criticicalVal,
-    total: parsedTemplate.total,
-    charName: parsedTemplate.charName,
-    damage: parsedTemplate.damage,
-    customCritical: parsedTemplate.customCritical,
-    forceDistrib: parsedTemplate.forceDistrib
-  };
-  if (!verify) return statistiqueTemplate;
-  if (statistiqueTemplate.diceType) {
-    if (statistiqueTemplate.diceType.match(DETECT_CRITICAL)) {
-      throw new DiceTypeError(
-        statistiqueTemplate.diceType,
-        "critical_dice_type",
-        "contains critical detection: should be in custom critical instead"
-      );
-    }
-    const cleanedDice2 = diceTypeRandomParse(
-      statistiqueTemplate.diceType,
-      statistiqueTemplate,
-      engine
-    );
-    const rolled = roll(cleanedDice2, engine);
-    if (!rolled) throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
-  }
-  if (statistiqueTemplate.customCritical) {
-    if (!statistiqueTemplate.diceType) {
-      throw new DiceTypeError("no_dice_type", "no_dice_type", "no dice type");
-    }
-    const customCritical = statistiqueTemplate.customCritical;
-    for (const [, custom] of Object.entries(customCritical)) {
-      const cleanedDice2 = createCriticalCustom(
-        statistiqueTemplate.diceType,
-        custom,
-        statistiqueTemplate,
-        engine
-      );
-      const rolled = roll(cleanedDice2, engine);
-      if (!rolled)
-        throw new DiceTypeError(cleanedDice2, "verifyTemplateValue", "no roll result");
-    }
-  }
-  testDiceRegistered(statistiqueTemplate, engine);
-  testStatCombinaison(statistiqueTemplate, engine);
-  return statistiqueTemplate;
-}
-function testDiceRegistered(template, engine = import_rpg_dice_roller8.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();
-  for (const [name, dice] of Object.entries(template.damage)) {
-    if (!dice) continue;
-    const diceReplaced = replaceExpByRandom(dice);
-    const randomDiceParsed = diceRandomParse(diceReplaced, template, engine);
-    try {
-      const rolled = roll(randomDiceParsed, engine);
-      if (!rolled) throw new DiceTypeError(name, "no_roll_result", dice);
-    } catch (error) {
-      throw new DiceTypeError(name, "testDiceRegistered", error);
-    }
-  }
-}
-function testStatCombinaison(template, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto) {
-  if (!template.statistics) return;
-  const onlycombinaisonStats = Object.fromEntries(
-    Object.entries(template.statistics).filter(
-      ([_, value]) => value.combinaison !== void 0
-    )
-  );
-  const allOtherStats = Object.fromEntries(
-    Object.entries(template.statistics).filter(([_, value]) => !value.combinaison)
-  );
-  if (Object.keys(onlycombinaisonStats).length === 0) return;
-  const allStats = Object.keys(template.statistics).filter(
-    (stat) => !template.statistics[stat].combinaison
-  );
-  if (allStats.length === 0) throw new NoStatisticsError();
-  const error = [];
-  for (const [stat, value] of Object.entries(onlycombinaisonStats)) {
-    let formula = value.combinaison;
-    for (const [other, data] of Object.entries(allOtherStats)) {
-      const { max, min } = data;
-      const total = template.total || 100;
-      const randomStatValue = generateRandomStat(total, max, min, engine);
-      const regex = new RegExp(other, "gi");
-      formula = formula.replace(regex, randomStatValue.toString());
-    }
-    try {
-      (0, import_mathjs9.evaluate)(formula);
-    } catch (e) {
-      error.push(stat);
-    }
-  }
-  if (error.length > 0) throw new FormulaError(error.join(", "), "testStatCombinaison");
-  return;
-}
-function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roller8.NumberGenerator.engines.nodeCrypto) {
-  let randomStatValue = total + 1;
-  const random = new import_random_js2.Random(engine || import_rpg_dice_roller8.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);
-    else if (min) randomStatValue = randomInt(min, total, engine, random);
-    else randomStatValue = randomInt(1, total, engine, random);
-  }
-  return randomStatValue;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   COMMENT_REGEX,
@@ -1626,6 +1698,7 @@ function generateRandomStat(total = 100, max, min, engine = import_rpg_dice_roll
   replaceFormulaInDice,
   replaceInFormula,
   replaceUnknown,
+  resolveFormulaHint,
   roll,
   standardizeDice,
   templateSchema,