@vitest/utils 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/diff.js

@@ -21,14 +21,15 @@ function getType(value) {
     return "bigint";
   } else if (typeof value === "object") {
     if (value != null) {
-      if (value.constructor === RegExp)
+      if (value.constructor === RegExp) {
         return "regexp";
-      else if (value.constructor === Map)
+      } else if (value.constructor === Map) {
         return "map";
-      else if (value.constructor === Set)
+      } else if (value.constructor === Set) {
         return "set";
-      else if (value.constructor === Date)
+      } else if (value.constructor === Date) {
         return "date";
+      }
     }
     return "object";
   } else if (typeof value === "symbol") {
@@ -49,8 +50,9 @@ class Diff {
   }
 }
 const diff_commonPrefix = function(text1, text2) {
-  if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0))
+  if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {
     return 0;
+  }
   let pointermin = 0;
   let pointermax = Math.min(text1.length, text2.length);
   let pointermid = pointermax;
@@ -67,8 +69,9 @@ const diff_commonPrefix = function(text1, text2) {
   return pointermid;
 };
 const diff_commonSuffix = function(text1, text2) {
-  if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1))
+  if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) {
     return 0;
+  }
   let pointermin = 0;
   let pointermax = Math.min(text1.length, text2.length);
   let pointermid = pointermax;
@@ -87,22 +90,26 @@ const diff_commonSuffix = function(text1, text2) {
 const diff_commonOverlap_ = function(text1, text2) {
   const text1_length = text1.length;
   const text2_length = text2.length;
-  if (text1_length === 0 || text2_length === 0)
+  if (text1_length === 0 || text2_length === 0) {
     return 0;
-  if (text1_length > text2_length)
+  }
+  if (text1_length > text2_length) {
     text1 = text1.substring(text1_length - text2_length);
-  else if (text1_length < text2_length)
+  } else if (text1_length < text2_length) {
     text2 = text2.substring(0, text1_length);
+  }
   const text_length = Math.min(text1_length, text2_length);
-  if (text1 === text2)
+  if (text1 === text2) {
     return text_length;
+  }
   let best = 0;
   let length = 1;
   while (true) {
     const pattern = text1.substring(text_length - length);
     const found = text2.indexOf(pattern);
-    if (found === -1)
+    if (found === -1) {
       return best;
+    }
     length += found;
     if (found === 0 || text1.substring(text_length - length) === text2.substring(0, length)) {
       best = length;
@@ -129,12 +136,17 @@ const diff_cleanupSemantic = function(diffs) {
       length_deletions2 = 0;
       lastEquality = diffs[pointer][1];
     } else {
-      if (diffs[pointer][0] === DIFF_INSERT)
+      if (diffs[pointer][0] === DIFF_INSERT) {
         length_insertions2 += diffs[pointer][1].length;
-      else
+      } else {
         length_deletions2 += diffs[pointer][1].length;
+      }
       if (lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2)) {
-        diffs.splice(equalities[equalitiesLength - 1], 0, new Diff(DIFF_DELETE, lastEquality));
+        diffs.splice(
+          equalities[equalitiesLength - 1],
+          0,
+          new Diff(DIFF_DELETE, lastEquality)
+        );
         diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
         equalitiesLength--;
         equalitiesLength--;
@@ -149,8 +161,9 @@ const diff_cleanupSemantic = function(diffs) {
     }
     pointer++;
   }
-  if (changes)
+  if (changes) {
     diff_cleanupMerge(diffs);
+  }
   diff_cleanupSemanticLossless(diffs);
   pointer = 1;
   while (pointer < diffs.length) {
@@ -161,16 +174,30 @@ const diff_cleanupSemantic = function(diffs) {
       const overlap_length2 = diff_commonOverlap_(insertion, deletion);
       if (overlap_length1 >= overlap_length2) {
         if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
-          diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1)));
-          diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
+          diffs.splice(
+            pointer,
+            0,
+            new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1))
+          );
+          diffs[pointer - 1][1] = deletion.substring(
+            0,
+            deletion.length - overlap_length1
+          );
           diffs[pointer + 1][1] = insertion.substring(overlap_length1);
           pointer++;
         }
       } else {
         if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
-          diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2)));
+          diffs.splice(
+            pointer,
+            0,
+            new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2))
+          );
           diffs[pointer - 1][0] = DIFF_INSERT;
-          diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+          diffs[pointer - 1][1] = insertion.substring(
+            0,
+            insertion.length - overlap_length2
+          );
           diffs[pointer + 1][0] = DIFF_DELETE;
           diffs[pointer + 1][1] = deletion.substring(overlap_length2);
           pointer++;
@@ -181,7 +208,7 @@ const diff_cleanupSemantic = function(diffs) {
     pointer++;
   }
 };
-const nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
+const nonAlphaNumericRegex_ = /[^a-z0-9]/i;
 const whitespaceRegex_ = /\s/;
 const linebreakRegex_ = /[\r\n]/;
 const blanklineEndRegex_ = /\n\r?\n$/;
@@ -290,7 +317,11 @@ function diff_cleanupMerge(diffs) {
               if (pointer - count_delete - count_insert > 0 && diffs[pointer - count_delete - count_insert - 1][0] === DIFF_EQUAL) {
                 diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
               } else {
-                diffs.splice(0, 0, new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength)));
+                diffs.splice(
+                  0,
+                  0,
+                  new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength))
+                );
                 pointer++;
               }
               text_insert = text_insert.substring(commonlength);
@@ -299,8 +330,14 @@ function diff_cleanupMerge(diffs) {
             commonlength = diff_commonSuffix(text_insert, text_delete);
             if (commonlength !== 0) {
               diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];
-              text_insert = text_insert.substring(0, text_insert.length - commonlength);
-              text_delete = text_delete.substring(0, text_delete.length - commonlength);
+              text_insert = text_insert.substring(
+                0,
+                text_insert.length - commonlength
+              );
+              text_delete = text_delete.substring(
+                0,
+                text_delete.length - commonlength
+              );
             }
           }
           pointer -= count_delete + count_insert;
@@ -327,14 +364,20 @@ function diff_cleanupMerge(diffs) {
         break;
     }
   }
-  if (diffs[diffs.length - 1][1] === "")
+  if (diffs[diffs.length - 1][1] === "") {
     diffs.pop();
+  }
   let changes = false;
   pointer = 1;
   while (pointer < diffs.length - 1) {
     if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
-      if (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {
-        diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length);
+      if (diffs[pointer][1].substring(
+        diffs[pointer][1].length - diffs[pointer - 1][1].length
+      ) === diffs[pointer - 1][1]) {
+        diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(
+          0,
+          diffs[pointer][1].length - diffs[pointer - 1][1].length
+        );
         diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
         diffs.splice(pointer - 1, 1);
         changes = true;
@@ -347,8 +390,9 @@ function diff_cleanupMerge(diffs) {
     }
     pointer++;
   }
-  if (changes)
+  if (changes) {
     diff_cleanupMerge(diffs);
+  }
 }
 
 const NO_DIFF_MESSAGE = "Compared values have no visual difference.";
@@ -422,8 +466,9 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   let i = 0;
   while (i !== iLength) {
     const iStart = i;
-    while (i !== iLength && diffs[i][0] === DIFF_EQUAL)
+    while (i !== iLength && diffs[i][0] === DIFF_EQUAL) {
       i += 1;
+    }
     if (iStart !== i) {
       if (iStart === 0) {
         if (i > nContextLines) {
@@ -444,19 +489,22 @@ function joinAlignedDiffsNoExpand(diffs, options) {
         }
       }
     }
-    while (i !== iLength && diffs[i][0] !== DIFF_EQUAL)
+    while (i !== iLength && diffs[i][0] !== DIFF_EQUAL) {
       i += 1;
+    }
   }
   const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
-  if (nExcessesBetweenChanges !== 0)
+  if (nExcessesBetweenChanges !== 0) {
     jLength += nExcessesBetweenChanges + 1;
-  else if (hasExcessAtStartOrEnd)
+  } else if (hasExcessAtStartOrEnd) {
     jLength += 1;
+  }
   const jLast = jLength - 1;
   const lines = [];
   let jPatchMark = 0;
-  if (hasPatch)
+  if (hasPatch) {
     lines.push("");
+  }
   let aStart = 0;
   let bStart = 0;
   let aEnd = 0;
@@ -480,8 +528,9 @@ function joinAlignedDiffsNoExpand(diffs, options) {
   i = 0;
   while (i !== iLength) {
     let iStart = i;
-    while (i !== iLength && diffs[i][0] === DIFF_EQUAL)
+    while (i !== iLength && diffs[i][0] === DIFF_EQUAL) {
       i += 1;
+    }
     if (iStart !== i) {
       if (iStart === 0) {
         if (i > nContextLines) {
@@ -491,18 +540,21 @@ function joinAlignedDiffsNoExpand(diffs, options) {
           aEnd = aStart;
           bEnd = bStart;
         }
-        for (let iCommon = iStart; iCommon !== i; iCommon += 1)
+        for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
           pushCommonLine(diffs[iCommon][1]);
+        }
       } else if (i === iLength) {
         const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
-        for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1)
+        for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
           pushCommonLine(diffs[iCommon][1]);
+        }
       } else {
         const nCommon = i - iStart;
         if (nCommon > nContextLines2) {
           const iEnd = iStart + nContextLines;
-          for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1)
+          for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
             pushCommonLine(diffs[iCommon][1]);
+          }
           lines[jPatchMark] = createPatchMark(
             aStart,
             aEnd,
@@ -517,11 +569,13 @@ function joinAlignedDiffsNoExpand(diffs, options) {
           bStart = bEnd + nOmit;
           aEnd = aStart;
           bEnd = bStart;
-          for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1)
+          for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) {
             pushCommonLine(diffs[iCommon][1]);
+          }
         } else {
-          for (let iCommon = iStart; iCommon !== i; iCommon += 1)
+          for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
             pushCommonLine(diffs[iCommon][1]);
+          }
         }
       }
     }
@@ -534,8 +588,9 @@ function joinAlignedDiffsNoExpand(diffs, options) {
       i += 1;
     }
   }
-  if (hasPatch)
+  if (hasPatch) {
     lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
+  }
   return lines.join("\n");
 }
 function joinAlignedDiffsExpand(diffs, options) {
@@ -625,8 +680,9 @@ function printAnnotation({
   includeChangeCounts,
   omitAnnotationLines
 }, changeCounts) {
-  if (omitAnnotationLines)
+  if (omitAnnotationLines) {
     return "";
+  }
   let aRest = "";
   let bRest = "";
   if (includeChangeCounts) {
@@ -659,11 +715,7 @@ function diffLinesUnified(aLines, bLines, options) {
     isEmptyString(bLines) ? [] : bLines,
     normalizedOptions
   );
-  return printDiffLines(
-    diffs,
-    truncated,
-    normalizedOptions
-  );
+  return printDiffLines(diffs, truncated, normalizedOptions);
 }
 function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options) {
   if (isEmptyString(aLinesDisplay) && isEmptyString(aLinesCompare)) {
@@ -677,7 +729,11 @@ function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCo
   if (aLinesDisplay.length !== aLinesCompare.length || bLinesDisplay.length !== bLinesCompare.length) {
     return diffLinesUnified(aLinesDisplay, bLinesDisplay, options);
   }
-  const [diffs, truncated] = diffLinesRaw(aLinesCompare, bLinesCompare, options);
+  const [diffs, truncated] = diffLinesRaw(
+    aLinesCompare,
+    bLinesCompare,
+    options
+  );
   let aIndex = 0;
   let bIndex = 0;
   diffs.forEach((diff2) => {
@@ -700,7 +756,10 @@ function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCo
 }
 function diffLinesRaw(aLines, bLines, options) {
   const truncate = (options == null ? void 0 : options.truncateThreshold) ?? false;
-  const truncateThreshold = Math.max(Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0), 0);
+  const truncateThreshold = Math.max(
+    Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0),
+    0
+  );
   const aLength = truncate ? Math.min(aLines.length, truncateThreshold) : aLines.length;
   const bLength = truncate ? Math.min(bLines.length, truncateThreshold) : bLines.length;
   const truncated = aLength !== aLines.length || bLength !== bLines.length;
@@ -709,19 +768,24 @@ function diffLinesRaw(aLines, bLines, options) {
   let aIndex = 0;
   let bIndex = 0;
   const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    for (; aIndex !== aCommon; aIndex += 1)
+    for (; aIndex !== aCommon; aIndex += 1) {
       diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
-    for (; bIndex !== bCommon; bIndex += 1)
+    }
+    for (; bIndex !== bCommon; bIndex += 1) {
       diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
-    for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1)
+    }
+    for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
       diffs.push(new Diff(DIFF_EQUAL, bLines[bIndex]));
+    }
   };
   const diffSequences = diff$1.default.default || diff$1.default;
   diffSequences(aLength, bLength, isCommon, foundSubsequence);
-  for (; aIndex !== aLength; aIndex += 1)
+  for (; aIndex !== aLength; aIndex += 1) {
     diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
-  for (; bIndex !== bLength; bIndex += 1)
+  }
+  for (; bIndex !== bLength; bIndex += 1) {
     diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
+  }
   return [diffs, truncated];
 }
 
@@ -730,7 +794,10 @@ function getNewLineSymbol(string) {
 }
 function diffStrings(a, b, options) {
   const truncate = (options == null ? void 0 : options.truncateThreshold) ?? false;
-  const truncateThreshold = Math.max(Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0), 0);
+  const truncateThreshold = Math.max(
+    Math.floor((options == null ? void 0 : options.truncateThreshold) ?? 0),
+    0
+  );
   let aLength = a.length;
   let bLength = b.length;
   if (truncate) {
@@ -751,20 +818,24 @@ function diffStrings(a, b, options) {
   let bIndex = 0;
   const diffs = [];
   const foundSubsequence = (nCommon, aCommon, bCommon) => {
-    if (aIndex !== aCommon)
+    if (aIndex !== aCommon) {
       diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex, aCommon)));
-    if (bIndex !== bCommon)
+    }
+    if (bIndex !== bCommon) {
       diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
+    }
     aIndex = aCommon + nCommon;
     bIndex = bCommon + nCommon;
     diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
   };
   const diffSequences = diff$1.default.default || diff$1.default;
   diffSequences(aLength, bLength, isCommon, foundSubsequence);
-  if (aIndex !== aLength)
+  if (aIndex !== aLength) {
     diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
-  if (bIndex !== bLength)
+  }
+  if (bIndex !== bLength) {
     diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
+  }
   return [diffs, truncated];
 }
 
@@ -827,8 +898,9 @@ class ChangeBuffer {
   }
   // Output from buffer.
   moveLinesTo(lines) {
-    if (!this.isLineEmpty())
+    if (!this.isLineEmpty()) {
       this.pushLine();
+    }
     lines.push(...this.lines);
     this.lines.length = 0;
   }
@@ -847,10 +919,12 @@ class CommonBuffer {
   }
   pushDiffChangeLines(diff) {
     const isDiffEmpty = diff[1].length === 0;
-    if (!isDiffEmpty || this.deleteBuffer.isLineEmpty())
+    if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {
       this.deleteBuffer.pushDiff(diff);
-    if (!isDiffEmpty || this.insertBuffer.isLineEmpty())
+    }
+    if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {
       this.insertBuffer.pushDiff(diff);
+    }
   }
   flushChangeLines() {
     this.deleteBuffer.moveLinesTo(this.lines);
@@ -939,8 +1013,9 @@ function diffStringsUnified(a, b, options) {
 }
 function diffStringsRaw(a, b, cleanup, options) {
   const [diffs, truncated] = diffStrings(a, b, options);
-  if (cleanup)
+  if (cleanup) {
     diff_cleanupSemantic(diffs);
+  }
   return [diffs, truncated];
 }
 
@@ -973,8 +1048,9 @@ const FALLBACK_FORMAT_OPTIONS = {
   plugins: PLUGINS
 };
 function diff(a, b, options) {
-  if (Object.is(a, b))
+  if (Object.is(a, b)) {
     return "";
+  }
   const aType = getType(a);
   let expectedType = aType;
   let omitDifference = false;
@@ -1001,8 +1077,9 @@ ${bDisplay}`;
 
 ${bDiff}`;
   }
-  if (omitDifference)
+  if (omitDifference) {
     return null;
+  }
   switch (aType) {
     case "string":
       return diffLinesUnified(a.split("\n"), b.split("\n"), options);

package/dist/error.js

@@ -13,33 +13,45 @@ function isImmutable(v) {
 }
 const OBJECT_PROTO = Object.getPrototypeOf({});
 function getUnserializableMessage(err) {
-  if (err instanceof Error)
+  if (err instanceof Error) {
     return `<unserializable>: ${err.message}`;
-  if (typeof err === "string")
+  }
+  if (typeof err === "string") {
     return `<unserializable>: ${err}`;
+  }
   return "<unserializable>";
 }
 function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
-  if (!val || typeof val === "string")
+  if (!val || typeof val === "string") {
     return val;
-  if (typeof val === "function")
+  }
+  if (typeof val === "function") {
     return `Function<${val.name || "anonymous"}>`;
-  if (typeof val === "symbol")
+  }
+  if (typeof val === "symbol") {
     return val.toString();
-  if (typeof val !== "object")
+  }
+  if (typeof val !== "object") {
     return val;
-  if (isImmutable(val))
+  }
+  if (isImmutable(val)) {
     return serializeError(val.toJSON(), seen);
-  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction")
+  }
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") {
     return "Promise";
-  if (typeof Element !== "undefined" && val instanceof Element)
+  }
+  if (typeof Element !== "undefined" && val instanceof Element) {
     return val.tagName;
-  if (typeof val.asymmetricMatch === "function")
+  }
+  if (typeof val.asymmetricMatch === "function") {
     return `${val.toString()} ${format(val.sample)}`;
-  if (typeof val.toJSON === "function")
-    return val.toJSON();
-  if (seen.has(val))
+  }
+  if (typeof val.toJSON === "function") {
+    return serializeError(val.toJSON(), seen);
+  }
+  if (seen.has(val)) {
     return seen.get(val);
+  }
   if (Array.isArray(val)) {
     const clone = new Array(val.length);
     seen.set(val, clone);
@@ -57,8 +69,9 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     let obj = val;
     while (obj && obj !== OBJECT_PROTO) {
       Object.getOwnPropertyNames(obj).forEach((key) => {
-        if (key in clone)
+        if (key in clone) {
           return;
+        }
         try {
           clone[key] = serializeError(val[key], seen);
         } catch (err) {
@@ -75,25 +88,37 @@ function normalizeErrorMessage(message) {
   return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
 }
 function processError(err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
-  if (!err || typeof err !== "object")
+  if (!err || typeof err !== "object") {
     return { message: err };
-  if (err.stack)
+  }
+  if (err.stack) {
     err.stackStr = String(err.stack);
-  if (err.name)
+  }
+  if (err.name) {
     err.nameStr = String(err.name);
+  }
   if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
     const clonedActual = deepClone(err.actual, { forceWritable: true });
     const clonedExpected = deepClone(err.expected, { forceWritable: true });
-    const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(clonedActual, clonedExpected);
-    err.diff = diff(replacedExpected, replacedActual, { ...diffOptions, ...err.diffOptions });
+    const { replacedActual, replacedExpected } = replaceAsymmetricMatcher(
+      clonedActual,
+      clonedExpected
+    );
+    err.diff = diff(replacedExpected, replacedActual, {
+      ...diffOptions,
+      ...err.diffOptions
+    });
   }
-  if (typeof err.expected !== "string")
+  if (typeof err.expected !== "string") {
     err.expected = stringify(err.expected, 10);
-  if (typeof err.actual !== "string")
+  }
+  if (typeof err.actual !== "string") {
     err.actual = stringify(err.actual, 10);
+  }
   try {
-    if (typeof err.message === "string")
+    if (typeof err.message === "string") {
       err.message = normalizeErrorMessage(err.message);
+    }
   } catch {
   }
   try {
@@ -106,8 +131,12 @@ function processError(err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
   try {
     return serializeError(err);
   } catch (e) {
-    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}
-Inner error message: ${err == null ? void 0 : err.message}`));
+    return serializeError(
+      new Error(
+        `Failed to fully serialize error: ${e == null ? void 0 : e.message}
+Inner error message: ${err == null ? void 0 : err.message}`
+      )
+    );
   }
 }
 function isAsymmetricMatcher(data) {
@@ -120,21 +149,25 @@ function isReplaceable(obj1, obj2) {
   return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
 }
 function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
-  if (!isReplaceable(actual, expected))
+  if (!isReplaceable(actual, expected)) {
     return { replacedActual: actual, replacedExpected: expected };
-  if (actualReplaced.has(actual) || expectedReplaced.has(expected))
+  }
+  if (actualReplaced.has(actual) || expectedReplaced.has(expected)) {
     return { replacedActual: actual, replacedExpected: expected };
+  }
   actualReplaced.add(actual);
   expectedReplaced.add(expected);
   getOwnProperties(expected).forEach((key) => {
     const expectedValue = expected[key];
     const actualValue = actual[key];
     if (isAsymmetricMatcher(expectedValue)) {
-      if (expectedValue.asymmetricMatch(actualValue))
+      if (expectedValue.asymmetricMatch(actualValue)) {
         actual[key] = expectedValue;
+      }
     } else if (isAsymmetricMatcher(actualValue)) {
-      if (actualValue.asymmetricMatch(expectedValue))
+      if (actualValue.asymmetricMatch(expectedValue)) {
         expected[key] = actualValue;
+      }
     } else if (isReplaceable(actualValue, expectedValue)) {
       const replaced = replaceAsymmetricMatcher(
         actualValue,

package/dist/helpers.d.ts

@@ -31,5 +31,6 @@ declare function createDefer<T>(): DeferPromise<T>;
  * ```
  */
 declare function getCallLastIndex(code: string): number | null;
+declare function isNegativeNaN(val: number): boolean;
 
-export { type DeferPromise, assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };
+export { type DeferPromise, assertTypes, clone, createDefer, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };