vitest 0.25.8 → 0.26.0

package/dist/{types-71ccd11d.d.ts → types-56bcd6c3.d.ts}

@@ -1,5 +1,8 @@
-import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import { UserConfig as UserConfig$1, ViteDevServer, CommonServerOptions, AliasOptions } from 'vite';
 import { Task as Task$1, TaskResult as TaskResult$1, Bench, Options } from 'tinybench';
+import { ViteNodeRunner } from 'vite-node/client';
+import { ViteNodeServer } from 'vite-node/server';
+import { RawSourceMap, ViteNodeResolveId, FetchFunction, ModuleCacheMap } from 'vite-node';
 import { Stats } from 'fs';
 import { MessagePort } from 'worker_threads';
 
@@ -156,276 +159,6 @@ interface FakeTimerInstallOpts {
     shouldClearNativeTimers?: boolean | undefined;
 }
 
-interface UpdatePayload {
-  type: 'update'
-  updates: Update[]
-}
-
-interface Update {
-  type: 'js-update' | 'css-update'
-  path: string
-  acceptedPath: string
-  timestamp: number
-  /**
-   * @experimental internal
-   */
-  explicitImportRequired?: boolean | undefined
-}
-
-interface PrunePayload {
-  type: 'prune'
-  paths: string[]
-}
-
-interface FullReloadPayload {
-  type: 'full-reload'
-  path?: string
-}
-
-interface ErrorPayload {
-  type: 'error'
-  err: {
-    [name: string]: any
-    message: string
-    stack: string
-    id?: string
-    frame?: string
-    plugin?: string
-    pluginCode?: string
-    loc?: {
-      file?: string
-      line: number
-      column: number
-    }
-  }
-}
-
-interface CustomEventMap {
-  'vite:beforeUpdate': UpdatePayload
-  'vite:afterUpdate': UpdatePayload
-  'vite:beforePrune': PrunePayload
-  'vite:beforeFullReload': FullReloadPayload
-  'vite:error': ErrorPayload
-  'vite:invalidate': InvalidatePayload
-}
-
-interface InvalidatePayload {
-  path: string
-  message: string | undefined
-}
-
-type InferCustomEventPayload<T extends string> =
-  T extends keyof CustomEventMap ? CustomEventMap[T] : any
-
-type ModuleNamespace = Record<string, any> & {
-  [Symbol.toStringTag]: 'Module'
-}
-
-interface ViteHotContext {
-  readonly data: any
-
-  accept(): void
-  accept(cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(
-    deps: readonly string[],
-    cb: (mods: Array<ModuleNamespace | undefined>) => void,
-  ): void
-
-  acceptExports(
-    exportNames: string | readonly string[],
-    cb?: (mod: ModuleNamespace | undefined) => void,
-  ): void
-
-  dispose(cb: (data: any) => void): void
-  prune(cb: (data: any) => void): void
-  invalidate(message?: string): void
-
-  on<T extends string>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
-}
-declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
-    normalizePath(fsPath: string): string;
-    /**
-     * Assign partial data to the map
-     */
-    update(fsPath: string, mod: Partial<ModuleCache$1>): this;
-    set(fsPath: string, mod: ModuleCache$1): this;
-    get(fsPath: string): ModuleCache$1;
-    delete(fsPath: string): boolean;
-    /**
-     * Invalidate modules that dependent on the given modules, up to the main entry
-     */
-    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
-    /**
-     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
-     */
-    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
-    /**
-     * Return parsed source map based on inlined source map of the module
-     */
-    getSourceMap(id: string): RawSourceMap | null;
-}
-declare class ViteNodeRunner {
-    options: ViteNodeRunnerOptions;
-    root: string;
-    debug: boolean;
-    /**
-     * Holds the cache of modules
-     * Keys of the map are filepaths, or plain package names
-     */
-    moduleCache: ModuleCacheMap;
-    constructor(options: ViteNodeRunnerOptions);
-    executeFile(file: string): Promise<any>;
-    executeId(id: string): Promise<any>;
-    getSourceMap(id: string): RawSourceMap | null;
-    /** @internal */
-    cachedRequest(rawId: string, callstack: string[]): Promise<any>;
-    /** @internal */
-    directRequest(id: string, fsPath: string, _callstack: string[]): Promise<any>;
-    prepareContext(context: Record<string, any>): Record<string, any>;
-    shouldResolveId(dep: string): boolean;
-    /**
-     * Define if a module should be interop-ed
-     * This function mostly for the ability to override by subclass
-     */
-    shouldInterop(path: string, mod: any): boolean;
-    /**
-     * Import a module and interop it
-     */
-    interopedImport(path: string): Promise<any>;
-    hasNestedDefault(target: any): any;
-}
-interface DepsHandlingOptions {
-    external?: (string | RegExp)[];
-    inline?: (string | RegExp)[] | true;
-    /**
-     * Try to guess the CJS version of a package when it's invalid ESM
-     * @default false
-     */
-    fallbackCJS?: boolean;
-}
-interface StartOfSourceMap {
-    file?: string;
-    sourceRoot?: string;
-}
-interface RawSourceMap extends StartOfSourceMap {
-    version: string;
-    sources: string[];
-    names: string[];
-    sourcesContent?: string[];
-    mappings: string;
-}
-interface FetchResult {
-    code?: string;
-    externalize?: string;
-    map?: RawSourceMap;
-}
-type HotContext = Omit<ViteHotContext, 'acceptDeps' | 'decline'>;
-type FetchFunction = (id: string) => Promise<FetchResult>;
-type ResolveIdFunction$1 = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
-type CreateHotContextFunction = (runner: ViteNodeRunner, url: string) => HotContext;
-interface ModuleCache$1 {
-    promise?: Promise<any>;
-    exports?: any;
-    evaluated?: boolean;
-    code?: string;
-    map?: RawSourceMap;
-    /**
-     * Module ids that imports this module
-     */
-    importers?: Set<string>;
-}
-interface ViteNodeRunnerOptions {
-    root: string;
-    fetchModule: FetchFunction;
-    resolveId?: ResolveIdFunction$1;
-    createHotContext?: CreateHotContextFunction;
-    base?: string;
-    moduleCache?: ModuleCacheMap;
-    interopDefault?: boolean;
-    requestStubs?: Record<string, any>;
-    debug?: boolean;
-}
-interface ViteNodeResolveId {
-    external?: boolean | 'absolute' | 'relative';
-    id: string;
-    meta?: Record<string, any> | null;
-    moduleSideEffects?: boolean | 'no-treeshake' | null;
-    syntheticNamedExports?: boolean | string | null;
-}
-interface ViteNodeServerOptions {
-    /**
-     * Inject inline sourcemap to modules
-     * @default 'inline'
-     */
-    sourcemap?: 'inline' | boolean;
-    /**
-     * Deps handling
-     */
-    deps?: DepsHandlingOptions;
-    /**
-     * Transform method for modules
-     */
-    transformMode?: {
-        ssr?: RegExp[];
-        web?: RegExp[];
-    };
-    debug?: DebuggerOptions;
-}
-interface DebuggerOptions {
-    /**
-     * Dump the transformed module to filesystem
-     * Passing a string will dump to the specified path
-     */
-    dumpModules?: boolean | string;
-    /**
-     * Read dumpped module from filesystem whenever exists.
-     * Useful for debugging by modifying the dump result from the filesystem.
-     */
-    loadDumppedModules?: boolean;
-}
-
-declare class Debugger {
-    options: DebuggerOptions;
-    dumpDir: string | undefined;
-    initPromise: Promise<void> | undefined;
-    externalizeMap: Map<string, string>;
-    constructor(root: string, options: DebuggerOptions);
-    clearDump(): Promise<void>;
-    encodeId(id: string): string;
-    recordExternalize(id: string, path: string): Promise<void>;
-    dumpFile(id: string, result: TransformResult$1 | null): Promise<void>;
-    loadDump(id: string): Promise<TransformResult$1 | null>;
-    writeInfo(): Promise<void>;
-}
-
-declare class ViteNodeServer {
-    server: ViteDevServer;
-    options: ViteNodeServerOptions;
-    private fetchPromiseMap;
-    private transformPromiseMap;
-    fetchCache: Map<string, {
-        duration?: number | undefined;
-        timestamp: number;
-        result: FetchResult;
-    }>;
-    externalizeCache: Map<string, Promise<string | false>>;
-    debugger?: Debugger;
-    constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
-    shouldExternalize(id: string): Promise<string | false>;
-    resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
-    getSourceMap(source: string): RawSourceMap | null;
-    fetchModule(id: string): Promise<FetchResult>;
-    transformRequest(id: string): Promise<TransformResult$1 | null | undefined>;
-    getTransformMode(id: string): "web" | "ssr";
-    private _fetchModule;
-    private _transformRequest;
-}
-
 declare class SnapshotManager {
     options: SnapshotStateOptions;
     summary: SnapshotSummary;
@@ -1833,7 +1566,7 @@ interface InlineConfig {
      * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
      * and/or paths to custom reporters
      */
-    reporters?: Arrayable<BuiltinReporters | Reporter | Omit<string, BuiltinReporters>>;
+    reporters?: Arrayable<BuiltinReporters | 'html' | Reporter | Omit<string, BuiltinReporters>>;
     /**
      * diff output length
      */
@@ -1938,6 +1671,16 @@ interface InlineConfig {
      * @default false
      */
     restoreMocks?: boolean;
+    /**
+     * Will restore all global stubs to their original values before each test
+     * @default false
+     */
+    unstubGlobals?: boolean;
+    /**
+     * Will restore all env stubs to their original values before each test
+     * @default false
+     */
+    unstubEnvs?: boolean;
     /**
      * Serve API options.
      *
@@ -2483,4 +2226,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { WorkerContext as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SuiteFactory as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, RuntimeContext as K, TestContext as L, ModuleGraphData as M, Vitest as N, OnTestFailedHandler as O, SnapshotData as P, SnapshotUpdateState as Q, RuntimeConfig as R, SequenceHooks as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotStateOptions as W, SnapshotMatchOptions as X, SnapshotResult as Y, UncheckedSnapshot as Z, SnapshotSummary as _, File as a, ResolveIdFunction as a0, AfterSuiteRunMeta as a1, WorkerRPC as a2, WorkerGlobalState as a3, Awaitable as a4, Nullable as a5, Arrayable as a6, ArgumentsType$1 as a7, MergeInsertions as a8, DeepMerge as a9, ViteNodeRunner as aA, TestSequencer as aB, startVitest as aC, TestSequencerConstructor as aD, MutableArray as aa, Constructable as ab, ModuleCache as ac, EnvironmentReturn as ad, Environment as ae, UserConsoleLog as af, Position as ag, ParsedStack as ah, ErrorWithDiff as ai, OnServerRestartHandler as aj, CoverageProvider as ak, CoverageProviderModule as al, CoverageReporter as am, CoverageOptions as an, ResolvedCoverageOptions as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageC8Options as ar, BenchmarkUserOptions as as, Benchmark as at, BenchmarkResult as au, BenchFunction as av, BenchmarkAPI as aw, ModuleCacheMap as ax, ViteNodeRunnerOptions as ay, MockMap as az, ResolvedConfig as b, Reporter as c, RawErrsMap as d, TscErrorInfo as e, CollectLines as f, RootAndTarget as g, Context as h, CSSModuleScopeStrategy as i, VitestRunMode as j, TypecheckConfig as k, RunMode as l, TaskState as m, TaskBase as n, TaskResult as o, Suite as p, Test as q, TypeCheck as r, Task as s, TestFunction as t, TestOptions as u, TestAPI as v, SuiteAPI as w, HookCleanupCallback as x, SuiteHooks as y, SuiteCollector as z };
+export { WorkerContext as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SuiteFactory as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, RuntimeContext as K, TestContext as L, ModuleGraphData as M, Vitest as N, OnTestFailedHandler as O, SnapshotData as P, SnapshotUpdateState as Q, RuntimeConfig as R, SequenceHooks as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotStateOptions as W, SnapshotMatchOptions as X, SnapshotResult as Y, UncheckedSnapshot as Z, SnapshotSummary as _, File as a, ResolveIdFunction as a0, AfterSuiteRunMeta as a1, WorkerRPC as a2, WorkerGlobalState as a3, Awaitable as a4, Nullable as a5, Arrayable as a6, ArgumentsType$1 as a7, MergeInsertions as a8, DeepMerge as a9, TestSequencerConstructor as aA, MutableArray as aa, Constructable as ab, ModuleCache as ac, EnvironmentReturn as ad, Environment as ae, UserConsoleLog as af, Position as ag, ParsedStack as ah, ErrorWithDiff as ai, OnServerRestartHandler as aj, CoverageProvider as ak, CoverageProviderModule as al, CoverageReporter as am, CoverageOptions as an, ResolvedCoverageOptions as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageC8Options as ar, BenchmarkUserOptions as as, Benchmark as at, BenchmarkResult as au, BenchFunction as av, BenchmarkAPI as aw, MockMap as ax, TestSequencer as ay, startVitest as az, ResolvedConfig as b, Reporter as c, RawErrsMap as d, TscErrorInfo as e, CollectLines as f, RootAndTarget as g, Context as h, CSSModuleScopeStrategy as i, VitestRunMode as j, TypecheckConfig as k, RunMode as l, TaskState as m, TaskBase as n, TaskResult as o, Suite as p, Test as q, TypeCheck as r, Task as s, TestFunction as t, TestOptions as u, TestAPI as v, SuiteAPI as w, HookCleanupCallback as x, SuiteHooks as y, SuiteCollector as z };

package/dist/vendor-index.783e7f3e.js

@@ -0,0 +1,71 @@
+const DEFAULT_TIMEOUT = 6e4;
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = (i) => i,
+    deserialize = (i) => i,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => {
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          rpcPromiseMap.set(id, { resolve, reject });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          if (timeout >= 0) {
+            setTimeout(() => {
+              reject(new Error(`[birpc] timeout on calling "${method}"`));
+              rpcPromiseMap.delete(id);
+            }, timeout);
+          }
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      try {
+        result = await functions[method].apply(rpc, args);
+      } catch (e) {
+        error = e;
+      }
+      if (msg.i)
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (error)
+        promise?.reject(error);
+      else
+        promise?.resolve(result);
+      rpcPromiseMap.delete(ack);
+    }
+  });
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+
+export { createBirpc as c };

package/dist/vendor-index.96e022fd.js

@@ -0,0 +1,211 @@
+import 'acorn';
+import { builtinModules } from 'module';
+import 'fs';
+import { pathToFileURL } from 'url';
+import 'path';
+import assert from 'assert';
+import { format, inspect } from 'util';
+
+const BUILTIN_MODULES = new Set(builtinModules);
+
+const isWindows = process.platform === "win32";
+const own$1 = {}.hasOwnProperty;
+const messages = /* @__PURE__ */ new Map();
+const nodeInternalPrefix = "__node_internal_";
+let userStackTraceLimit;
+createError(
+  "ERR_INVALID_MODULE_SPECIFIER",
+  (request, reason, base = void 0) => {
+    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_INVALID_PACKAGE_CONFIG",
+  (path, base, message) => {
+    return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_INVALID_PACKAGE_TARGET",
+  (pkgPath, key, target, isImport = false, base = void 0) => {
+    const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+    if (key === ".") {
+      assert(isImport === false);
+      return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+    }
+    return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_MODULE_NOT_FOUND",
+  (path, base, type = "package") => {
+    return `Cannot find ${type} '${path}' imported from ${base}`;
+  },
+  Error
+);
+createError(
+  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  (pkgPath, subpath, base = void 0) => {
+    if (subpath === ".") {
+      return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+    }
+    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "Directory import '%s' is not supported resolving ES modules imported from %s",
+  Error
+);
+createError(
+  "ERR_UNKNOWN_FILE_EXTENSION",
+  'Unknown file extension "%s" for %s',
+  TypeError
+);
+createError(
+  "ERR_INVALID_ARG_VALUE",
+  (name, value, reason = "is invalid") => {
+    let inspected = inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
+  (url) => {
+    let message = "Only file and data URLs are supported by the default ESM loader";
+    if (isWindows && url.protocol.length === 2) {
+      message += ". On Windows, absolute paths must be valid file:// URLs";
+    }
+    message += `. Received protocol '${url.protocol}'`;
+    return message;
+  },
+  Error
+);
+function createError(sym, value, def) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(def, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...args) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = 0;
+    }
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) {
+      Error.stackTraceLimit = limit;
+    }
+    const message = getMessage(key, args, error);
+    Object.defineProperty(error, "message", {
+      value: message,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    Object.defineProperty(error, "toString", {
+      value() {
+        return `${this.name} [${key}]: ${this.message}`;
+      },
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+    addCodeToName(error, Base.name, key);
+    error.code = key;
+    return error;
+  }
+}
+const addCodeToName = hideStackFrames(
+  function(error, name, code) {
+    error = captureLargerStackTrace(error);
+    error.name = `${name} [${code}]`;
+    error.stack;
+    if (name === "SystemError") {
+      Object.defineProperty(error, "name", {
+        value: name,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      delete error.name;
+    }
+  }
+);
+function isErrorStackTraceLimitWritable() {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own$1.call(desc, "writable") ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(fn) {
+  const hidden = nodeInternalPrefix + fn.name;
+  Object.defineProperty(fn, "name", { value: hidden });
+  return fn;
+}
+const captureLargerStackTrace = hideStackFrames(
+  function(error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+    Error.captureStackTrace(error);
+    if (stackTraceLimitIsWritable) {
+      Error.stackTraceLimit = userStackTraceLimit;
+    }
+    return error;
+  }
+);
+function getMessage(key, args, self) {
+  const message = messages.get(key);
+  if (typeof message === "function") {
+    assert(
+      message.length <= args.length,
+      `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, args);
+  }
+  const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
+  assert(
+    expectedLength === args.length,
+    `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (args.length === 0) {
+    return message;
+  }
+  args.unshift(message);
+  return Reflect.apply(format, null, args);
+}
+Object.freeze(["node", "import"]);
+function isNodeBuiltin(id = "") {
+  id = id.replace(/^node:/, "").split("/")[0];
+  return BUILTIN_MODULES.has(id);
+}
+pathToFileURL(process.cwd());
+const CJS_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
+function hasCJSSyntax(code) {
+  return CJS_RE.test(code);
+}
+
+export { hasCJSSyntax as h, isNodeBuiltin as i };

package/dist/worker.js

@@ -1,25 +1,22 @@
 import { b as resolve, e as distDir } from './chunk-utils-env.03f840f2.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-source-map.b4ea5792.js';
+import { c as createBirpc } from './vendor-index.783e7f3e.js';
 import { workerId } from 'tinypool';
-import { g as getWorkerState } from './chunk-typecheck-constants.ed987901.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.99b910d0.js';
-import { r as rpc } from './chunk-runtime-rpc.42aebbb9.js';
-import { p as processError } from './chunk-runtime-error.616e92ca.js';
+import { ModuleCacheMap } from 'vite-node/client';
+import { g as getWorkerState } from './chunk-typecheck-constants.3f865d14.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.35fabb8b.js';
+import { r as rpc } from './chunk-runtime-rpc.7959fc79.js';
+import { p as processError } from './chunk-runtime-error.dfbbf9be.js';
 import 'tty';
 import 'url';
 import 'path';
-import 'module';
-import 'vm';
-import './chunk-vite-node-utils.0e4a6a88.js';
+import 'local-pkg';
+import 'vite';
 import 'fs';
+import './vendor-index.96e022fd.js';
 import 'acorn';
+import 'module';
 import 'assert';
 import 'util';
-import 'debug';
-import './vendor-source-map-support.1ce17397.js';
-import 'source-map';
-import 'local-pkg';
-import 'vite';
 import './chunk-utils-timers.793fd179.js';
 import 'chai';
 
@@ -53,7 +50,7 @@ async function startViteNode(ctx) {
     },
     moduleCache,
     mockMap,
-    interopDefault: config.deps.interopDefault ?? true,
+    interopDefault: config.deps.interopDefault,
     root: config.root,
     base: config.base
   }))[0];
@@ -66,6 +63,7 @@ function init(ctx) {
   const { config, port, workerId: workerId$1 } = ctx;
   process.env.VITEST_WORKER_ID = String(workerId$1);
   process.env.VITEST_POOL_ID = String(workerId);
+  globalThis.__vitest_environment__ = config.environment;
   globalThis.__vitest_worker__ = {
     ctx,
     moduleCache,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.25.8",
+  "version": "0.26.0",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -113,7 +113,8 @@
     "tinybench": "^2.3.1",
     "tinypool": "^0.3.0",
     "tinyspy": "^1.0.2",
-    "vite": "^3.0.0 || ^4.0.0"
+    "vite": "^3.0.0 || ^4.0.0",
+    "vite-node": "0.26.0"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.1",
@@ -154,8 +155,7 @@
     "strip-ansi": "^7.0.1",
     "typescript": "^4.9.4",
     "ws": "^8.11.0",
-    "@vitest/ui": "0.25.8",
-    "vite-node": "0.25.8"
+    "@vitest/ui": "0.26.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",