@vitest/utils 2.1.2 → 2.1.4

package/dist/chunk-_commonjsHelpers.js

@@ -1,5 +1,5 @@
-import * as loupe from 'loupe';
 import { format as format$1, plugins } from '@vitest/pretty-format';
+import * as loupe from 'loupe';
 
 const {
   AsymmetricMatcher,

package/dist/diff.js

@@ -4,42 +4,6 @@ import { g as getDefaultExportFromCjs, s as stringify } from './chunk-_commonjsH
 import { deepClone, getOwnProperties, getType as getType$1 } from './helpers.js';
 import 'loupe';
 
-function getType(value) {
-  if (value === void 0) {
-    return "undefined";
-  } else if (value === null) {
-    return "null";
-  } else if (Array.isArray(value)) {
-    return "array";
-  } else if (typeof value === "boolean") {
-    return "boolean";
-  } else if (typeof value === "function") {
-    return "function";
-  } else if (typeof value === "number") {
-    return "number";
-  } else if (typeof value === "string") {
-    return "string";
-  } else if (typeof value === "bigint") {
-    return "bigint";
-  } else if (typeof value === "object") {
-    if (value != null) {
-      if (value.constructor === RegExp) {
-        return "regexp";
-      } else if (value.constructor === Map) {
-        return "map";
-      } else if (value.constructor === Set) {
-        return "set";
-      } else if (value.constructor === Date) {
-        return "date";
-      }
-    }
-    return "object";
-  } else if (typeof value === "symbol") {
-    return "symbol";
-  }
-  throw new Error(`value of unknown type: ${value}`);
-}
-
 const DIFF_DELETE = -1;
 const DIFF_INSERT = 1;
 const DIFF_EQUAL = 0;
@@ -1599,6 +1563,42 @@ function diffLinesRaw(aLines, bLines, options) {
   return [diffs, truncated];
 }
 
+function getType(value) {
+  if (value === void 0) {
+    return "undefined";
+  } else if (value === null) {
+    return "null";
+  } else if (Array.isArray(value)) {
+    return "array";
+  } else if (typeof value === "boolean") {
+    return "boolean";
+  } else if (typeof value === "function") {
+    return "function";
+  } else if (typeof value === "number") {
+    return "number";
+  } else if (typeof value === "string") {
+    return "string";
+  } else if (typeof value === "bigint") {
+    return "bigint";
+  } else if (typeof value === "object") {
+    if (value != null) {
+      if (value.constructor === RegExp) {
+        return "regexp";
+      } else if (value.constructor === Map) {
+        return "map";
+      } else if (value.constructor === Set) {
+        return "set";
+      } else if (value.constructor === Date) {
+        return "date";
+      }
+    }
+    return "object";
+  } else if (typeof value === "symbol") {
+    return "symbol";
+  }
+  throw new Error(`value of unknown type: ${value}`);
+}
+
 function getNewLineSymbol(string) {
   return string.includes("\r\n") ? "\r\n" : "\n";
 }

package/dist/helpers.d.ts

@@ -42,5 +42,13 @@ declare function createDefer<T>(): DeferPromise<T>;
  */
 declare function getCallLastIndex(code: string): number | null;
 declare function isNegativeNaN(val: number): boolean;
+/**
+ * Deep merge :P
+ *
+ * Will merge objects only if they are plain
+ *
+ * Do not merge types - it is very expensive and usually it's better to case a type here
+ */
+declare function deepMerge<T extends object = object>(target: T, ...sources: any[]): T;
 
-export { type DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };
+export { type DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };

package/dist/helpers.js

@@ -188,5 +188,37 @@ function isNegativeNaN(val) {
   const isNegative = u32[1] >>> 31 === 1;
   return isNegative;
 }
+function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+  return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function isMergeableObject(item) {
+  return isPlainObject(item) && !Array.isArray(item);
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) {
+    return target;
+  }
+  const source = sources.shift();
+  if (source === void 0) {
+    return target;
+  }
+  if (isMergeableObject(target) && isMergeableObject(source)) {
+    Object.keys(source).forEach((key) => {
+      const _source = source;
+      if (isMergeableObject(_source[key])) {
+        if (!target[key]) {
+          target[key] = {};
+        }
+        deepMerge(target[key], _source[key]);
+      } else {
+        target[key] = _source[key];
+      }
+    });
+  }
+  return deepMerge(target, ...sources);
+}
 
-export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };
+export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray };

package/dist/index.d.ts

@@ -1,22 +1,8 @@
-export { DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
+export { DeferPromise, assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
 import { Colors } from 'tinyrainbow';
 export { ArgumentsType, Arrayable, Awaitable, Constructable, DeepMerge, ErrorWithDiff, MergeInsertions, MutableArray, Nullable, ParsedStack, SerializedError, TestError } from './types.js';
 
-interface SafeTimers {
-    nextTick: (cb: () => void) => void;
-    setTimeout: typeof setTimeout;
-    setInterval: typeof setInterval;
-    clearInterval: typeof clearInterval;
-    clearTimeout: typeof clearTimeout;
-    setImmediate: typeof setImmediate;
-    clearImmediate: typeof clearImmediate;
-}
-declare function getSafeTimers(): SafeTimers;
-declare function setSafeTimers(): void;
-
-declare function shuffle<T>(array: T[], seed?: number): T[];
-
 type Inspect = (value: unknown, options: Options) => string;
 interface Options {
     showHidden: boolean;
@@ -40,10 +26,6 @@ declare function format(...args: unknown[]): string;
 declare function inspect(obj: unknown, options?: LoupeOptions): string;
 declare function objDisplay(obj: unknown, options?: LoupeOptions): string;
 
-declare const lineSplitRE: RegExp;
-declare function positionToOffset(source: string, lineNumber: number, columnNumber: number): number;
-declare function offsetToLineNumber(source: string, offset: number): number;
-
 interface HighlightOptions {
     jsx?: boolean;
     colors?: Colors;
@@ -52,4 +34,22 @@ declare function highlight(code: string, options?: HighlightOptions): string;
 
 declare function nanoid(size?: number): string;
 
+declare const lineSplitRE: RegExp;
+declare function positionToOffset(source: string, lineNumber: number, columnNumber: number): number;
+declare function offsetToLineNumber(source: string, offset: number): number;
+
+declare function shuffle<T>(array: T[], seed?: number): T[];
+
+interface SafeTimers {
+    nextTick: (cb: () => void) => void;
+    setTimeout: typeof setTimeout;
+    setInterval: typeof setInterval;
+    clearInterval: typeof clearInterval;
+    clearTimeout: typeof clearTimeout;
+    setImmediate: typeof setImmediate;
+    clearImmediate: typeof clearImmediate;
+}
+declare function getSafeTimers(): SafeTimers;
+declare function setSafeTimers(): void;
+
 export { type SafeTimers, type StringifyOptions, format, getSafeTimers, highlight, inspect, lineSplitRE, nanoid, objDisplay, offsetToLineNumber, positionToOffset, setSafeTimers, shuffle, stringify };

package/dist/index.js

@@ -1,104 +1,9 @@
-export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
 import { g as getDefaultExportFromCjs } from './chunk-_commonjsHelpers.js';
 export { f as format, i as inspect, o as objDisplay, s as stringify } from './chunk-_commonjsHelpers.js';
+export { assertTypes, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isNegativeNaN, isObject, isPrimitive, noop, notNullish, objectAttr, parseRegexp, slash, toArray } from './helpers.js';
 import c from 'tinyrainbow';
-import 'loupe';
 import '@vitest/pretty-format';
-
-const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
-function getSafeTimers() {
-  const {
-    setTimeout: safeSetTimeout,
-    setInterval: safeSetInterval,
-    clearInterval: safeClearInterval,
-    clearTimeout: safeClearTimeout,
-    setImmediate: safeSetImmediate,
-    clearImmediate: safeClearImmediate
-  } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
-  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || { nextTick: (cb) => cb() };
-  return {
-    nextTick: safeNextTick,
-    setTimeout: safeSetTimeout,
-    setInterval: safeSetInterval,
-    clearInterval: safeClearInterval,
-    clearTimeout: safeClearTimeout,
-    setImmediate: safeSetImmediate,
-    clearImmediate: safeClearImmediate
-  };
-}
-function setSafeTimers() {
-  const {
-    setTimeout: safeSetTimeout,
-    setInterval: safeSetInterval,
-    clearInterval: safeClearInterval,
-    clearTimeout: safeClearTimeout,
-    setImmediate: safeSetImmediate,
-    clearImmediate: safeClearImmediate
-  } = globalThis;
-  const { nextTick: safeNextTick } = globalThis.process || {
-    nextTick: (cb) => cb()
-  };
-  const timers = {
-    nextTick: safeNextTick,
-    setTimeout: safeSetTimeout,
-    setInterval: safeSetInterval,
-    clearInterval: safeClearInterval,
-    clearTimeout: safeClearTimeout,
-    setImmediate: safeSetImmediate,
-    clearImmediate: safeClearImmediate
-  };
-  globalThis[SAFE_TIMERS_SYMBOL] = timers;
-}
-
-const RealDate = Date;
-function random(seed) {
-  const x = Math.sin(seed++) * 1e4;
-  return x - Math.floor(x);
-}
-function shuffle(array, seed = RealDate.now()) {
-  let length = array.length;
-  while (length) {
-    const index = Math.floor(random(seed) * length--);
-    const previous = array[length];
-    array[length] = array[index];
-    array[index] = previous;
-    ++seed;
-  }
-  return array;
-}
-
-const lineSplitRE = /\r?\n/;
-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) {
-    return source.length;
-  }
-  for (let i = 0; i < lineNumber - 1; i++) {
-    start += lines[i].length + nl;
-  }
-  return start + columnNumber;
-}
-function offsetToLineNumber(source, offset) {
-  if (offset > source.length) {
-    throw new Error(
-      `offset is longer than source length! offset ${offset} > length ${source.length}`
-    );
-  }
-  const lines = source.split(lineSplitRE);
-  const nl = /\r\n/.test(source) ? 2 : 1;
-  let counted = 0;
-  let line = 0;
-  for (; line < lines.length; line++) {
-    const lineLength = lines[line].length + nl;
-    if (counted + lineLength >= offset) {
-      break;
-    }
-    counted += lineLength;
-  }
-  return line + 1;
-}
+import 'loupe';
 
 var jsTokens_1;
 var hasRequiredJsTokens;
@@ -644,4 +549,99 @@ function nanoid(size = 21) {
   return id;
 }
 
+const lineSplitRE = /\r?\n/;
+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) {
+    return source.length;
+  }
+  for (let i = 0; i < lineNumber - 1; i++) {
+    start += lines[i].length + nl;
+  }
+  return start + columnNumber;
+}
+function offsetToLineNumber(source, offset) {
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(lineSplitRE);
+  const nl = /\r\n/.test(source) ? 2 : 1;
+  let counted = 0;
+  let line = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + nl;
+    if (counted + lineLength >= offset) {
+      break;
+    }
+    counted += lineLength;
+  }
+  return line + 1;
+}
+
+const RealDate = Date;
+function random(seed) {
+  const x = Math.sin(seed++) * 1e4;
+  return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+  let length = array.length;
+  while (length) {
+    const index = Math.floor(random(seed) * length--);
+    const previous = array[length];
+    array[length] = array[index];
+    array[index] = previous;
+    ++seed;
+  }
+  return array;
+}
+
+const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+  const {
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || { nextTick: (cb) => cb() };
+  return {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  };
+}
+function setSafeTimers() {
+  const {
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  } = globalThis;
+  const { nextTick: safeNextTick } = globalThis.process || {
+    nextTick: (cb) => cb()
+  };
+  const timers = {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  };
+  globalThis[SAFE_TIMERS_SYMBOL] = timers;
+}
+
 export { getSafeTimers, highlight, lineSplitRE, nanoid, offsetToLineNumber, positionToOffset, setSafeTimers, shuffle };

package/dist/source-map.js

@@ -1,100 +1,5 @@
 import { notNullish, isPrimitive } from './helpers.js';
 
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-const resolve$2 = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-
 const comma = ','.charCodeAt(0);
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 const intToChar = new Uint8Array(64); // 64 possible chars.
@@ -377,7 +282,7 @@ function normalizePath(url, type) {
 /**
  * Attempts to resolve `input` URL/path relative to `base`.
  */
-function resolve$1(input, base) {
+function resolve$2(input, base) {
     if (!input && !base)
         return '';
     const url = parseUrl(input);
@@ -437,13 +342,13 @@ function resolve$1(input, base) {
     }
 }
 
-function resolve(input, base) {
+function resolve$1(input, base) {
     // The base is always treated as a directory, if it's not empty.
     // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
     // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
     if (base && !base.endsWith('/'))
         base += '/';
-    return resolve$1(input, base);
+    return resolve$2(input, base);
 }
 
 /**
@@ -643,8 +548,8 @@ class TraceMap {
         this.sources = sources;
         this.sourcesContent = sourcesContent;
         this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
+        const from = resolve$1(sourceRoot || '', stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve$1(s || '', from));
         const { mappings } = parsed;
         if (typeof mappings === 'string') {
             this._encoded = mappings;
@@ -778,6 +683,101 @@ function generatedPosition(map, source, line, column, bias, all) {
     return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
 }
 
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+
 const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
 const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
 const stackIgnorePatterns = [
@@ -886,7 +886,7 @@ function parseSingleV8Stack(raw) {
   if (file.startsWith("file://")) {
     file = file.slice(7);
   }
-  file = resolve$2(file);
+  file = resolve(file);
   if (method) {
     method = method.replace(/__vite_ssr_import_\d+__\./g, "");
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/utils",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "Shared Vitest utility functions",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -60,13 +60,13 @@
     "dist"
   ],
   "dependencies": {
-    "loupe": "^3.1.1",
+    "loupe": "^3.1.2",
     "tinyrainbow": "^1.2.0",
-    "@vitest/pretty-format": "2.1.2"
+    "@vitest/pretty-format": "2.1.4"
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",
-    "@types/estree": "^1.0.5",
+    "@types/estree": "^1.0.6",
     "diff-sequences": "^29.6.3",
     "tinyhighlight": "^0.3.2"
   },