vitest 0.21.1 → 0.23.0

package/dist/{index-4a906fa4.d.ts → index-5f09f4d0.d.ts}

@@ -1,53 +1,5 @@
-import { MessagePort } from 'worker_threads';
-import { R as ResolvedConfig, a2 as ViteNodeResolveId, a3 as FetchFunction, a4 as RawSourceMap, a as File, X as UserConsoleLog, T as TaskResultPack, v as SnapshotResult, g as Test, a5 as ModuleCacheMap, k as SuiteAPI, j as TestAPI, m as SuiteHooks, H as HookListener, q as TestContext, S as Suite, l as HookCleanupCallback } from './global-60f880c6.js';
-import { M as MockMap } from './mocker-5e2a8e41.js';
 import { SpyImpl } from 'tinyspy';
-
-declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
-declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
-declare type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType$1<T>>>;
-declare type BirpcFn<T> = PromisifyFn<T> & {
-    /**
-     * Send event without asking for response
-     */
-    asEvent(...args: ArgumentsType<T>): void;
-};
-declare type BirpcReturn<RemoteFunctions> = {
-    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
-};
-
-interface WorkerContext {
-    workerId: number;
-    port: MessagePort;
-    config: ResolvedConfig;
-    files: string[];
-    invalidates?: string[];
-}
-declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
-interface WorkerRPC {
-    fetch: FetchFunction;
-    resolveId: ResolveIdFunction;
-    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
-    onFinished: (files: File[], errors?: unknown[]) => void;
-    onWorkerExit: (code?: number) => void;
-    onPathsCollected: (paths: string[]) => void;
-    onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledRejection: (err: unknown) => void;
-    onCollected: (files: File[]) => void;
-    onTaskUpdate: (pack: TaskResultPack[]) => void;
-    snapshotSaved: (snapshot: SnapshotResult) => void;
-    resolveSnapshotPath: (testPath: string) => string;
-}
-interface WorkerGlobalState {
-    ctx: WorkerContext;
-    config: ResolvedConfig;
-    rpc: BirpcReturn<WorkerRPC>;
-    current?: Test;
-    filepath?: string;
-    moduleCache: ModuleCacheMap;
-    browserHashMap?: Map<string, string>;
-    mockMap: MockMap;
-}
+import { m as SuiteAPI, l as TestAPI, al as BenchmarkAPI, o as SuiteHooks, H as HookListener, s as TestContext, S as Suite, n as HookCleanupCallback, h as Test } from './global-ea084c9f.js';
 
 interface MockResultReturn<T> {
     type: 'return';
@@ -150,6 +102,7 @@ declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...ar
 
 declare const suite: SuiteAPI<{}>;
 declare const test: TestAPI<{}>;
+declare const bench: BenchmarkAPI;
 declare const describe: SuiteAPI<{}>;
 declare const it: TestAPI<{}>;
 
@@ -161,4 +114,4 @@ declare const afterEach: <ExtraContext = {}>(fn: HookListener<[TestContext & Ext
 declare function createExpect(test?: Test): Vi.ExpectStatic;
 declare const globalExpect: Vi.ExpectStatic;
 
-export { EnhancedSpy as E, MaybeMockedDeep as M, ResolveIdFunction as R, SpyInstance as S, WorkerContext as W, MaybeMocked as a, MaybePartiallyMocked as b, MaybePartiallyMockedDeep as c, suite as d, describe as e, fn as f, beforeAll as g, afterAll as h, it as i, beforeEach as j, afterEach as k, globalExpect as l, createExpect as m, MockedFunction as n, MockedObject as o, MockInstance as p, Mock as q, MockContext as r, spyOn as s, test as t, Mocked as u, MockedClass as v, WorkerRPC as w, WorkerGlobalState as x };
+export { EnhancedSpy as E, MaybeMockedDeep as M, SpyInstance as S, MaybeMocked as a, MaybePartiallyMocked as b, MaybePartiallyMockedDeep as c, suite as d, describe as e, fn as f, bench as g, beforeAll as h, it as i, afterAll as j, beforeEach as k, afterEach as l, globalExpect as m, createExpect as n, MockedFunction as o, MockedObject as p, MockInstance as q, Mock as r, spyOn as s, test as t, MockContext as u, Mocked as v, MockedClass as w };

package/dist/index.d.ts

@@ -1,15 +1,15 @@
-import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-4a906fa4.js';
-export { E as EnhancedSpy, q as Mock, r as MockContext, p as MockInstance, u as Mocked, v as MockedClass, n as MockedFunction, o as MockedObject, R as ResolveIdFunction, S as SpyInstance, W as WorkerContext, x as WorkerGlobalState, w as WorkerRPC, h as afterAll, k as afterEach, g as beforeAll, j as beforeEach, m as createExpect, e as describe, l as expect, i as it, d as suite, t as test } from './index-4a906fa4.js';
-import { D as DoneCallback, F as FakeTimerInstallOpts, a as File, T as TaskResultPack, R as ResolvedConfig, M as ModuleGraphData, b as Reporter } from './global-60f880c6.js';
-export { A as ApiConfig, C as ArgumentsType, z as Arrayable, y as Awaitable, B as BuiltinEnvironment, a0 as C8Options, O as Constructable, $ as CoverageReporter, K as DeepMerge, D as DoneCallback, W as Environment, E as EnvironmentOptions, Q as EnvironmentReturn, _ as ErrorWithDiff, a as File, l as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, G as MergeInsertions, P as ModuleCache, M as ModuleGraphData, L as MutableArray, N as Nullable, Z as ParsedStack, Y as Position, b as Reporter, a1 as ResolvedC8Options, R as ResolvedConfig, c as RunMode, p as RuntimeContext, r as SnapshotData, u as SnapshotMatchOptions, v as SnapshotResult, t as SnapshotStateOptions, x as SnapshotSummary, s as SnapshotUpdateState, S as Suite, k as SuiteAPI, n as SuiteCollector, o as SuiteFactory, m as SuiteHooks, h as Task, e as TaskBase, f as TaskResult, T as TaskResultPack, d as TaskState, g as Test, j as TestAPI, q as TestContext, i as TestFunction, w as UncheckedSnapshot, U as UserConfig, X as UserConsoleLog, V as Vitest } from './global-60f880c6.js';
+import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-5f09f4d0.js';
+export { E as EnhancedSpy, r as Mock, u as MockContext, q as MockInstance, v as Mocked, w as MockedClass, o as MockedFunction, p as MockedObject, S as SpyInstance, j as afterAll, l as afterEach, h as beforeAll, k as beforeEach, g as bench, n as createExpect, e as describe, m as expect, i as it, d as suite, t as test } from './index-5f09f4d0.js';
+import { D as DoneCallback, F as FakeTimerInstallOpts, a as File, T as TaskResultPack, R as ResolvedConfig, M as ModuleGraphData, b as Reporter } from './global-ea084c9f.js';
+export { L as AfterSuiteRunMeta, A as ApiConfig, Y as ArgumentsType, X as Arrayable, P as Awaitable, ae as BaseCoverageOptions, ak as BenchFunction, ai as Benchmark, al as BenchmarkAPI, aj as BenchmarkResult, ah as BenchmarkUserOptions, B as BuiltinEnvironment, C as CSSModuleScopeStrategy, a0 as Constructable, ag as CoverageC8Options, af as CoverageIstanbulOptions, ac as CoverageOptions, a9 as CoverageProvider, aa as CoverageProviderModule, ab as CoverageReporter, _ as DeepMerge, D as DoneCallback, a3 as Environment, E as EnvironmentOptions, a2 as EnvironmentReturn, a7 as ErrorWithDiff, a as File, n as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, Z as MergeInsertions, a1 as ModuleCache, M as ModuleGraphData, $ as MutableArray, Q as Nullable, a8 as OnServerRestartHandler, a6 as ParsedStack, a5 as Position, b as Reporter, K as ResolveIdFunction, R as ResolvedConfig, ad as ResolvedCoverageOptions, d as RunMode, r as RuntimeContext, u as SnapshotData, x as SnapshotMatchOptions, y as SnapshotResult, w as SnapshotStateOptions, G as SnapshotSummary, v as SnapshotUpdateState, S as Suite, m as SuiteAPI, p as SuiteCollector, q as SuiteFactory, o as SuiteHooks, i as Task, f as TaskBase, g as TaskResult, T as TaskResultPack, e as TaskState, h as Test, l as TestAPI, s as TestContext, j as TestFunction, k as TestOptions, z as UncheckedSnapshot, U as UserConfig, a4 as UserConsoleLog, t as Vitest, V as VitestEnvironment, c as VitestRunMode, W as WorkerContext, O as WorkerGlobalState, N as WorkerRPC } from './global-ea084c9f.js';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
-import 'worker_threads';
-import './mocker-5e2a8e41.js';
+export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import 'tinyspy';
 import 'fs';
+import 'worker_threads';
 
 /**
  * A simple wrapper for converting callback style to promise

package/dist/index.mjs

@@ -1,18 +1,19 @@
-export { c as createExpect, d as describe, b as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.98d42d89.mjs';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.453f8858.mjs';
+export { b as bench, c as createExpect, d as describe, e as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.2af36ddf.mjs';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.75ce0575.mjs';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import 'util';
-import './chunk-mock-date.bc81a3ac.mjs';
+import './chunk-mock-date.0d86eaa5.mjs';
 import 'path';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
+import 'url';
 import 'local-pkg';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.b50ab560.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';
+import './chunk-runtime-rpc.3fe371e9.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.94107ee8.mjs';
+import './chunk-utils-source-map.70ee97e1.mjs';
 import './spy.mjs';
 import 'tinyspy';

package/dist/loader.mjs

@@ -1,13 +1,13 @@
 import { pathToFileURL } from 'url';
 import { readFile } from 'fs/promises';
-import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.f34df9d3.mjs';
-import './chunk-mock-date.bc81a3ac.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.68573626.mjs';
+import { g as getWorkerState } from './chunk-mock-date.0d86eaa5.mjs';
 import 'module';
 import 'fs';
 import 'path';
 import 'assert';
 import 'util';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
 import 'local-pkg';
 

package/dist/node.d.ts

@@ -1,10 +1,11 @@
-import { U as UserConfig, V as Vitest, a5 as ModuleCacheMap, a6 as ViteNodeRunnerOptions, a7 as ViteNodeRunner, a8 as TestSequencer } from './global-60f880c6.js';
-export { a8 as TestSequencer, aa as TestSequencerConstructor, V as Vitest, a9 as startVitest } from './global-60f880c6.js';
+import { c as VitestRunMode, U as UserConfig, t as Vitest, am as ModuleCacheMap, an as ViteNodeRunnerOptions, ao as MockMap, ap as ViteNodeRunner, aq as TestSequencer } from './global-ea084c9f.js';
+export { aq as TestSequencer, as as TestSequencerConstructor, t as Vitest, ar as startVitest } from './global-ea084c9f.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
-import { M as MockMap } from './mocker-5e2a8e41.js';
+import 'tinybench';
 import 'fs';
+import 'worker_threads';
 
-declare function createVitest(options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
+declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
 
 declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugin[]>;
 

package/dist/node.mjs

@@ -1,34 +1,37 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.27aee038.mjs';
-export { V as VitestRunner } from './chunk-runtime-mocker.23b62bfa.mjs';
-import './chunk-mock-date.bc81a3ac.mjs';
-import 'path';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.41bf722e.mjs';
+export { V as VitestRunner } from './chunk-runtime-mocker.fc76f21d.mjs';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
-import 'local-pkg';
-import './chunk-defaults.02abff90.mjs';
-import 'fs';
-import 'module';
 import 'url';
+import 'path';
+import './chunk-integrations-coverage.99c020eb.mjs';
+import 'local-pkg';
+import './chunk-env-node.ceb43f1c.mjs';
+import 'console';
+import './chunk-mock-date.0d86eaa5.mjs';
 import 'vite';
 import 'process';
-import './chunk-constants.26dc9f85.mjs';
+import 'fs';
 import 'os';
 import 'util';
 import 'stream';
 import 'events';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-vite-node-client.fdd9592c.mjs';
+import './chunk-vite-node-client.74ebe3d5.mjs';
+import 'module';
 import 'vm';
-import './chunk-vite-node-utils.f34df9d3.mjs';
+import './chunk-vite-node-utils.68573626.mjs';
 import 'assert';
 import 'debug';
+import 'perf_hooks';
 import 'worker_threads';
 import 'tinypool';
-import 'perf_hooks';
-import './chunk-utils-source-map.94107ee8.mjs';
+import './chunk-utils-source-map.70ee97e1.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'crypto';
-import './vendor-index.61438b77.mjs';
-import './chunk-magic-string.efe26975.mjs';
+import './vendor-index.13e3bda3.mjs';
+import './vendor-index.731a22f2.mjs';
+import './chunk-magic-string.56b2b543.mjs';
+import 'strip-literal';
 import 'readline';
 import './vendor-index.ae96af6e.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';

package/dist/suite.mjs

@@ -1,15 +1,16 @@
 import 'util';
-import './chunk-mock-date.bc81a3ac.mjs';
-export { e as clearCollectorContext, o as createSuiteHooks, f as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.98d42d89.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';
+import './chunk-mock-date.0d86eaa5.mjs';
+export { b as bench, f as clearCollectorContext, q as createSuiteHooks, h as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.2af36ddf.mjs';
 import 'path';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
+import 'url';
 import 'local-pkg';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.b50ab560.mjs';
+import './chunk-runtime-rpc.3fe371e9.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.94107ee8.mjs';
+import './chunk-utils-source-map.70ee97e1.mjs';
 import './spy.mjs';
 import 'tinyspy';

package/dist/vendor-index.0557b03a.mjs

@@ -0,0 +1,147 @@
+import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var eventTargetPolyfill = {};
+
+const root =
+  (typeof globalThis !== "undefined" && globalThis) ||
+  (typeof self !== "undefined" && self) ||
+  (typeof commonjsGlobal !== "undefined" && commonjsGlobal);
+
+function isConstructor(fn) {
+  try {
+    new fn();
+  } catch (error) {
+    return false;
+  }
+  return true;
+}
+
+if (typeof root.Event !== "function" || !isConstructor(root.Event)) {
+  root.Event = (function () {
+    function Event(type, options) {
+        this.bubbles = !!options && !!options.bubbles;
+        this.cancelable = !!options && !!options.cancelable;
+        this.composed = !!options && !!options.composed;
+      this.type = type;
+    }
+
+    return Event;
+  })();
+}
+
+if (typeof root.EventTarget === "undefined" || !isConstructor(root.Event)) {
+  root.EventTarget = (function () {
+    function EventTarget() {
+      this.__listeners = new Map();
+    }
+
+    EventTarget.prototype = Object.create(Object.prototype);
+
+    EventTarget.prototype.addEventListener = function (
+      type,
+      listener,
+      options
+    ) {
+      if (arguments.length < 2) {
+        throw new TypeError(
+          `TypeError: Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const __listeners = this.__listeners;
+      const actualType = type.toString();
+      if (!__listeners.has(actualType)) {
+        __listeners.set(actualType, new Map());
+      }
+      const listenersForType = __listeners.get(actualType);
+      if (!listenersForType.has(listener)) {
+        // Any given listener is only registered once
+        listenersForType.set(listener, options);
+      }
+    };
+
+    EventTarget.prototype.removeEventListener = function (
+      type,
+      listener,
+      _options
+    ) {
+      if (arguments.length < 2) {
+        throw new TypeError(
+          `TypeError: Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      const __listeners = this.__listeners;
+      const actualType = type.toString();
+      if (__listeners.has(actualType)) {
+        const listenersForType = __listeners.get(actualType);
+        if (listenersForType.has(listener)) {
+          listenersForType.delete(listener);
+        }
+      }
+    };
+
+    EventTarget.prototype.dispatchEvent = function (event) {
+      if (!(event instanceof Event)) {
+        throw new TypeError(
+          `Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'.`
+        );
+      }
+      const type = event.type;
+      const __listeners = this.__listeners;
+      const listenersForType = __listeners.get(type);
+      if (listenersForType) {
+        for (const [listener, options] of listenersForType.entries()) {
+          try {
+            if (typeof listener === "function") {
+              // Listener functions must be executed with the EventTarget as the `this` context.
+              listener.call(this, event);
+            } else if (listener && typeof listener.handleEvent === "function") {
+              // Listener objects have their handleEvent method called, if they have one
+              listener.handleEvent(event);
+            }
+          } catch (err) {
+            // We need to report the error to the global error handling event,
+            // but we do not want to break the loop that is executing the events.
+            // Unfortunately, this is the best we can do, which isn't great, because the
+            // native EventTarget will actually do this synchronously before moving to the next
+            // event in the loop.
+            setTimeout(() => {
+              throw err;
+            });
+          }
+          if (options && options.once) {
+            // If this was registered with { once: true }, we need
+            // to remove it now.
+            listenersForType.delete(listener);
+          }
+        }
+      }
+      // Since there are no cancellable events on a base EventTarget,
+      // this should always return true.
+      return true;
+    };
+
+    return EventTarget;
+  })();
+}
+
+var index = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  'default': eventTargetPolyfill
+}, [eventTargetPolyfill]);
+
+export { index as i };

package/dist/vendor-index.13e3bda3.mjs

@@ -0,0 +1,61 @@
+var onetime$1 = {exports: {}};
+
+var mimicFn$2 = {exports: {}};
+
+const mimicFn$1 = (to, from) => {
+	for (const prop of Reflect.ownKeys(from)) {
+		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+	}
+
+	return to;
+};
+
+mimicFn$2.exports = mimicFn$1;
+// TODO: Remove this for the next major release
+mimicFn$2.exports.default = mimicFn$1;
+
+const mimicFn = mimicFn$2.exports;
+
+const calledFunctions = new WeakMap();
+
+const onetime = (function_, options = {}) => {
+	if (typeof function_ !== 'function') {
+		throw new TypeError('Expected a function');
+	}
+
+	let returnValue;
+	let callCount = 0;
+	const functionName = function_.displayName || function_.name || '<anonymous>';
+
+	const onetime = function (...arguments_) {
+		calledFunctions.set(onetime, ++callCount);
+
+		if (callCount === 1) {
+			returnValue = function_.apply(this, arguments_);
+			function_ = null;
+		} else if (options.throw === true) {
+			throw new Error(`Function \`${functionName}\` can only be called once`);
+		}
+
+		return returnValue;
+	};
+
+	mimicFn(onetime, function_);
+	calledFunctions.set(onetime, callCount);
+
+	return onetime;
+};
+
+onetime$1.exports = onetime;
+// TODO: Remove this for the next major release
+onetime$1.exports.default = onetime;
+
+onetime$1.exports.callCount = function_ => {
+	if (!calledFunctions.has(function_)) {
+		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+	}
+
+	return calledFunctions.get(function_);
+};
+
+export { onetime$1 as o };

package/dist/{chunk-node-git.c2be9c49.mjs → vendor-index.4aeeb598.mjs}

@@ -1,20 +1,11 @@
-import { y as resolve } from './chunk-mock-date.bc81a3ac.mjs';
 import { Buffer } from 'buffer';
 import path from 'path';
 import childProcess from 'child_process';
 import process$1 from 'process';
 import { m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.62ce5c33.mjs';
-import _url from 'url';
+import url from 'url';
 import require$$0, { constants } from 'os';
-import { s as signalExit } from './vendor-index.61438b77.mjs';
-import 'tty';
-import 'local-pkg';
-import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import 'fs';
-import 'stream';
-import 'util';
-import 'assert';
-import 'events';
+import { s as signalExit } from './vendor-index.731a22f2.mjs';
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -52,7 +43,7 @@ function npmRunPath(options = {}) {
 	} = options;
 
 	let previous;
-	const cwdString = cwd instanceof URL ? _url.fileURLToPath(cwd) : cwd;
+	const cwdString = cwd instanceof URL ? url.fileURLToPath(cwd) : cwd;
 	let cwdPath = path.resolve(cwdString);
 	const result = [];
 
@@ -1077,63 +1068,4 @@ function execa(file, args, options) {
 	return mergePromise(spawned, handlePromiseOnce);
 }
 
-class VitestGit {
-  constructor(cwd) {
-    this.cwd = cwd;
-  }
-  async resolveFilesWithGitCommand(args) {
-    let result;
-    try {
-      result = await execa("git", args, { cwd: this.root });
-    } catch (e) {
-      e.message = e.stderr;
-      throw e;
-    }
-    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
-  }
-  async findChangedFiles(options) {
-    const root = await this.getRoot(this.cwd);
-    if (!root)
-      return null;
-    this.root = root;
-    const changedSince = options.changedSince;
-    if (typeof changedSince === "string") {
-      const [committed, staged2, unstaged2] = await Promise.all([
-        this.getFilesSince(changedSince),
-        this.getStagedFiles(),
-        this.getUnstagedFiles()
-      ]);
-      return [...committed, ...staged2, ...unstaged2];
-    }
-    const [staged, unstaged] = await Promise.all([
-      this.getStagedFiles(),
-      this.getUnstagedFiles()
-    ]);
-    return [...staged, ...unstaged];
-  }
-  getFilesSince(hash) {
-    return this.resolveFilesWithGitCommand(["diff", "--name-only", `${hash}...HEAD`]);
-  }
-  getStagedFiles() {
-    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
-  }
-  getUnstagedFiles() {
-    return this.resolveFilesWithGitCommand([
-      "ls-files",
-      "--other",
-      "--modified",
-      "--exclude-standard"
-    ]);
-  }
-  async getRoot(cwd) {
-    const options = ["rev-parse", "--show-cdup"];
-    try {
-      const result = await execa("git", options, { cwd });
-      return resolve(cwd, result.stdout);
-    } catch {
-      return null;
-    }
-  }
-}
-
-export { VitestGit };
+export { execa as e };

package/dist/{vendor-index.61438b77.mjs → vendor-index.731a22f2.mjs}

@@ -2,66 +2,6 @@ import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
 import assert$1 from 'assert';
 import require$$2 from 'events';
 
-var onetime$1 = {exports: {}};
-
-var mimicFn$2 = {exports: {}};
-
-const mimicFn$1 = (to, from) => {
-	for (const prop of Reflect.ownKeys(from)) {
-		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
-	}
-
-	return to;
-};
-
-mimicFn$2.exports = mimicFn$1;
-// TODO: Remove this for the next major release
-mimicFn$2.exports.default = mimicFn$1;
-
-const mimicFn = mimicFn$2.exports;
-
-const calledFunctions = new WeakMap();
-
-const onetime = (function_, options = {}) => {
-	if (typeof function_ !== 'function') {
-		throw new TypeError('Expected a function');
-	}
-
-	let returnValue;
-	let callCount = 0;
-	const functionName = function_.displayName || function_.name || '<anonymous>';
-
-	const onetime = function (...arguments_) {
-		calledFunctions.set(onetime, ++callCount);
-
-		if (callCount === 1) {
-			returnValue = function_.apply(this, arguments_);
-			function_ = null;
-		} else if (options.throw === true) {
-			throw new Error(`Function \`${functionName}\` can only be called once`);
-		}
-
-		return returnValue;
-	};
-
-	mimicFn(onetime, function_);
-	calledFunctions.set(onetime, callCount);
-
-	return onetime;
-};
-
-onetime$1.exports = onetime;
-// TODO: Remove this for the next major release
-onetime$1.exports.default = onetime;
-
-onetime$1.exports.callCount = function_ => {
-	if (!calledFunctions.has(function_)) {
-		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
-	}
-
-	return calledFunctions.get(function_);
-};
-
 var signalExit = {exports: {}};
 
 var signals$1 = {exports: {}};
@@ -332,4 +272,4 @@ if (!processOk(process$1)) {
   };
 }
 
-export { onetime$1 as o, signalExit as s };
+export { signalExit as s };