vitest 3.1.0-beta.1 → 3.1.0-beta.2

package/dist/chunks/index.uXkkC4xl.js

@@ -1,111 +0,0 @@
-import * as chai from 'chai';
-import { resolve } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.CPvtqi8q.js';
-import { distDir } from '../path.js';
-import { r as rpc } from './rpc.TVf73xOu.js';
-import { g as getWorkerState } from './utils.C8RiOc4B.js';
-
-function setupChaiConfig(config) {
-  Object.assign(chai.config, config);
-}
-
-async function resolveSnapshotEnvironment(config, executor) {
-  if (!config.snapshotEnvironment) {
-    const { VitestNodeSnapshotEnvironment } = await import('./node.AKq966Jp.js');
-    return new VitestNodeSnapshotEnvironment();
-  }
-  const mod = await executor.executeId(config.snapshotEnvironment);
-  if (typeof mod.default !== "object" || !mod.default) {
-    throw new Error(
-      "Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`"
-    );
-  }
-  return mod.default;
-}
-
-const runnersFile = resolve(distDir, "runners.js");
-async function getTestRunnerConstructor(config, executor) {
-  if (!config.runner) {
-    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
-    return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-  }
-  const mod = await executor.executeId(config.runner);
-  if (!mod.default && typeof mod.default !== "function") {
-    throw new Error(
-      `Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`
-    );
-  }
-  return mod.default;
-}
-async function resolveTestRunner(config, executor) {
-  const TestRunner = await getTestRunnerConstructor(config, executor);
-  const testRunner = new TestRunner(config);
-  Object.defineProperty(testRunner, "__vitest_executor", {
-    value: executor,
-    enumerable: false,
-    configurable: false
-  });
-  if (!testRunner.config) {
-    testRunner.config = config;
-  }
-  if (!testRunner.importFile) {
-    throw new Error('Runner must implement "importFile" method.');
-  }
-  const [diffOptions] = await Promise.all([
-    loadDiffConfig(config, executor),
-    loadSnapshotSerializers(config, executor)
-  ]);
-  testRunner.config.diffOptions = diffOptions;
-  const originalOnTaskUpdate = testRunner.onTaskUpdate;
-  testRunner.onTaskUpdate = async (task, events) => {
-    const p = rpc().onTaskUpdate(task, events);
-    await originalOnTaskUpdate?.call(testRunner, task, events);
-    return p;
-  };
-  const originalOnCollectStart = testRunner.onCollectStart;
-  testRunner.onCollectStart = async (file) => {
-    await rpc().onQueued(file);
-    await originalOnCollectStart?.call(testRunner, file);
-  };
-  const originalOnCollected = testRunner.onCollected;
-  testRunner.onCollected = async (files) => {
-    const state = getWorkerState();
-    files.forEach((file) => {
-      file.prepareDuration = state.durations.prepare;
-      file.environmentLoad = state.durations.environment;
-      state.durations.prepare = 0;
-      state.durations.environment = 0;
-    });
-    rpc().onCollected(files);
-    await originalOnCollected?.call(testRunner, files);
-  };
-  const originalOnAfterRun = testRunner.onAfterRunFiles;
-  testRunner.onAfterRunFiles = async (files) => {
-    const state = getWorkerState();
-    const coverage = await takeCoverageInsideWorker(config.coverage, executor);
-    if (coverage) {
-      rpc().onAfterSuiteRun({
-        coverage,
-        testFiles: files.map((file) => file.name).sort(),
-        transformMode: state.environment.transformMode,
-        projectName: state.ctx.projectName
-      });
-    }
-    await originalOnAfterRun?.call(testRunner, files);
-  };
-  const originalOnAfterRunTask = testRunner.onAfterRunTask;
-  testRunner.onAfterRunTask = async (test) => {
-    if (config.bail && test.result?.state === "fail") {
-      const previousFailures = await rpc().getCountOfFailedTests();
-      const currentFailures = 1 + previousFailures;
-      if (currentFailures >= config.bail) {
-        rpc().onCancel("test-failure");
-        testRunner.onCancel?.("test-failure");
-      }
-    }
-    await originalOnAfterRunTask?.call(testRunner, test);
-  };
-  return testRunner;
-}
-
-export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

package/dist/chunks/inspector.DKLceBVD.js

@@ -1,54 +0,0 @@
-import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-
-const __require = createRequire(import.meta.url);
-let inspector;
-let session;
-function setupInspect(ctx) {
-  const config = ctx.config;
-  const isEnabled = config.inspector.enabled;
-  if (isEnabled) {
-    inspector = __require("node:inspector");
-    const isOpen = inspector.url() !== void 0;
-    if (!isOpen) {
-      inspector.open(
-        config.inspector.port,
-        config.inspector.host,
-        config.inspector.waitForDebugger
-      );
-      if (config.inspectBrk) {
-        const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
-        if (firstTestFile) {
-          session = new inspector.Session();
-          session.connect();
-          session.post("Debugger.enable");
-          session.post("Debugger.setBreakpointByUrl", {
-            lineNumber: 0,
-            url: pathToFileURL(firstTestFile)
-          });
-        }
-      }
-    }
-  }
-  const keepOpen = shouldKeepOpen(config);
-  return function cleanup() {
-    if (isEnabled && !keepOpen && inspector) {
-      inspector.close();
-      session?.disconnect();
-    }
-  };
-}
-function closeInspector(config) {
-  const keepOpen = shouldKeepOpen(config);
-  if (inspector && !keepOpen) {
-    inspector.close();
-    session?.disconnect();
-  }
-}
-function shouldKeepOpen(config) {
-  const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread;
-  const isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
-  return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
-}
-
-export { closeInspector as c, setupInspect as s };

package/dist/chunks/node.AKq966Jp.js

@@ -1,15 +0,0 @@
-import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.C8RiOc4B.js';
-import '@vitest/utils';
-
-class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
-  getHeader() {
-    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
-  }
-  resolvePath(filepath) {
-    const rpc = getWorkerState().rpc;
-    return rpc.resolveSnapshotPath(filepath);
-  }
-}
-
-export { VitestNodeSnapshotEnvironment };

package/dist/chunks/rpc.TVf73xOu.js

@@ -1,102 +0,0 @@
-import { getSafeTimers } from '@vitest/utils';
-import { c as createBirpc } from './index.68735LiX.js';
-import { g as getWorkerState } from './utils.C8RiOc4B.js';
-
-const { get } = Reflect;
-function withSafeTimers(fn) {
-  const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
-  const currentSetTimeout = globalThis.setTimeout;
-  const currentClearTimeout = globalThis.clearTimeout;
-  const currentSetImmediate = globalThis.setImmediate;
-  const currentClearImmediate = globalThis.clearImmediate;
-  const currentNextTick = globalThis.process?.nextTick;
-  try {
-    globalThis.setTimeout = setTimeout;
-    globalThis.clearTimeout = clearTimeout;
-    globalThis.setImmediate = setImmediate;
-    globalThis.clearImmediate = clearImmediate;
-    if (globalThis.process) {
-      globalThis.process.nextTick = nextTick;
-    }
-    const result = fn();
-    return result;
-  } finally {
-    globalThis.setTimeout = currentSetTimeout;
-    globalThis.clearTimeout = currentClearTimeout;
-    globalThis.setImmediate = currentSetImmediate;
-    globalThis.clearImmediate = currentClearImmediate;
-    if (globalThis.process) {
-      nextTick(() => {
-        globalThis.process.nextTick = currentNextTick;
-      });
-    }
-  }
-}
-const promises = /* @__PURE__ */ new Set();
-async function rpcDone() {
-  if (!promises.size) {
-    return;
-  }
-  const awaitable = Array.from(promises);
-  return Promise.all(awaitable);
-}
-function createRuntimeRpc(options) {
-  let setCancel = (_reason) => {
-  };
-  const onCancel = new Promise((resolve) => {
-    setCancel = resolve;
-  });
-  const rpc2 = createSafeRpc(
-    createBirpc(
-      {
-        onCancel: setCancel
-      },
-      {
-        eventNames: [
-          "onUserConsoleLog",
-          "onCollected",
-          "onCancel"
-        ],
-        onTimeoutError(functionName, args) {
-          let message = `[vitest-worker]: Timeout calling "${functionName}"`;
-          if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") {
-            message += ` with "${JSON.stringify(args)}"`;
-          }
-          if (functionName === "onUnhandledError") {
-            message += ` with "${args[0]?.message || args[0]}"`;
-          }
-          throw new Error(message);
-        },
-        ...options
-      }
-    )
-  );
-  return {
-    rpc: rpc2,
-    onCancel
-  };
-}
-function createSafeRpc(rpc2) {
-  return new Proxy(rpc2, {
-    get(target, p, handler) {
-      const sendCall = get(target, p, handler);
-      const safeSendCall = (...args) => withSafeTimers(async () => {
-        const result = sendCall(...args);
-        promises.add(result);
-        try {
-          return await result;
-        } finally {
-          promises.delete(result);
-        }
-      });
-      safeSendCall.asEvent = sendCall.asEvent;
-      return safeSendCall;
-    }
-  });
-}
-function rpc() {
-  const { rpc: rpc2 } = getWorkerState();
-  return rpc2;
-}
-
-export { rpcDone as a, createRuntimeRpc as c, rpc as r };

package/dist/chunks/run-once.2ogXb3JV.js

@@ -1,28 +0,0 @@
-import { g as getWorkerState } from './utils.C8RiOc4B.js';
-
-const filesCount = /* @__PURE__ */ new Map();
-const cache = /* @__PURE__ */ new Map();
-function runOnce(fn, key) {
-  const filepath = getWorkerState().filepath || "__unknown_files__";
-  if (!key) {
-    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
-    key = String(filesCount.get(filepath));
-  }
-  const id = `${filepath}:${key}`;
-  if (!cache.has(id)) {
-    cache.set(id, fn());
-  }
-  return cache.get(id);
-}
-function isFirstRun() {
-  let firstRun = false;
-  runOnce(() => {
-    firstRun = true;
-  }, "__vitest_first_run__");
-  return firstRun;
-}
-function resetRunOnceCounter() {
-  filesCount.clear();
-}
-
-export { runOnce as a, isFirstRun as i, resetRunOnceCounter as r };

package/dist/chunks/runBaseTests.BVrL_ow3.js

@@ -1,142 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.uXkkC4xl.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.CPvtqi8q.js';
-import { a as globalExpect, v as vi } from './vi.nSCvwQ7l.js';
-import { c as closeInspector } from './inspector.DKLceBVD.js';
-import { createRequire } from 'node:module';
-import timers from 'node:timers';
-import timersPromises from 'node:timers/promises';
-import util from 'node:util';
-import { getSafeTimers } from '@vitest/utils';
-import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
-import { installSourcemapsSupport } from 'vite-node/source-map';
-import { V as VitestIndex } from './index.D7Ny8f_s.js';
-import { g as getWorkerState, r as resetModules } from './utils.C8RiOc4B.js';
-import 'chai';
-import 'node:path';
-import '../path.js';
-import 'node:url';
-import './rpc.TVf73xOu.js';
-import './index.68735LiX.js';
-import './coverage.A3sS5-Wm.js';
-import '@vitest/snapshot';
-import './run-once.2ogXb3JV.js';
-import '@vitest/expect';
-import '@vitest/runner/utils';
-import './_commonjsHelpers.BFTU3MAI.js';
-import '@vitest/utils/error';
-import '@vitest/spy';
-import '@vitest/utils/source-map';
-import './date.W2xKR2qe.js';
-import './benchmark.DL72EVN-.js';
-import 'expect-type';
-
-let globalSetup = false;
-async function setupGlobalEnv(config, { environment }, executor) {
-  await setupCommonEnv(config);
-  Object.defineProperty(globalThis, "__vitest_index__", {
-    value: VitestIndex,
-    enumerable: false
-  });
-  const state = getWorkerState();
-  if (!state.config.snapshotOptions.snapshotEnvironment) {
-    state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, executor);
-  }
-  if (globalSetup) {
-    return;
-  }
-  globalSetup = true;
-  if (environment.transformMode === "web") {
-    const _require = createRequire(import.meta.url);
-    _require.extensions[".css"] = resolveCss;
-    _require.extensions[".scss"] = resolveCss;
-    _require.extensions[".sass"] = resolveCss;
-    _require.extensions[".less"] = resolveCss;
-    KNOWN_ASSET_TYPES.forEach((type) => {
-      _require.extensions[`.${type}`] = resolveAsset;
-    });
-    process.env.SSR = "";
-  } else {
-    process.env.SSR = "1";
-  }
-  globalThis.__vitest_required__ = {
-    util,
-    timers,
-    timersPromises
-  };
-  installSourcemapsSupport({
-    getSourceMap: (source) => state.moduleCache.getSourceMap(source)
-  });
-  if (!config.disableConsoleIntercept) {
-    await setupConsoleLogSpy();
-  }
-}
-function resolveCss(mod) {
-  mod.exports = "";
-}
-function resolveAsset(mod, url) {
-  mod.exports = url;
-}
-async function setupConsoleLogSpy() {
-  const { createCustomConsole } = await import('./console.CN7AiMGV.js');
-  globalThis.console = createCustomConsole();
-}
-async function withEnv({ environment }, options, fn) {
-  globalThis.__vitest_environment__ = environment.name;
-  globalExpect.setState({
-    environment: environment.name
-  });
-  const env = await environment.setup(globalThis, options);
-  try {
-    await fn();
-  } finally {
-    const { setTimeout } = getSafeTimers();
-    await new Promise((resolve) => setTimeout(resolve));
-    await env.teardown(globalThis);
-  }
-}
-
-async function run(method, files, config, environment, executor) {
-  const workerState = getWorkerState();
-  const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
-  const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
-  const isolate = isIsolatedThreads || isIsolatedForks;
-  await setupGlobalEnv(config, environment, executor);
-  await startCoverageInsideWorker(config.coverage, executor, { isolate });
-  if (config.chaiConfig) {
-    setupChaiConfig(config.chaiConfig);
-  }
-  const runner = await resolveTestRunner(config, executor);
-  workerState.onCancel.then((reason) => {
-    closeInspector(config);
-    runner.onCancel?.(reason);
-  });
-  workerState.durations.prepare = performance.now() - workerState.durations.prepare;
-  workerState.durations.environment = performance.now();
-  await withEnv(
-    environment,
-    environment.options || config.environmentOptions || {},
-    async () => {
-      workerState.durations.environment = performance.now() - workerState.durations.environment;
-      for (const file of files) {
-        if (isolate) {
-          executor.mocker.reset();
-          resetModules(workerState.moduleCache, true);
-        }
-        workerState.filepath = file.filepath;
-        if (method === "run") {
-          await startTests([file], runner);
-        } else {
-          await collectTests([file], runner);
-        }
-        vi.resetConfig();
-        vi.restoreAllMocks();
-      }
-      await stopCoverageInsideWorker(config.coverage, executor, { isolate });
-    }
-  );
-  workerState.environmentTeardownRun = true;
-}
-
-export { run };

package/dist/chunks/setup-common.CPvtqi8q.js

@@ -1,96 +0,0 @@
-import { r as resolveCoverageProviderModule } from './coverage.A3sS5-Wm.js';
-import { addSerializer } from '@vitest/snapshot';
-import { setSafeTimers } from '@vitest/utils';
-import { r as resetRunOnceCounter } from './run-once.2ogXb3JV.js';
-
-async function startCoverageInsideWorker(options, loader, runtimeOptions) {
-  const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule) {
-    return coverageModule.startCoverage?.(runtimeOptions);
-  }
-  return null;
-}
-async function takeCoverageInsideWorker(options, loader) {
-  const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule) {
-    return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
-  }
-  return null;
-}
-async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
-  const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule) {
-    return coverageModule.stopCoverage?.(runtimeOptions);
-  }
-  return null;
-}
-
-let globalSetup = false;
-async function setupCommonEnv(config) {
-  resetRunOnceCounter();
-  setupDefines(config.defines);
-  setupEnv(config.env);
-  if (globalSetup) {
-    return;
-  }
-  globalSetup = true;
-  setSafeTimers();
-  if (config.globals) {
-    (await import('./globals.BEpDe-k3.js')).registerApiGlobally();
-  }
-}
-function setupDefines(defines) {
-  for (const key in defines) {
-    globalThis[key] = defines[key];
-  }
-}
-function setupEnv(env) {
-  if (typeof process === "undefined") {
-    return;
-  }
-  const { PROD, DEV, ...restEnvs } = env;
-  process.env.PROD = PROD ? "1" : "";
-  process.env.DEV = DEV ? "1" : "";
-  for (const key in restEnvs) {
-    process.env[key] = env[key];
-  }
-}
-async function loadDiffConfig(config, executor) {
-  if (typeof config.diff === "object") {
-    return config.diff;
-  }
-  if (typeof config.diff !== "string") {
-    return;
-  }
-  const diffModule = await executor.executeId(config.diff);
-  if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) {
-    return diffModule.default;
-  } else {
-    throw new Error(
-      `invalid diff config file ${config.diff}. Must have a default export with config object`
-    );
-  }
-}
-async function loadSnapshotSerializers(config, executor) {
-  const files = config.snapshotSerializers;
-  const snapshotSerializers = await Promise.all(
-    files.map(async (file) => {
-      const mo = await executor.executeId(file);
-      if (!mo || typeof mo.default !== "object" || mo.default === null) {
-        throw new Error(
-          `invalid snapshot serializer file ${file}. Must export a default object`
-        );
-      }
-      const config2 = mo.default;
-      if (typeof config2.test !== "function" || typeof config2.serialize !== "function" && typeof config2.print !== "function") {
-        throw new TypeError(
-          `invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`
-        );
-      }
-      return config2;
-    })
-  );
-  snapshotSerializers.forEach((serializer) => addSerializer(serializer));
-}
-
-export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/utils.C8RiOc4B.js

@@ -1,77 +0,0 @@
-import { getSafeTimers } from '@vitest/utils';
-
-const NAME_WORKER_STATE = "__vitest_worker__";
-function getWorkerState() {
-  const workerState = globalThis[NAME_WORKER_STATE];
-  if (!workerState) {
-    const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
-    throw new Error(errorMsg);
-  }
-  return workerState;
-}
-function provideWorkerState(context, state) {
-  Object.defineProperty(context, NAME_WORKER_STATE, {
-    value: state,
-    configurable: true,
-    writable: true,
-    enumerable: false
-  });
-  return state;
-}
-function getCurrentEnvironment() {
-  const state = getWorkerState();
-  return state?.environment.name;
-}
-function isChildProcess() {
-  return typeof process !== "undefined" && !!process.send;
-}
-function setProcessTitle(title) {
-  try {
-    process.title = `node (${title})`;
-  } catch {
-  }
-}
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
-    }
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout } = getSafeTimers();
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = getWorkerState();
-  const promises = [];
-  let resolvingCount = 0;
-  for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated) {
-      promises.push(mod.promise);
-    }
-    if (mod.resolving) {
-      resolvingCount++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
-  }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
-}
-
-export { getCurrentEnvironment as a, getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, setProcessTitle as s, waitForImportsToResolve as w };

package/dist/chunks/utils.Cn0zI1t3.js

@@ -1,68 +0,0 @@
-import { parseRegexp } from '@vitest/utils';
-
-const REGEXP_WRAP_PREFIX = "$$vitest:";
-const processSend = process.send?.bind(process);
-const processOn = process.on?.bind(process);
-const processOff = process.off?.bind(process);
-const dispose = [];
-function createThreadsRpcOptions({
-  port
-}) {
-  return {
-    post: (v) => {
-      port.postMessage(v);
-    },
-    on: (fn) => {
-      port.addListener("message", fn);
-    }
-  };
-}
-function disposeInternalListeners() {
-  for (const fn of dispose) {
-    try {
-      fn();
-    } catch {
-    }
-  }
-  dispose.length = 0;
-}
-function createForksRpcOptions(nodeV8) {
-  return {
-    serialize: nodeV8.serialize,
-    deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
-    post(v) {
-      processSend(v);
-    },
-    on(fn) {
-      const handler = (message, ...extras) => {
-        if (message?.__tinypool_worker_message__) {
-          return;
-        }
-        return fn(message, ...extras);
-      };
-      processOn("message", handler);
-      dispose.push(() => processOff("message", handler));
-    }
-  };
-}
-function unwrapSerializableConfig(config) {
-  if (config.testNamePattern && typeof config.testNamePattern === "string") {
-    const testNamePattern = config.testNamePattern;
-    if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) {
-      config.testNamePattern = parseRegexp(
-        testNamePattern.slice(REGEXP_WRAP_PREFIX.length)
-      );
-    }
-  }
-  if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
-    const { keys, original } = config.defines;
-    const defines = {};
-    for (const key of keys) {
-      defines[key] = original[key];
-    }
-    config.defines = defines;
-  }
-  return config;
-}
-
-export { createThreadsRpcOptions as a, createForksRpcOptions as c, disposeInternalListeners as d, unwrapSerializableConfig as u };