@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/@vitest/spy/index.d.ts

@@ -31,7 +31,7 @@ interface MockSettledResultRejected {
 type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
 type MockSettledResult<T> = MockSettledResultFulfilled<T> | MockSettledResultRejected | MockSettledResultIncomplete;
 type MockParameters<T extends Procedure | Constructable> = T extends Constructable ? ConstructorParameters<T> : T extends Procedure ? Parameters<T> : never;
-type MockReturnType<T extends Procedure | Constructable> = T extends Constructable ? void : T extends Procedure ? ReturnType<T> : never;
+type MockReturnType<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : T extends Procedure ? ReturnType<T> : never;
 type MockProcedureContext<T extends Procedure | Constructable> = T extends Constructable ? InstanceType<T> : ThisParameterType<T>;
 interface MockContext<T extends Procedure | Constructable = Procedure> {
 	/**
@@ -173,7 +173,7 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
 	/**
 	* Clears all information about every call. After calling it, all properties on `.mock` will return to their initial state. This method does not reset implementations. It is useful for cleaning up mocks between different assertions.
 	*
-	* To automatically call this method before each test, enable the [`clearMocks`](https://vitest.dev/config/#clearmocks) setting in the configuration.
+	* To automatically call this method before each test, enable the [`clearMocks`](https://vitest.dev/config/clearmocks) setting in the configuration.
 	* @see https://vitest.dev/api/mock#mockclear
 	*/
 	mockClear(): this;
@@ -183,7 +183,7 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
 	* Note that resetting a mock from `vi.fn()` will set implementation to an empty function that returns `undefined`.
 	* Resetting a mock from `vi.fn(impl)` will set implementation to `impl`. It is useful for completely resetting a mock to its default state.
 	*
-	* To automatically call this method before each test, enable the [`mockReset`](https://vitest.dev/config/#mockreset) setting in the configuration.
+	* To automatically call this method before each test, enable the [`mockReset`](https://vitest.dev/config/mockreset) setting in the configuration.
 	* @see https://vitest.dev/api/mock#mockreset
 	*/
 	mockReset(): this;
@@ -267,6 +267,28 @@ interface MockInstance<T extends Procedure | Constructable = Procedure> extends
 	*/
 	mockReturnValueOnce(value: MockReturnType<T>): this;
 	/**
+	* Accepts a value that will be thrown whenever the mock function is called.
+	* @see https://vitest.dev/api/mock#mockthrow
+	* @example
+	* const myMockFn = vi.fn().mockThrow(new Error('error'))
+	* myMockFn() // throws 'error'
+	*/
+	mockThrow(value: unknown): this;
+	/**
+	* Accepts a value that will be thrown during the next function call. If chained, every consecutive call will throw the specified value.
+	* @example
+	* const myMockFn = vi
+	*   .fn()
+	*   .mockReturnValue('default')
+	*   .mockThrowOnce(new Error('first call error'))
+	*   .mockThrowOnce('second call error')
+	*
+	* expect(() => myMockFn()).toThrowError('first call error')
+	* expect(() => myMockFn()).toThrowError('second call error')
+	* expect(myMockFn()).toEqual('default')
+	*/
+	mockThrowOnce(value: unknown): this;
+	/**
 	* Accepts a value that will be resolved when the async function is called. TypeScript will only accept values that match the return type of the original function.
 	* @example
 	* const asyncMock = vi.fn().mockResolvedValue(42)
@@ -322,11 +344,19 @@ type PartialResultFunction<T> = T extends Constructable ? ({
 	(this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
 }) : T extends Procedure ? (...args: Parameters<T>) => PartialMaybePromise<ReturnType<T>> : T;
 type PartialMock<T extends Procedure | Constructable = Procedure> = Mock<PartialResultFunction<T extends Mock ? NonNullable<ReturnType<T["getMockImplementation"]>> : T>>;
+type DeepPartial<T> = T extends Procedure ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]? : DeepPartial<T[K]> } : T;
+type DeepPartialMaybePromise<T> = T extends Promise<Awaited<T>> ? Promise<DeepPartial<Awaited<T>>> : DeepPartial<T>;
+type DeepPartialResultFunction<T> = T extends Constructable ? ({
+	new (...args: ConstructorParameters<T>): InstanceType<T>;
+}) | ({
+	(this: InstanceType<T>, ...args: ConstructorParameters<T>): void;
+}) : T extends Procedure ? (...args: Parameters<T>) => DeepPartialMaybePromise<ReturnType<T>> : T;
+type DeepPartialMock<T extends Procedure | Constructable = Procedure> = Mock<DeepPartialResultFunction<T extends Mock ? NonNullable<ReturnType<T["getMockImplementation"]>> : T>>;
 type MaybeMockedConstructor<T> = T extends Constructable ? Mock<T> : T;
 type MockedFunction<T extends Procedure | Constructable> = Mock<T> & { [K in keyof T] : T[K] };
 type PartiallyMockedFunction<T extends Procedure | Constructable> = PartialMock<T> & { [K in keyof T] : T[K] };
 type MockedFunctionDeep<T extends Procedure | Constructable> = Mock<T> & MockedObjectDeep<T>;
-type PartiallyMockedFunctionDeep<T extends Procedure | Constructable> = PartialMock<T> & MockedObjectDeep<T>;
+type PartiallyMockedFunctionDeep<T extends Procedure | Constructable> = DeepPartialMock<T> & MockedObjectDeep<T>;
 type MockedObject<T> = MaybeMockedConstructor<T> & { [K in Methods<T>] : T[K] extends Procedure ? MockedFunction<T[K]> : T[K] } & { [K in Properties<T>] : T[K] };
 type MockedObjectDeep<T> = MaybeMockedConstructor<T> & { [K in Methods<T>] : T[K] extends Procedure ? MockedFunctionDeep<T[K]> : T[K] } & { [K in Properties<T>] : MaybeMockedDeep<T[K]> };
 type MaybeMockedDeep<T> = T extends Procedure | Constructable ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;

package/dist/@vitest/spy/index.js

@@ -8,7 +8,6 @@ const MOCK_RESTORE = new Set();
 const REGISTERED_MOCKS = new Set();
 const MOCK_CONFIGS = new WeakMap();
 function createMockInstance(options = {}) {
-  var _ref;
   const { originalImplementation, restore, mockImplementation, resetToMockImplementation, resetToMockName } = options;
   if (restore) {
     MOCK_RESTORE.add(restore);
@@ -20,7 +19,7 @@ function createMockInstance(options = {}) {
     state,
     ...options
   });
-  const mockLength = ((_ref = mockImplementation || originalImplementation) === null || _ref === void 0 ? void 0 : _ref.length) ?? 0;
+  const mockLength = (mockImplementation || originalImplementation)?.length ?? 0;
   Object.defineProperty(mock, "length", {
     writable: true,
     enumerable: false,
@@ -65,7 +64,7 @@ function createMockInstance(options = {}) {
     config.mockImplementation = implementation;
     config.onceMockImplementations = [];
     const returnValue = callback();
-    if (typeof returnValue === "object" && typeof (returnValue === null || returnValue === void 0 ? void 0 : returnValue.then) === "function") {
+    if (typeof returnValue === "object" && typeof returnValue?.then === "function") {
       return returnValue.then(() => {
         reset();
         return mock;
@@ -81,22 +80,64 @@ function createMockInstance(options = {}) {
     });
   };
   mock.mockReturnValue = function mockReturnValue(value) {
-    return mock.mockImplementation(() => value);
+    return mock.mockImplementation(function() {
+      if (new.target) {
+        throwConstructorError("mockReturnValue");
+      }
+      return value;
+    });
   };
   mock.mockReturnValueOnce = function mockReturnValueOnce(value) {
-    return mock.mockImplementationOnce(() => value);
+    return mock.mockImplementationOnce(function() {
+      if (new.target) {
+        throwConstructorError("mockReturnValueOnce");
+      }
+      return value;
+    });
+  };
+  mock.mockThrow = function mockThrow(value) {
+    // eslint-disable-next-line prefer-arrow-callback
+    return mock.mockImplementation(function() {
+      throw value;
+    });
+  };
+  mock.mockThrowOnce = function mockThrowOnce(value) {
+    // eslint-disable-next-line prefer-arrow-callback
+    return mock.mockImplementationOnce(function() {
+      throw value;
+    });
   };
   mock.mockResolvedValue = function mockResolvedValue(value) {
-    return mock.mockImplementation(() => Promise.resolve(value));
+    return mock.mockImplementation(function() {
+      if (new.target) {
+        throwConstructorError("mockResolvedValue");
+      }
+      return Promise.resolve(value);
+    });
   };
   mock.mockResolvedValueOnce = function mockResolvedValueOnce(value) {
-    return mock.mockImplementationOnce(() => Promise.resolve(value));
+    return mock.mockImplementationOnce(function() {
+      if (new.target) {
+        throwConstructorError("mockResolvedValueOnce");
+      }
+      return Promise.resolve(value);
+    });
   };
   mock.mockRejectedValue = function mockRejectedValue(value) {
-    return mock.mockImplementation(() => Promise.reject(value));
+    return mock.mockImplementation(function() {
+      if (new.target) {
+        throwConstructorError("mockRejectedValue");
+      }
+      return Promise.reject(value);
+    });
   };
   mock.mockRejectedValueOnce = function mockRejectedValueOnce(value) {
-    return mock.mockImplementationOnce(() => Promise.reject(value));
+    return mock.mockImplementationOnce(function() {
+      if (new.target) {
+        throwConstructorError("mockRejectedValueOnce");
+      }
+      return Promise.reject(value);
+    });
   };
   mock.mockClear = function mockClear() {
     state.calls = [];
@@ -116,7 +157,7 @@ function createMockInstance(options = {}) {
   };
   mock.mockRestore = function mockRestore() {
     mock.mockReset();
-    return restore === null || restore === void 0 ? void 0 : restore();
+    return restore?.();
   };
   mock.mockName = function mockName(name) {
     if (typeof name === "string") {
@@ -161,6 +202,12 @@ function spyOn(object, key, accessor) {
   let original;
   if (originalDescriptor) {
     original = originalDescriptor[accessType];
+    // weird Proxy edge case where descriptor's value is undefined,
+    // but there's still a value on the object when called
+    // https://github.com/vitest-dev/vitest/issues/9439
+    if (original == null && accessType === "value") {
+      original = object[key];
+    }
   } else if (accessType !== "value") {
     original = () => object[key];
   } else {
@@ -236,7 +283,7 @@ let invocationCallCounter = 1;
 function createMock({ state, config, name: mockName, prototypeState, prototypeConfig, keepMembersImplementation, mockImplementation, prototypeMembers = [] }) {
   const original = config.mockOriginal;
   const pseudoOriginal = mockImplementation;
-  const name = mockName || (original === null || original === void 0 ? void 0 : original.name) || "Mock";
+  const name = mockName || original?.name || "Mock";
   const namedObject = { [name]: (function(...args) {
     registerCalls(args, state, prototypeState);
     registerInvocationOrder(invocationCallCounter++, state, prototypeState);
@@ -253,7 +300,7 @@ function createMock({ state, config, name: mockName, prototypeState, prototypeCo
     const context = new.target ? undefined : this;
     const [instanceIndex, instancePrototypeIndex] = registerInstance(context, state, prototypeState);
     const [contextIndex, contextPrototypeIndex] = registerContext(context, state, prototypeState);
-    const implementation = config.onceMockImplementations.shift() || config.mockImplementation || (prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.onceMockImplementations.shift()) || (prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.mockImplementation) || original || function() {};
+    const implementation = config.onceMockImplementations.shift() || config.mockImplementation || prototypeConfig?.onceMockImplementations.shift() || prototypeConfig?.mockImplementation || original || function() {};
     let returnValue;
     let thrownValue;
     let didThrow = false;
@@ -275,7 +322,7 @@ function createMock({ state, config, name: mockName, prototypeState, prototypeCo
           const prototypeState = isMock ? prototypeMock.mock : undefined;
           const prototypeConfig = isMock ? MOCK_CONFIGS.get(prototypeMock) : undefined;
           returnValue[prop] = createMockInstance({
-            originalImplementation: keepMembersImplementation ? prototypeConfig === null || prototypeConfig === void 0 ? void 0 : prototypeConfig.mockOriginal : undefined,
+            originalImplementation: keepMembersImplementation ? prototypeConfig?.mockOriginal : undefined,
             prototypeState,
             prototypeConfig,
             keepMembersImplementation
@@ -335,28 +382,28 @@ function createMock({ state, config, name: mockName, prototypeState, prototypeCo
 }
 function registerCalls(args, state, prototypeState) {
   state.calls.push(args);
-  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.calls.push(args);
+  prototypeState?.calls.push(args);
 }
 function registerInvocationOrder(order, state, prototypeState) {
   state.invocationCallOrder.push(order);
-  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.invocationCallOrder.push(order);
+  prototypeState?.invocationCallOrder.push(order);
 }
 function registerResult(result, state, prototypeState) {
   state.results.push(result);
-  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.results.push(result);
+  prototypeState?.results.push(result);
 }
 function registerSettledResult(result, state, prototypeState) {
   state.settledResults.push(result);
-  prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.settledResults.push(result);
+  prototypeState?.settledResults.push(result);
 }
 function registerInstance(instance, state, prototypeState) {
   const instanceIndex = state.instances.push(instance);
-  const instancePrototypeIndex = prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.instances.push(instance);
+  const instancePrototypeIndex = prototypeState?.instances.push(instance);
   return [instanceIndex, instancePrototypeIndex];
 }
 function registerContext(context, state, prototypeState) {
   const contextIndex = state.contexts.push(context);
-  const contextPrototypeIndex = prototypeState === null || prototypeState === void 0 ? void 0 : prototypeState.contexts.push(context);
+  const contextPrototypeIndex = prototypeState?.contexts.push(context);
   return [contextIndex, contextPrototypeIndex];
 }
 function copyOriginalStaticProperties(mock, original) {
@@ -429,5 +476,8 @@ function clearAllMocks() {
 function resetAllMocks() {
   REGISTERED_MOCKS.forEach((mock) => mock.mockReset());
 }
+function throwConstructorError(shorthand) {
+  throw new TypeError(`Cannot use \`${shorthand}\` when called with \`new\`. Use \`mockImplementation\` with a \`class\` keyword instead. See https://vitest.dev/api/mock#class-support for more information.`);
+}
 
 export { clearAllMocks, createMockInstance, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn };

package/dist/@vitest/utils/diff.js

@@ -2,7 +2,6 @@ import { plugins, format } from '../pretty-format/index.js';
 import c from '../../vendor/tinyrainbow.mjs';
 import { stringify } from './display.js';
 import { deepClone, getOwnProperties, getType as getType$1 } from './helpers.js';
-import { g as getDefaultExportFromCjs } from './chunk-_commonjsHelpers.js';
 import './constants.js';
 
 /**
@@ -333,7 +332,6 @@ function diff_cleanupSemanticLossless(diffs) {
 * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
 */
 function diff_cleanupMerge(diffs) {
-  var _diffs$at;
   // Add a dummy entry at the end.
   diffs.push(new Diff(DIFF_EQUAL, ""));
   let pointer = 0;
@@ -404,7 +402,7 @@ function diff_cleanupMerge(diffs) {
         break;
     }
   }
-  if (((_diffs$at = diffs.at(-1)) === null || _diffs$at === void 0 ? void 0 : _diffs$at[1]) === "") {
+  if (diffs.at(-1)?.[1] === "") {
     diffs.pop();
   }
   // Second pass: look for single edits surrounded on both sides by equalities
@@ -495,6 +493,10 @@ function diff_cleanupSemanticScore_(one, two) {
 const NO_DIFF_MESSAGE = "Compared values have no visual difference.";
 const SIMILAR_MESSAGE = "Compared values serialize to the same structure.\n" + "Printing internal object structure without calling `toJSON` instead.";
 
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
 var build = {};
 
 var hasRequiredBuild;
@@ -1623,8 +1625,8 @@ function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCo
 }
 // Compare two arrays of strings line-by-line.
 function diffLinesRaw(aLines, bLines, options) {
-  const truncate = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
-  const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? 0), 0);
+  const truncate = options?.truncateThreshold ?? false;
+  const truncateThreshold = Math.max(Math.floor(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;
@@ -1697,8 +1699,8 @@ function getNewLineSymbol(string) {
   return string.includes("\r\n") ? "\r\n" : "\n";
 }
 function diffStrings(a, b, options) {
-  const truncate = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
-  const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? 0), 0);
+  const truncate = options?.truncateThreshold ?? false;
+  const truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);
   let aLength = a.length;
   let bLength = b.length;
   if (truncate) {
@@ -2010,8 +2012,8 @@ function diff(a, b, options) {
     }
     aDisplay = truncate(aDisplay);
     bDisplay = truncate(bDisplay);
-    const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)} \n${aDisplay}`;
-    const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)} \n${bDisplay}`;
+    const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)}\n${aDisplay}`;
+    const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)}\n${bDisplay}`;
     return `${aDiff}\n\n${bDiff}`;
   }
   if (omitDifference) {

package/dist/@vitest/utils/display.d.ts

@@ -17,8 +17,9 @@ interface Options {
 type LoupeOptions = Partial<Options>;
 interface StringifyOptions extends PrettyFormatOptions {
 	maxLength?: number;
+	filterNode?: string | ((node: any) => boolean);
 }
-declare function stringify(object: unknown, maxDepth?: number, { maxLength, ...options }?: StringifyOptions): string;
+declare function stringify(object: unknown, maxDepth?: number, { maxLength, filterNode, ...options }?: StringifyOptions): string;
 declare const formatRegExp: RegExp;
 declare function format(...args: unknown[]): string;
 declare function browserFormat(...args: unknown[]): string;

package/dist/@vitest/utils/display.js

@@ -1,4 +1,4 @@
-import { plugins, format as format$1 } from '../pretty-format/index.js';
+import { plugins, createDOMElementFilter, format as format$1 } from '../pretty-format/index.js';
 
 const ansiColors = {
     bold: ['1', '22'],
@@ -583,14 +583,24 @@ const PLUGINS = [
   Immutable,
   AsymmetricMatcher
 ];
-function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
   const MAX_LENGTH = maxLength ?? 1e4;
   let result;
+  // Convert string selector to filter function
+  const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
+  const plugins = filterFn ? [
+    ReactTestComponent,
+    ReactElement,
+    createDOMElementFilter(filterFn),
+    DOMCollection,
+    Immutable,
+    AsymmetricMatcher
+  ] : PLUGINS;
   try {
     result = format$1(object, {
       maxDepth,
       escapeString: false,
-      plugins: PLUGINS,
+      plugins,
       ...options
     });
   } catch {
@@ -598,16 +608,36 @@ function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
       callToJSON: false,
       maxDepth,
       escapeString: false,
-      plugins: PLUGINS,
+      plugins,
       ...options
     });
   }
   // Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
   return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
     maxLength,
+    filterNode,
     ...options
   }) : result;
 }
+function createNodeFilterFromSelector(selector) {
+  const ELEMENT_NODE = 1;
+  const COMMENT_NODE = 8;
+  return (node) => {
+    // Filter out comments
+    if (node.nodeType === COMMENT_NODE) {
+      return false;
+    }
+    // Filter out elements matching the selector
+    if (node.nodeType === ELEMENT_NODE && node.matches) {
+      try {
+        return !node.matches(selector);
+      } catch {
+        return true;
+      }
+    }
+    return true;
+  };
+}
 const formatRegExp = /%[sdjifoOc%]/g;
 function baseFormat(args, options = {}) {
   const formatArg = (item, inspecOptions) => {
@@ -664,6 +694,9 @@ function baseFormat(args, options = {}) {
         if (typeof value === "bigint") {
           return `${value.toString()}n`;
         }
+        if (typeof value === "symbol") {
+          return "NaN";
+        }
         return Number(value).toString();
       }
       case "%i": {
@@ -697,7 +730,7 @@ function baseFormat(args, options = {}) {
   });
   for (let x = args[i]; i < len; x = args[++i]) {
     if (x === null || typeof x !== "object") {
-      str += ` ${x}`;
+      str += ` ${typeof x === "symbol" ? x.toString() : x}`;
     } else {
       str += ` ${formatArg(x)}`;
     }

package/dist/@vitest/utils/error.d.ts

@@ -1,7 +1,8 @@
 import { D as DiffOptions } from './types.d-BCElaP-c.js';
+import { TestError } from './types.js';
 export { serializeValue as serializeError } from './serialize.js';
 import '../pretty-format/index.js';
 
-declare function processError(_err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): any;
+declare function processError(_err: any, diffOptions?: DiffOptions, seen?: WeakSet<WeakKey>): TestError;
 
 export { processError };

package/dist/@vitest/utils/error.js

@@ -5,7 +5,6 @@ import '../pretty-format/index.js';
 import '../../vendor/tinyrainbow.mjs';
 import './helpers.js';
 import './constants.js';
-import './chunk-_commonjsHelpers.js';
 
 function processError(_err, diffOptions, seen = new WeakSet()) {
   if (!_err || typeof _err !== "object") {
@@ -35,7 +34,7 @@ function processError(_err, diffOptions, seen = new WeakSet()) {
   try {
     return serializeValue(err);
   } catch (e) {
-    return serializeValue(new Error(`Failed to fully serialize error: ${e === null || e === void 0 ? void 0 : e.message}\nInner error message: ${err === null || err === void 0 ? void 0 : err.message}`));
+    return serializeValue(new Error(`Failed to fully serialize error: ${e?.message}\nInner error message: ${err?.message}`));
   }
 }
 

package/dist/@vitest/utils/helpers.d.ts

@@ -35,6 +35,7 @@ declare function wrapId(id: string): string;
 */
 declare function unwrapId(id: string): string;
 declare function withTrailingSlash(path: string): string;
+declare function filterOutComments(s: string): string;
 declare function isBareImport(id: string): boolean;
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 declare function isObject(item: unknown): boolean;
@@ -60,6 +61,7 @@ declare function createDefer<T>(): DeferPromise<T>;
 */
 declare function getCallLastIndex(code: string): number | null;
 declare function isNegativeNaN(val: number): boolean;
+declare function ordinal(i: number): string;
 /**
 * Deep merge :P
 *
@@ -68,6 +70,7 @@ declare function isNegativeNaN(val: number): boolean;
 * 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;
+declare function unique<T>(array: T[]): T[];
 
-export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, filterOutComments, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, ordinal, shuffle, slash, toArray, unique, unwrapId, withTrailingSlash, wrapId };
 export type { DeferPromise };

package/dist/@vitest/utils/helpers.js

@@ -88,6 +88,31 @@ function withTrailingSlash(path) {
   }
   return path;
 }
+function filterOutComments(s) {
+  const result = [];
+  let commentState = "none";
+  for (let i = 0; i < s.length; ++i) {
+    if (commentState === "singleline") {
+      if (s[i] === "\n") {
+        commentState = "none";
+      }
+    } else if (commentState === "multiline") {
+      if (s[i - 1] === "*" && s[i] === "/") {
+        commentState = "none";
+      }
+    } else if (commentState === "none") {
+      if (s[i] === "/" && s[i + 1] === "/") {
+        commentState = "singleline";
+      } else if (s[i] === "/" && s[i + 1] === "*") {
+        commentState = "multiline";
+        i += 2;
+      } else {
+        result.push(s[i]);
+      }
+    }
+  }
+  return result.join("");
+}
 const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
 function isBareImport(id) {
   return bareImportRE.test(id);
@@ -261,6 +286,20 @@ function isPlainObject(val) {
 function isMergeableObject(item) {
   return isPlainObject(item) && !Array.isArray(item);
 }
+function ordinal(i) {
+  const j = i % 10;
+  const k = i % 100;
+  if (j === 1 && k !== 11) {
+    return `${i}st`;
+  }
+  if (j === 2 && k !== 12) {
+    return `${i}nd`;
+  }
+  if (j === 3 && k !== 13) {
+    return `${i}rd`;
+  }
+  return `${i}th`;
+}
 /**
 * Deep merge :P
 *
@@ -291,5 +330,8 @@ function deepMerge(target, ...sources) {
   }
   return deepMerge(target, ...sources);
 }
+function unique(array) {
+  return Array.from(new Set(array));
+}
 
-export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, shuffle, slash, toArray, unwrapId, withTrailingSlash, wrapId };
+export { assertTypes, cleanUrl, clone, createDefer, createSimpleStackTrace, deepClone, deepMerge, filterOutComments, getCallLastIndex, getOwnProperties, getType, isBareImport, isExternalUrl, isNegativeNaN, isObject, isPrimitive, nanoid, noop, notNullish, objectAttr, ordinal, shuffle, slash, toArray, unique, unwrapId, withTrailingSlash, wrapId };

package/dist/@vitest/utils/resolver.js

@@ -5,13 +5,12 @@ const packageCache = new Map();
 function findNearestPackageData(basedir) {
   const originalBasedir = basedir;
   while (basedir) {
-    var _tryStatSync;
     const cached = getCachedData(packageCache, basedir, originalBasedir);
     if (cached) {
       return cached;
     }
     const pkgPath = join(basedir, "package.json");
-    if ((_tryStatSync = tryStatSync(pkgPath)) === null || _tryStatSync === void 0 ? void 0 : _tryStatSync.isFile()) {
+    if (tryStatSync(pkgPath)?.isFile()) {
       const pkgData = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf8")));
       if (packageCache) {
         setCacheData(packageCache, pkgData, basedir, originalBasedir);

package/dist/@vitest/utils/serialize.js

@@ -22,16 +22,16 @@ function serializeValue(val, seen = new WeakMap()) {
     const jsonValue = val.toJSON();
     if (jsonValue && jsonValue !== val && typeof jsonValue === "object") {
       if (typeof val.message === "string") {
-        safe(() => jsonValue.message ?? (jsonValue.message = normalizeErrorMessage(val.message)));
+        safe(() => jsonValue.message ??= normalizeErrorMessage(val.message));
       }
       if (typeof val.stack === "string") {
-        safe(() => jsonValue.stack ?? (jsonValue.stack = val.stack));
+        safe(() => jsonValue.stack ??= val.stack);
       }
       if (typeof val.name === "string") {
-        safe(() => jsonValue.name ?? (jsonValue.name = val.name));
+        safe(() => jsonValue.name ??= val.name);
       }
       if (val.cause != null) {
-        safe(() => jsonValue.cause ?? (jsonValue.cause = serializeValue(val.cause, seen)));
+        safe(() => jsonValue.cause ??= serializeValue(val.cause, seen));
       }
     }
     return serializeValue(jsonValue, seen);
@@ -101,7 +101,7 @@ function serializeValue(val, seen = new WeakMap()) {
       obj = Object.getPrototypeOf(obj);
     }
     if (val instanceof Error) {
-      safe(() => val.message = normalizeErrorMessage(val.message));
+      safe(() => clone.message = normalizeErrorMessage(val.message));
     }
     return clone;
   }
@@ -112,7 +112,7 @@ function safe(fn) {
   } catch {}
 }
 function normalizeErrorMessage(message) {
-  return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
+  return message.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/getByTestId('__vitest_\d+__')/g, "page");
 }
 
 export { serializeValue };

package/dist/@vitest/utils/source-map/node.d.ts

@@ -0,0 +1,6 @@
+interface ExtractedSourceMap {
+	map: any;
+}
+declare function extractSourcemapFromFile(code: string, filePath: string): ExtractedSourceMap | undefined;
+
+export { extractSourcemapFromFile };

package/dist/@vitest/utils/source-map/node.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import convertSourceMap from '../../../vendor/convert-source-map.mjs';
+
+// based on vite
+// https://github.com/vitejs/vite/blob/84079a84ad94de4c1ef4f1bdb2ab448ff2c01196/packages/vite/src/node/server/sourcemap.ts#L149
+function extractSourcemapFromFile(code, filePath) {
+  const map = (convertSourceMap.fromSource(code) || convertSourceMap.fromMapFileSource(code, createConvertSourceMapReadMap(filePath)))?.toObject();
+  return map ? { map } : undefined;
+}
+function createConvertSourceMapReadMap(originalFileName) {
+  return (filename) => {
+    // convertSourceMap can detect invalid filename from comments.
+    // fallback to empty source map to avoid errors.
+    const targetPath = path.resolve(path.dirname(originalFileName), filename);
+    if (existsSync(targetPath)) {
+      return readFileSync(targetPath, "utf-8");
+    }
+    return "{}";
+  };
+}
+
+export { extractSourcemapFromFile };