@vitest/utils 2.0.0-beta.9 → 2.0.0

package/dist/ast.js

@@ -14,8 +14,9 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
   const identifiers = [];
   const setScope = (node, name) => {
     let scopeIds = scopeMap.get(node);
-    if (scopeIds && scopeIds.has(name))
+    if (scopeIds && scopeIds.has(name)) {
       return;
+    }
     if (!scopeIds) {
       scopeIds = /* @__PURE__ */ new Set();
       scopeMap.set(node, scopeIds);
@@ -35,15 +36,17 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
       handlePattern(p.argument, parentScope);
     } else if (p.type === "ObjectPattern") {
       p.properties.forEach((property) => {
-        if (property.type === "RestElement")
+        if (property.type === "RestElement") {
           setScope(parentScope, property.argument.name);
-        else
+        } else {
           handlePattern(property.value, parentScope);
+        }
       });
     } else if (p.type === "ArrayPattern") {
       p.elements.forEach((element) => {
-        if (element)
+        if (element) {
           handlePattern(element, parentScope);
+        }
       });
     } else if (p.type === "AssignmentPattern") {
       handlePattern(p.left, parentScope);
@@ -53,18 +56,23 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
   }
   walk(root, {
     enter(node, parent) {
-      if (node.type === "ImportDeclaration")
+      if (node.type === "ImportDeclaration") {
         return this.skip();
-      if (parent && !(parent.type === "IfStatement" && node === parent.alternate))
+      }
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
         parentStack.unshift(parent);
-      if (node.type === "VariableDeclaration")
+      }
+      if (node.type === "VariableDeclaration") {
         varKindStack.unshift(node.kind);
-      if (node.type === "CallExpression")
+      }
+      if (node.type === "CallExpression") {
         onCallExpression == null ? void 0 : onCallExpression(node);
-      if (node.type === "MetaProperty" && node.meta.name === "import")
+      }
+      if (node.type === "MetaProperty" && node.meta.name === "import") {
         onImportMeta == null ? void 0 : onImportMeta(node);
-      else if (node.type === "ImportExpression")
+      } else if (node.type === "ImportExpression") {
         onDynamicImport == null ? void 0 : onDynamicImport(node);
+      }
       if (node.type === "Identifier") {
         if (!isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack)) {
           identifiers.push([node, parentStack.slice(0)]);
@@ -72,8 +80,9 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
       } else if (isFunctionNode(node)) {
         if (node.type === "FunctionDeclaration") {
           const parentScope = findParentScope(parentStack);
-          if (parentScope)
+          if (parentScope) {
             setScope(parentScope, node.id.name);
+          }
         }
         node.params.forEach((p) => {
           if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
@@ -82,14 +91,18 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
           }
           walk(p.type === "AssignmentPattern" ? p.left : p, {
             enter(child, parent2) {
-              if ((parent2 == null ? void 0 : parent2.type) === "AssignmentPattern" && (parent2 == null ? void 0 : parent2.right) === child)
+              if ((parent2 == null ? void 0 : parent2.type) === "AssignmentPattern" && (parent2 == null ? void 0 : parent2.right) === child) {
                 return this.skip();
-              if (child.type !== "Identifier")
+              }
+              if (child.type !== "Identifier") {
                 return;
-              if (isStaticPropertyKey(child, parent2))
+              }
+              if (isStaticPropertyKey(child, parent2)) {
                 return;
-              if ((parent2 == null ? void 0 : parent2.type) === "TemplateLiteral" && (parent2 == null ? void 0 : parent2.expressions.includes(child)) || (parent2 == null ? void 0 : parent2.type) === "CallExpression" && (parent2 == null ? void 0 : parent2.callee) === child)
+              }
+              if ((parent2 == null ? void 0 : parent2.type) === "TemplateLiteral" && (parent2 == null ? void 0 : parent2.expressions.includes(child)) || (parent2 == null ? void 0 : parent2.type) === "CallExpression" && (parent2 == null ? void 0 : parent2.callee) === child) {
                 return;
+              }
               setScope(node, child.name);
             }
           });
@@ -101,17 +114,20 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
           parentStack,
           varKindStack[0] === "var"
         );
-        if (parentFunction)
+        if (parentFunction) {
           handlePattern(node.id, parentFunction);
+        }
       } else if (node.type === "CatchClause" && node.param) {
         handlePattern(node.param, node);
       }
     },
     leave(node, parent) {
-      if (parent && !(parent.type === "IfStatement" && node === parent.alternate))
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
         parentStack.shift();
-      if (node.type === "VariableDeclaration")
+      }
+      if (node.type === "VariableDeclaration") {
         varKindStack.shift();
+      }
     }
   });
   identifiers.forEach(([node, stack]) => {
@@ -121,37 +137,51 @@ function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallEx
       const hasBindingShortcut = isStaticProperty(parent) && parent.shorthand && (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack));
       const classDeclaration = parent.type === "PropertyDefinition" && (grandparent == null ? void 0 : grandparent.type) === "ClassBody" || parent.type === "ClassDeclaration" && node === parent.superClass;
       const classExpression = parent.type === "ClassExpression" && node === parent.id;
-      onIdentifier == null ? void 0 : onIdentifier(node, {
-        hasBindingShortcut,
-        classDeclaration,
-        classExpression
-      }, stack);
+      onIdentifier == null ? void 0 : onIdentifier(
+        node,
+        {
+          hasBindingShortcut,
+          classDeclaration,
+          classExpression
+        },
+        stack
+      );
     }
   });
 }
 function isRefIdentifier(id, parent, parentStack) {
-  if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id)
+  if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id) {
     return false;
+  }
   if (isFunctionNode(parent)) {
-    if (parent.id === id)
+    if (parent.id === id) {
       return false;
-    if (parent.params.includes(id))
+    }
+    if (parent.params.includes(id)) {
       return false;
+    }
   }
-  if (parent.type === "MethodDefinition" && !parent.computed)
+  if (parent.type === "MethodDefinition" && !parent.computed) {
     return false;
-  if (isStaticPropertyKey(id, parent))
+  }
+  if (isStaticPropertyKey(id, parent)) {
     return false;
-  if (isNodeInPattern(parent) && parent.value === id)
+  }
+  if (isNodeInPattern(parent) && parent.value === id) {
     return false;
-  if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack))
+  }
+  if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack)) {
     return false;
-  if (parent.type === "MemberExpression" && parent.property === id && !parent.computed)
+  }
+  if (parent.type === "MemberExpression" && parent.property === id && !parent.computed) {
     return false;
-  if (parent.type === "ExportSpecifier")
+  }
+  if (parent.type === "ExportSpecifier") {
     return false;
-  if (id.name === "arguments")
+  }
+  if (id.name === "arguments") {
     return false;
+  }
   return true;
 }
 function isStaticProperty(node) {
@@ -172,8 +202,9 @@ function findParentScope(parentStack, isVar = false) {
   return parentStack.find(isVar ? isFunctionNode : isBlock);
 }
 function isInDestructuringAssignment(parent, parentStack) {
-  if (parent && (parent.type === "Property" || parent.type === "ArrayPattern"))
+  if (parent && (parent.type === "Property" || parent.type === "ArrayPattern")) {
     return parentStack.some((i) => i.type === "AssignmentExpression");
+  }
   return false;
 }
 

package/dist/chunk-colors.js

@@ -33,10 +33,13 @@ function string(str) {
 }
 string.open = "";
 string.close = "";
-const defaultColors = /* @__PURE__ */ colorsEntries.reduce((acc, [key]) => {
-  acc[key] = string;
-  return acc;
-}, { isColorSupported: false });
+const defaultColors = /* @__PURE__ */ colorsEntries.reduce(
+  (acc, [key]) => {
+    acc[key] = string;
+    return acc;
+  },
+  { isColorSupported: false }
+);
 function getDefaultColors() {
   return { ...defaultColors };
 }

package/dist/chunk-display.js

@@ -45,39 +45,47 @@ const formatRegExp = /%[sdjifoOc%]/g;
 function format(...args) {
   if (typeof args[0] !== "string") {
     const objects = [];
-    for (let i2 = 0; i2 < args.length; i2++)
+    for (let i2 = 0; i2 < args.length; i2++) {
       objects.push(inspect(args[i2], { depth: 0, colors: false }));
+    }
     return objects.join(" ");
   }
   const len = args.length;
   let i = 1;
   const template = args[0];
   let str = String(template).replace(formatRegExp, (x) => {
-    if (x === "%%")
+    if (x === "%%") {
       return "%";
-    if (i >= len)
+    }
+    if (i >= len) {
       return x;
+    }
     switch (x) {
       case "%s": {
         const value = args[i++];
-        if (typeof value === "bigint")
+        if (typeof value === "bigint") {
           return `${value.toString()}n`;
-        if (typeof value === "number" && value === 0 && 1 / value < 0)
+        }
+        if (typeof value === "number" && value === 0 && 1 / value < 0) {
           return "-0";
-        if (typeof value === "object" && value !== null)
+        }
+        if (typeof value === "object" && value !== null) {
           return inspect(value, { depth: 0, colors: false });
+        }
         return String(value);
       }
       case "%d": {
         const value = args[i++];
-        if (typeof value === "bigint")
+        if (typeof value === "bigint") {
           return `${value.toString()}n`;
+        }
         return Number(value).toString();
       }
       case "%i": {
         const value = args[i++];
-        if (typeof value === "bigint")
+        if (typeof value === "bigint") {
           return `${value.toString()}n`;
+        }
         return Number.parseInt(String(value)).toString();
       }
       case "%f":
@@ -98,8 +106,9 @@ function format(...args) {
           if (
             // chromium
             m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")
-          )
+          ) {
             return "[Circular]";
+          }
           throw err;
         }
       default:
@@ -107,21 +116,24 @@ function format(...args) {
     }
   });
   for (let x = args[i]; i < len; x = args[++i]) {
-    if (x === null || typeof x !== "object")
+    if (x === null || typeof x !== "object") {
       str += ` ${x}`;
-    else
+    } else {
       str += ` ${inspect(x)}`;
+    }
   }
   return str;
 }
 function inspect(obj, options = {}) {
-  if (options.truncate === 0)
+  if (options.truncate === 0) {
     options.truncate = Number.POSITIVE_INFINITY;
+  }
   return loupe.inspect(obj, options);
 }
 function objDisplay(obj, options = {}) {
-  if (typeof options.truncate === "undefined")
+  if (typeof options.truncate === "undefined") {
     options.truncate = 40;
+  }
   const str = inspect(obj, options);
   const type = Object.prototype.toString.call(obj);
   if (options.truncate && str.length >= options.truncate) {

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++;
@@ -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.js

@@ -4,8 +4,11 @@ function notNullish(v) {
 function assertTypes(value, name, types) {
   const receivedType = typeof value;
   const pass = types.includes(receivedType);
-  if (!pass)
-    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+  if (!pass) {
+    throw new TypeError(
+      `${name} value must be ${types.join(" or ")}, received "${receivedType}"`
+    );
+  }
 }
 function isPrimitive(value) {
   return value === null || typeof value !== "function" && typeof value !== "object";
@@ -15,17 +18,21 @@ function slash(path) {
 }
 function parseRegexp(input) {
   const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
-  if (!m)
+  if (!m) {
     return /$^/;
-  if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]))
+  }
+  if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3])) {
     return RegExp(input);
+  }
   return new RegExp(m[2], m[3]);
 }
 function toArray(array) {
-  if (array === null || array === void 0)
+  if (array === null || array === void 0) {
     array = [];
-  if (Array.isArray(array))
+  }
+  if (Array.isArray(array)) {
     return array;
+  }
   return [array];
 }
 function isObject(item) {
@@ -44,8 +51,9 @@ function collectOwnProperties(obj, collector) {
 }
 function getOwnProperties(obj) {
   const ownProps = /* @__PURE__ */ new Set();
-  if (isFinalObj(obj))
+  if (isFinalObj(obj)) {
     return [];
+  }
   collectOwnProperties(obj, ownProps);
   return Array.from(ownProps);
 }
@@ -56,12 +64,15 @@ function deepClone(val, options = defaultCloneOptions) {
 }
 function clone(val, seen, options = defaultCloneOptions) {
   let k, out;
-  if (seen.has(val))
+  if (seen.has(val)) {
     return seen.get(val);
+  }
   if (Array.isArray(val)) {
     out = Array(k = val.length);
     seen.set(val, out);
-    while (k--) out[k] = clone(val[k], seen, options);
+    while (k--) {
+      out[k] = clone(val[k], seen, options);
+    }
     return out;
   }
   if (Object.prototype.toString.call(val) === "[object Object]") {
@@ -70,8 +81,9 @@ function clone(val, seen, options = defaultCloneOptions) {
     const props = getOwnProperties(val);
     for (const k2 of props) {
       const descriptor = Object.getOwnPropertyDescriptor(val, k2);
-      if (!descriptor)
+      if (!descriptor) {
         continue;
+      }
       const cloned = clone(val[k2], seen, options);
       if (options.forceWritable) {
         Object.defineProperty(out, k2, {
@@ -105,8 +117,9 @@ function objectAttr(source, path, defaultValue = void 0) {
   let result = source;
   for (const p of paths) {
     result = Object(result)[p];
-    if (result === void 0)
+    if (result === void 0) {
       return defaultValue;
+    }
   }
   return result;
 }
@@ -133,25 +146,30 @@ function getCallLastIndex(code) {
     const char = code[charIndex];
     const isCharString = char === '"' || char === "'" || char === "`";
     if (isCharString && beforeChar !== "\\") {
-      if (inString === char)
+      if (inString === char) {
         inString = null;
-      else if (!inString)
+      } else if (!inString) {
         inString = char;
+      }
     }
     if (!inString) {
-      if (char === "(")
+      if (char === "(") {
         startedBracers++;
-      if (char === ")")
+      }
+      if (char === ")") {
         endedBracers++;
+      }
     }
-    if (startedBracers && endedBracers && startedBracers === endedBracers)
+    if (startedBracers && endedBracers && startedBracers === endedBracers) {
       return charIndex;
+    }
   }
   return null;
 }
 function isNegativeNaN(val) {
-  if (!Number.isNaN(val))
+  if (!Number.isNaN(val)) {
     return false;
+  }
   const f64 = new Float64Array(1);
   f64[0] = val;
   const u32 = new Uint32Array(f64.buffer);

package/dist/index.js

@@ -14,9 +14,7 @@ function getSafeTimers() {
     setImmediate: safeSetImmediate,
     clearImmediate: safeClearImmediate
   } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
-  const {
-    nextTick: safeNextTick
-  } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || { nextTick: (cb) => cb() };
+  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || { nextTick: (cb) => cb() };
   return {
     nextTick: safeNextTick,
     setTimeout: safeSetTimeout,
@@ -36,9 +34,9 @@ function setSafeTimers() {
     setImmediate: safeSetImmediate,
     clearImmediate: safeClearImmediate
   } = globalThis;
-  const {
-    nextTick: safeNextTick
-  } = globalThis.process || { nextTick: (cb) => cb() };
+  const { nextTick: safeNextTick } = globalThis.process || {
+    nextTick: (cb) => cb()
+  };
   const timers = {
     nextTick: safeNextTick,
     setTimeout: safeSetTimeout,
@@ -86,10 +84,12 @@ function positionToOffset(source, lineNumber, columnNumber) {
   const lines = source.split(lineSplitRE);
   const nl = /\r\n/.test(source) ? 2 : 1;
   let start = 0;
-  if (lineNumber > lines.length)
+  if (lineNumber > lines.length) {
     return source.length;
-  for (let i = 0; i < lineNumber - 1; i++)
+  }
+  for (let i = 0; i < lineNumber - 1; i++) {
     start += lines[i].length + nl;
+  }
   return start + columnNumber;
 }
 function offsetToLineNumber(source, offset) {
@@ -104,8 +104,9 @@ function offsetToLineNumber(source, offset) {
   let line = 0;
   for (; line < lines.length; line++) {
     const lineLength = lines[line].length + nl;
-    if (counted + lineLength >= offset)
+    if (counted + lineLength >= offset) {
       break;
+    }
     counted += lineLength;
   }
   return line + 1;

package/dist/source-map.d.ts

@@ -104,6 +104,7 @@ declare function generatedPositionFor(map: TraceMap, needle: SourceNeedle): Gene
 interface StackTraceParserOptions {
     ignoreStackEntries?: (RegExp | string)[];
     getSourceMap?: (file: string) => unknown;
+    getFileName?: (id: string) => string;
     frameFilter?: (error: Error, frame: ParsedStack) => boolean | void;
 }
 declare function parseSingleFFOrSafariStack(raw: string): ParsedStack | null;

package/dist/source-map.js

@@ -774,21 +774,28 @@ const stackIgnorePatterns = [
   "/node_modules/tinypool/",
   "/node_modules/tinyspy/",
   // browser related deps
-  "/deps/chai.js",
-  "/deps/vitest___chai.js",
-  "/deps/p-limit.js",
+  "/deps/chunk-",
+  "/deps/@vitest",
+  "/deps/loupe",
+  "/deps/chai",
   /node:\w+/,
   /__vitest_test__/,
-  /__vitest_browser__/
+  /__vitest_browser__/,
+  /\/deps\/vitest_/
 ];
 function extractLocation(urlLike) {
-  if (!urlLike.includes(":"))
+  if (!urlLike.includes(":")) {
     return [urlLike];
+  }
   const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
   const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
-  if (!parts)
+  if (!parts) {
     return [urlLike];
+  }
   let url = parts[1];
+  if (url.startsWith("async ")) {
+    url = url.slice(6);
+  }
   if (url.startsWith("http:") || url.startsWith("https:")) {
     const urlObj = new URL(url);
     url = urlObj.pathname;
@@ -801,18 +808,27 @@ function extractLocation(urlLike) {
 }
 function parseSingleFFOrSafariStack(raw) {
   let line = raw.trim();
-  if (SAFARI_NATIVE_CODE_REGEXP.test(line))
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
     return null;
-  if (line.includes(" > eval"))
-    line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
-  if (!line.includes("@") && !line.includes(":"))
+  }
+  if (line.includes(" > eval")) {
+    line = line.replace(
+      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+      ":$1"
+    );
+  }
+  if (!line.includes("@") && !line.includes(":")) {
     return null;
+  }
   const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
   const matches = line.match(functionNameRegex);
   const functionName = matches && matches[1] ? matches[1] : void 0;
-  const [url, lineNumber, columnNumber] = extractLocation(line.replace(functionNameRegex, ""));
-  if (!url || !lineNumber || !columnNumber)
+  const [url, lineNumber, columnNumber] = extractLocation(
+    line.replace(functionNameRegex, "")
+  );
+  if (!url || !lineNumber || !columnNumber) {
     return null;
+  }
   return {
     file: url,
     method: functionName || "",
@@ -822,31 +838,40 @@ function parseSingleFFOrSafariStack(raw) {
 }
 function parseSingleStack(raw) {
   const line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line))
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
     return parseSingleFFOrSafariStack(line);
+  }
   return parseSingleV8Stack(line);
 }
 function parseSingleV8Stack(raw) {
   let line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line))
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
     return null;
-  if (line.includes("(eval "))
+  }
+  if (line.includes("(eval ")) {
     line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
   let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
   const location = sanitizedLine.match(/ (\(.+\)$)/);
   sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+  const [url, lineNumber, columnNumber] = extractLocation(
+    location ? location[1] : sanitizedLine
+  );
   let method = location && sanitizedLine || "";
   let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
-  if (!file || !lineNumber || !columnNumber)
+  if (!file || !lineNumber || !columnNumber) {
     return null;
-  if (method.startsWith("async "))
+  }
+  if (method.startsWith("async ")) {
     method = method.slice(6);
-  if (file.startsWith("file://"))
+  }
+  if (file.startsWith("file://")) {
     file = file.slice(7);
+  }
   file = resolve$2(file);
-  if (method)
+  if (method) {
     method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  }
   return {
     method,
     file,
@@ -857,17 +882,25 @@ function parseSingleV8Stack(raw) {
 function parseStacktrace(stack, options = {}) {
   const { ignoreStackEntries = stackIgnorePatterns } = options;
   let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
-  if (ignoreStackEntries.length)
-    stacks = stacks.filter((stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p)));
+  if (ignoreStackEntries.length) {
+    stacks = stacks.filter(
+      (stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p))
+    );
+  }
   return stacks.map((stack2) => {
     var _a;
+    if (options.getFileName) {
+      stack2.file = options.getFileName(stack2.file);
+    }
     const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
-    if (!map || typeof map !== "object" || !map.version)
+    if (!map || typeof map !== "object" || !map.version) {
       return stack2;
+    }
     const traceMap = new TraceMap(map);
     const { line, column } = originalPositionFor(traceMap, stack2);
-    if (line != null && column != null)
+    if (line != null && column != null) {
       return { ...stack2, line, column };
+    }
     return stack2;
   });
 }
@@ -878,14 +911,19 @@ function parseV8Stacktrace(stack) {
   return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
 }
 function parseErrorStacktrace(e, options = {}) {
-  if (!e || isPrimitive(e))
+  if (!e || isPrimitive(e)) {
     return [];
-  if (e.stacks)
+  }
+  if (e.stacks) {
     return e.stacks;
+  }
   const stackStr = e.stack || e.stackStr || "";
   let stackFrames = parseStacktrace(stackStr, options);
-  if (options.frameFilter)
-    stackFrames = stackFrames.filter((f) => options.frameFilter(e, f) !== false);
+  if (options.frameFilter) {
+    stackFrames = stackFrames.filter(
+      (f) => options.frameFilter(e, f) !== false
+    );
+  }
   e.stacks = stackFrames;
   return stackFrames;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -47,6 +47,9 @@
   "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
+      "ast": [
+        "dist/ast.d.ts"
+      ],
       "source-map": [
         "dist/source-map.d.ts"
       ]