@dicelette/core 1.28.2 → 1.28.4

package/dist/index.mjs

@@ -166,6 +166,7 @@ var templateSchema = z.object({
 });
 
 // src/regex.ts
+var REGEX_CACHE_MAX = 500;
 var regexCache = /* @__PURE__ */ new Map();
 var NORMALIZE_SINGLE_DICE = (str) => str.replace(/\b1d(\d+)/gi, "d$1");
 var REMOVER_PATTERN = {
@@ -180,6 +181,10 @@ function getCachedRegex(pattern, flags = "") {
   const key = `${pattern}|${flags}`;
   let regex = regexCache.get(key);
   if (!regex) {
+    if (regexCache.size >= REGEX_CACHE_MAX) {
+      const oldest = regexCache.keys().next().value;
+      if (oldest !== void 0) regexCache.delete(oldest);
+    }
     regex = new RegExp(pattern, flags);
     regexCache.set(key, regex);
   }
@@ -212,10 +217,6 @@ import { evaluate as evaluate10 } from "mathjs";
 import { DiceRoller as DiceRoller2, NumberGenerator as NumberGenerator7 } from "@dice-roller/rpg-dice-roller";
 import { evaluate as evaluate8 } from "mathjs";
 
-// src/dice/compare.ts
-import { NumberGenerator as NumberGenerator4 } from "@dice-roller/rpg-dice-roller";
-import { evaluate as evaluate2 } from "mathjs";
-
 // src/utils.ts
 import "uniformize";
 import { NumberGenerator as NumberGenerator3 } from "@dice-roller/rpg-dice-roller";
@@ -229,12 +230,12 @@ import { NumberGenerator as NumberGenerator2 } from "@dice-roller/rpg-dice-rolle
 function evalStatsDice(testDice, allStats, engine = NumberGenerator2.engines.nodeCrypto, pity) {
   let dice = testDice.trimEnd();
   if (allStats && Object.keys(allStats).length > 0) {
+    dice = dice.standardize();
     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();
+      const regex = getCachedRegex(name.standardize().escapeRegex(), "gi");
+      if (dice.match(regex)) {
+        dice = dice.replace(regex, allStats[name].toString()).trimEnd();
       }
     }
   }
@@ -252,8 +253,8 @@ function diceRandomParse(value, template, engine = NumberGenerator2.engines.node
   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)) {
+    const regex = getCachedRegex(name.standardize().escapeRegex(), "gi");
+    if (newDice.match(regex)) {
       let max;
       let min;
       const foundStat = template.statistics?.[name];
@@ -263,7 +264,7 @@ function diceRandomParse(value, template, engine = NumberGenerator2.engines.node
       }
       const total = template.total || 100;
       const randomStatValue = generateRandomStat(total, max, min, engine);
-      newDice = value.replace(regex, randomStatValue.toString());
+      newDice = newDice.replace(regex, randomStatValue.toString());
     }
   }
   return replaceFormulaInDice(newDice);
@@ -286,7 +287,7 @@ function evalCombinaison(combinaison, stats) {
   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");
+      const regex = getCachedRegex(statName.standardize().escapeRegex(), "gi");
       formula = formula.replace(regex, value.toString());
     }
     try {
@@ -300,7 +301,7 @@ function evalCombinaison(combinaison, stats) {
 function evalOneCombinaison(combinaison, stats) {
   let formula = combinaison.standardize();
   for (const [statName, value] of Object.entries(stats)) {
-    const regex = new RegExp(statName.standardize(), "gi");
+    const regex = getCachedRegex(statName.standardize().escapeRegex(), "gi");
     formula = formula.replace(regex, value.toString());
   }
   try {
@@ -348,7 +349,7 @@ function verifyTemplateValue(template, verify = true, engine = NumberGenerator2.
       engine
     );
     const rolled = roll(cleanedDice2, engine);
-    if (!rolled) throw new DiceTypeError(cleanedDice2, "no_roll_result", "no roll result");
+    if (!rolled) throw new DiceTypeError(cleanedDice2, "roll");
   }
   if (statistiqueTemplate.customCritical) {
     if (!statistiqueTemplate.diceType) {
@@ -373,15 +374,16 @@ function verifyTemplateValue(template, verify = true, engine = NumberGenerator2.
 }
 function testDiceRegistered(template, engine = NumberGenerator2.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)) {
+  const damageEntries = Object.entries(template.damage);
+  if (damageEntries.length === 0) throw new EmptyObjectError();
+  if (damageEntries.length > 25) throw new TooManyDice();
+  for (const [name, dice] of damageEntries) {
     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);
+      if (!rolled) throw new DiceTypeError(name, "testDiceRegistered", dice);
     } catch (error) {
       throw new DiceTypeError(name, "testDiceRegistered", error);
     }
@@ -389,19 +391,14 @@ function testDiceRegistered(template, engine = NumberGenerator2.engines.nodeCryp
 }
 function testStatCombinaison(template, engine = NumberGenerator2.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)
-  );
+  const onlycombinaisonStats = {};
+  const allOtherStats = {};
+  for (const [k, v] of Object.entries(template.statistics)) {
+    if (v.combinaison !== void 0) onlycombinaisonStats[k] = v;
+    else allOtherStats[k] = v;
+  }
   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();
+  if (Object.keys(allOtherStats).length === 0) throw new NoStatisticsError();
   const error = [];
   for (const [stat, value] of Object.entries(onlycombinaisonStats)) {
     let formula = value.combinaison;
@@ -409,7 +406,7 @@ function testStatCombinaison(template, engine = NumberGenerator2.engines.nodeCry
       const { max, min } = data;
       const total = template.total || 100;
       const randomStatValue = generateRandomStat(total, max, min, engine);
-      const regex = new RegExp(other, "gi");
+      const regex = getCachedRegex(other.escapeRegex(), "gi");
       formula = formula.replace(regex, randomStatValue.toString());
     }
     try {
@@ -422,20 +419,20 @@ function testStatCombinaison(template, engine = NumberGenerator2.engines.nodeCry
   return;
 }
 function generateRandomStat(total = 100, max, min, engine = NumberGenerator2.engines.nodeCrypto) {
-  let randomStatValue = total + 1;
+  if (total <= 1) throw new RangeError(`total must be greater than 1, got ${total}`);
   const random = new Random(engine || NumberGenerator2.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;
+  const effectiveMin = Math.max(min ?? 1, 1);
+  const effectiveMax = Math.min(max ?? total - 1, total - 1);
+  if (effectiveMin > effectiveMax) throw new MaxGreater(effectiveMin, effectiveMax);
+  return randomInt(effectiveMin, effectiveMax, engine, random);
 }
 
 // src/utils.ts
-function escapeRegex(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function splitDiceComment(dice) {
+  const match = /\s(#|\/{2}|\[|\/\*)(?<comment>.*)/i.exec(dice);
+  if (!match?.groups) return { dice: dice.trimEnd(), comment: void 0 };
+  const comment = match.groups.comment.trim() || void 0;
+  return { dice: dice.slice(0, match.index).trimEnd(), comment };
 }
 function standardizeDice(dice) {
   return dice.replace(
@@ -470,6 +467,8 @@ function createCriticalCustom(dice, customCritical, template, engine = NumberGen
 }
 
 // src/dice/compare.ts
+import { NumberGenerator as NumberGenerator4 } from "@dice-roller/rpg-dice-roller";
+import { evaluate as evaluate2 } from "mathjs";
 function isTrivialComparison(maxValue, minValue, compare) {
   const canSucceed = canComparisonSucceed(maxValue, compare, minValue);
   const canFail = canComparisonFail(maxValue, compare, minValue);
@@ -579,32 +578,31 @@ import { NumberGenerator as NumberGenerator5 } from "@dice-roller/rpg-dice-rolle
 import { evaluate as evaluate3 } from "mathjs";
 
 // src/dice/replace.ts
+var PARENTHESIS_REGEX = /d\((\d+)\)/g;
+var BRACKET_COMMENT_REGEX = /\[(?<comments>.*?)\]/;
+var OPTIONAL_COMMENT_REGEX = /\s+(#|\/\/)(?<comment>.*)/;
 function replaceUnwantedText(dice, sortOrder) {
-  const d = dice.replaceAll(/[{}]/g, "").replaceAll(/s[ad]/gi, "");
-  if (sortOrder) return sortDice(d, sortOrder);
+  let d = dice.replaceAll(/[{}]/g, "").replaceAll(/s[ad]/gi, "");
+  if (sortOrder) d = sortDice(d, sortOrder);
+  if (!d.length) throw new DiceTypeError(dice, "empty_dice");
   return d;
 }
 function sortDice(dice, sortOrder) {
   if (sortOrder === "none" /* None */) return dice;
   const dices = dice.split(/; ?/);
+  const decorated = dices.map((d) => ({
+    d,
+    v: Number.parseInt(d.split("= ")[1], 10) || 0
+  }));
   if (sortOrder === "sa" /* Ascending */) {
-    dices.sort((a, b) => {
-      const totalA = Number.parseInt(a.split("= ")[1], 10) || 0;
-      const totalB = Number.parseInt(b.split("= ")[1], 10) || 0;
-      return totalB - totalA;
-    });
+    decorated.sort((a, b) => b.v - a.v);
   } else if (sortOrder === "sd" /* Descending */) {
-    dices.sort((a, b) => {
-      const totalA = Number.parseInt(a.split("= ")[1], 10) || 0;
-      const totalB = Number.parseInt(b.split("= ")[1], 10) || 0;
-      return totalA - totalB;
-    });
+    decorated.sort((a, b) => a.v - b.v);
   }
-  return dices.join("; ");
+  return decorated.map((x) => x.d).join("; ");
 }
 function fixParenthesis(dice) {
-  const parenthesisRegex = /d\((\d+)\)/g;
-  return dice.replaceAll(parenthesisRegex, (_match, p1) => `d${p1}`);
+  return dice.replaceAll(PARENTHESIS_REGEX, (_match, p1) => `d${p1}`);
 }
 function replaceText(element, total, dice) {
   return {
@@ -613,12 +611,10 @@ function replaceText(element, total, dice) {
   };
 }
 function formatComment(dice) {
-  const commentsRegex = /\[(?<comments>.*?)\]/;
-  const commentsMatch = commentsRegex.exec(dice);
+  const commentsMatch = BRACKET_COMMENT_REGEX.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 diceWithoutBrackets = dice.replace(BRACKET_COMMENT_REGEX, "");
+  const optionalComments = OPTIONAL_COMMENT_REGEX.exec(diceWithoutBrackets);
   const optional = optionalComments?.groups?.comment ? `${optionalComments.groups.comment.trim()}` : "";
   let finalComment = "";
   if (comments && optional) finalComment = `__${comments} ${optional}__ \u2014 `;
@@ -770,23 +766,27 @@ function calculateSimilarity(str1, str2) {
   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;
+  if (str1.length > str2.length) {
+    [str1, str2] = [str2, str1];
+  }
+  let prev = Array.from({ length: str1.length + 1 }, (_, i) => i);
+  let curr = new Array(str1.length + 1);
   for (let j = 1; j <= str2.length; j++) {
+    curr[0] = 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,
+      curr[i] = Math.min(
+        curr[i - 1] + 1,
         // insertion
-        matrix[j - 1][i] + 1,
+        prev[i] + 1,
         // deletion
-        matrix[j - 1][i - 1] + cost
+        prev[i - 1] + cost
         // substitution
       );
     }
+    [prev, curr] = [curr, prev];
   }
-  return matrix[str2.length][str1.length];
+  return prev[str1.length];
 }
 function findBestStatMatch(searchTerm, normalizedStats, similarityThreshold = MIN_THRESHOLD_MATCH) {
   const exact = normalizedStats.get(searchTerm);
@@ -1060,28 +1060,23 @@ function setSortOrder(toRoll, sort) {
 }
 function prepareDice(diceInput) {
   let dice = standardizeDice(replaceFormulaInDice(diceInput)).replace(/^\+/, "").replaceAll("=>", ">=").replaceAll("=<", "<=").trimStart();
-  dice = dice.replaceAll(DETECT_CRITICAL, "").trimEnd();
+  dice = dice.replaceAll(REMOVER_PATTERN.CRITICAL_BLOCK, "").trimEnd();
   const explodingSuccess = normalizeExplodingSuccess(dice);
   if (explodingSuccess) dice = explodingSuccess.dice;
-  let diceDisplay;
-  if (dice.includes(";")) {
-    const mainDice = dice.split(";")[0];
-    diceDisplay = explodingSuccess?.originalDice ?? mainDice;
-  } else {
-    diceDisplay = explodingSuccess?.originalDice ?? dice;
-  }
+  const sharedSeparatorIndex = dice.indexOf(";");
+  const hasSharedSeparator = sharedSeparatorIndex !== -1;
+  let diceDisplay = explodingSuccess?.originalDice ?? (hasSharedSeparator ? dice.slice(0, sharedSeparatorIndex) : dice);
   const curlyBulkMatch = dice.match(/^\{(\d+#.*)\}$/);
   const isCurlyBulk = !!curlyBulkMatch;
   const bulkContent = isCurlyBulk ? curlyBulkMatch[1] : "";
-  const isSharedRoll = dice.includes(";");
   let isSharedCurly = false;
-  if (isSharedRoll && dice.match(/^\{.*;\s*.*\}$/)) {
+  if (hasSharedSeparator && dice.match(/^\{.*;\s*.*\}$/)) {
     dice = dice.slice(1, -1);
     isSharedCurly = true;
     diceDisplay = diceDisplay.slice(1);
   }
   let isSimpleCurly = false;
-  if (!isCurlyBulk && !isSharedRoll && dice.match(/^\{.*\}$/)) {
+  if (!isCurlyBulk && !hasSharedSeparator && dice.match(/^\{.*\}$/)) {
     const innerContent = dice.slice(1, -1);
     const hasModifiers = innerContent.match(/[+\-*/%^]/);
     const hasComparison = innerContent.match(/(([><=!]+\d+f)|([><=]|!=)+\d+)/);
@@ -1094,7 +1089,7 @@ function prepareDice(diceInput) {
     dice,
     diceDisplay,
     explodingSuccess,
-    isSharedRoll,
+    isSharedRoll: hasSharedSeparator,
     isSharedCurly,
     isCurlyBulk,
     bulkContent,
@@ -1111,10 +1106,15 @@ function getSortOrder(dice) {
 function handleBulkRolls(dice, isCurlyBulk, bulkContent, compare, explodingSuccess, diceDisplay, engine, sort) {
   const bulkProcessContent = isCurlyBulk ? bulkContent : dice;
   const diceArray = bulkProcessContent.split("#");
+  if (!isNumber(diceArray[0])) {
+    throw new DiceTypeError(dice, "bulk_number");
+  }
   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;
+  if (numberOfDice <= 0) {
+    throw new DiceTypeError(dice, "bulk_zero");
+  }
+  const { dice: diceToRollBase, comment: comments } = splitDiceComment(diceArray[1]);
+  let diceToRoll = diceToRollBase;
   let curlyCompare;
   if (isCurlyBulk) {
     const curlyCompareRegex = diceToRoll.match(SIGN_REGEX_SPACE);
@@ -1295,11 +1295,12 @@ function handlePitySystem(dice, compare, diceRoll, roller, engine) {
       isFail = evaluate9(`${res.total}${compare.sign}${compare.value}`);
     }
   }
+  if (!res?.result.length) throw new DiceTypeError(dice, "empty_dice");
   return { rerollCount, result: res };
 }
 
 // src/roll.ts
-function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
+function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort, comment) {
   if (sort === "none" /* None */) sort = void 0;
   const prepared = prepareDice(dice);
   if (!prepared.dice.includes("d")) return void 0;
@@ -1342,8 +1343,10 @@ function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
   }
   const roller = new DiceRoller3();
   NumberGenerator8.generator.engine = engine;
-  let diceWithoutComment = processedDice.replace(COMMENT_REGEX, "").trimEnd();
-  diceWithoutComment = setSortOrder(diceWithoutComment, sort);
+  const splitResult = splitDiceComment(processedDice);
+  const diceBase = comment !== void 0 ? processedDice.trimEnd() : splitResult.dice;
+  const resolvedComment = comment ?? splitResult.comment;
+  const diceWithoutComment = setSortOrder(diceBase, sort);
   let diceRoll;
   try {
     diceRoll = roller.roll(diceWithoutComment);
@@ -1359,8 +1362,6 @@ function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
     );
     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) {
@@ -1377,7 +1378,7 @@ function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
       return {
         ...pityResult,
         dice: prepared.isSimpleCurly ? finalDiceDisplay : processedDice,
-        comment,
+        comment: resolvedComment,
         compare,
         modifier: modificator,
         pityLogs: rerollCount,
@@ -1396,10 +1397,11 @@ function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
       prepared.explodingSuccess.normalizedSegment,
       prepared.explodingSuccess.originalSegment
     );
+    if (!resultOutput.length) throw new DiceTypeError(dice, "empty_dice");
     return {
       dice: prepared.isSimpleCurly ? finalDiceDisplay : prepared.diceDisplay,
       result: resultOutput,
-      comment,
+      comment: resolvedComment,
       compare: compare ? compare : void 0,
       modifier: modificator,
       total: successes,
@@ -1410,7 +1412,7 @@ function roll(dice, engine = NumberGenerator8.engines.nodeCrypto, pity, sort) {
   return {
     dice: prepared.isSimpleCurly ? finalDiceDisplay : processedDice,
     result: resultOutput,
-    comment,
+    comment: resolvedComment,
     compare: compare ? compare : void 0,
     modifier: modificator,
     total: roller.total,
@@ -1605,7 +1607,6 @@ export {
   createCriticalCustom,
   diceRandomParse,
   diceTypeRandomParse,
-  escapeRegex,
   evalCombinaison,
   evalOneCombinaison,
   evalStatsDice,
@@ -1626,6 +1627,7 @@ export {
   replaceUnknown,
   resolveFormulaHint,
   roll,
+  splitDiceComment,
   standardizeDice,
   templateSchema,
   testDiceRegistered,