@tianshu-ai/tianshu 0.3.0

package/plugins/web-search/node_modules/vitest/dist/node.d.ts

@@ -0,0 +1,158 @@
+import { z as ResolvedConfig, y as UserConfig, v as VitestRunMode, H as VitestOptions, V as Vitest, A as ApiConfig, L as Logger, T as TestProject, J as TestSequencer, K as TestSpecification, M as TestModule, N as ModuleDiagnostic } from './chunks/reporters.d.BuRON0I0.js';
+export { B as BaseCoverageOptions, F as BenchmarkUserOptions, ag as BrowserBuiltinProvider, ah as BrowserCommand, ai as BrowserCommandContext, q as BrowserConfigOptions, aj as BrowserInstanceOption, ak as BrowserModuleMocker, al as BrowserOrchestrator, am as BrowserProvider, an as BrowserProviderInitializationOptions, ao as BrowserProviderModule, ap as BrowserProviderOptions, p as BrowserScript, aq as BrowserServerState, ar as BrowserServerStateSession, r as BuiltinEnvironment, as as CDPSession, u as CSSModuleScopeStrategy, m as CoverageIstanbulOptions, l as CoverageOptions, h as CoverageProvider, i as CoverageProviderModule, j as CoverageReporter, c as CoverageV8Options, n as CustomProviderOptions, D as DepsOptimizationOptions, a0 as HTMLOptions, I as InlineConfig, a2 as JUnitOptions, a1 as JsonOptions, O as OnServerRestartHandler, Q as OnTestsRerunHandler, at as ParentProjectBrowser, P as Pool, t as PoolOptions, Y as ProcessPool, au as ProjectBrowser, E as ProjectConfig, a as ReportContext, aA as ReportedHookContext, o as Reporter, ax as ResolveSnapshotPathHandler, ay as ResolveSnapshotPathHandlerContext, av as ResolvedBrowserOptions, R as ResolvedCoverageOptions, aw as ResolvedProjectConfig, $ as SerializedTestProject, a3 as TaskOptions, a4 as TestCase, a5 as TestCollection, a6 as TestDiagnostic, a7 as TestModuleState, a8 as TestResult, a9 as TestResultFailed, aa as TestResultPassed, ab as TestResultSkipped, aB as TestRunEndReason, az as TestRunResult, af as TestSequencerConstructor, ac as TestState, ad as TestSuite, ae as TestSuiteState, w as TransformModePatterns, x as TypecheckConfig, U as UserWorkspaceConfig, s as VitestEnvironment, X as VitestPackageInstaller, g as WatcherTriggerPattern, Z as WorkspaceSpec, _ as getFilePoolName } from './chunks/reporters.d.BuRON0I0.js';
+import * as vite from 'vite';
+import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1, LogLevel, LoggerOptions, Logger as Logger$1 } from 'vite';
+export { vite as Vite };
+export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
+import { IncomingMessage } from 'node:http';
+import { R as RuntimeRPC } from './chunks/worker.d.CUgIPz9V.js';
+export { T as TestExecutionType } from './chunks/worker.d.CUgIPz9V.js';
+import { Writable } from 'node:stream';
+export { V as VitestPluginContext } from './chunks/vite.d.BnOPPc46.js';
+export { W as WorkerContext } from './chunks/worker.d.uzWsCv9X.js';
+export { C as TypeCheckCollectLineNumbers, a as TypeCheckCollectLines, c as TypeCheckContext, T as TypeCheckErrorInfo, R as TypeCheckRawErrorsMap, b as TypeCheckRootAndTarget } from './chunks/global.d.MAmajcmJ.js';
+import { Debugger } from 'debug';
+export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions } from './chunks/environment.d.cL3nLXbE.js';
+export { SerializedError } from '@vitest/utils';
+export { b as RuntimeConfig } from './chunks/config.d.BKdhh7Zx.js';
+export { generateFileHash } from '@vitest/runner/utils';
+import 'node:console';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/utils/diff';
+import 'vite-node';
+import 'chai';
+import './chunks/benchmark.d.BwvBVTda.js';
+import 'tinybench';
+import './chunks/coverage.d.S9RMNXIe.js';
+import 'vite-node/client';
+import '@vitest/snapshot/manager';
+import 'node:fs';
+import 'node:worker_threads';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import '@vitest/snapshot/environment';
+
+declare function isValidApiRequest(config: ResolvedConfig, req: IncomingMessage): boolean;
+
+interface CliOptions extends UserConfig {
+	/**
+	* Override the watch mode
+	*/
+	run?: boolean;
+	/**
+	* Removes colors from the console output
+	*/
+	color?: boolean;
+	/**
+	* Output collected tests as JSON or to a file
+	*/
+	json?: string | boolean;
+	/**
+	* Output collected test files only
+	*/
+	filesOnly?: boolean;
+	/**
+	* Override vite config's configLoader from cli.
+	* Use `bundle` to bundle the config with esbuild or `runner` (experimental) to process it on the fly (default: `bundle`).
+	* This is only available with **vite version 6.1.0** and above.
+	* @experimental
+	*/
+	configLoader?: InlineConfig extends {
+		configLoader?: infer T
+	} ? T : never;
+}
+/**
+* Start Vitest programmatically
+*
+* Returns a Vitest instance if initialized successfully.
+*/
+declare function startVitest(mode: VitestRunMode, cliFilters?: string[], options?: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
+
+interface CliParseOptions {
+	allowUnknownOptions?: boolean;
+}
+declare function parseCLI(argv: string | string[], config?: CliParseOptions): {
+	filter: string[]
+	options: CliOptions
+};
+
+declare function resolveApiServerConfig<Options extends ApiConfig & UserConfig>(options: Options, defaultPort: number, parentApi?: ApiConfig, logger?: Logger): ApiConfig | undefined;
+
+declare function createVitest(mode: VitestRunMode, options: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
+
+declare class FilesNotFoundError extends Error {
+	code: string;
+	constructor(mode: "test" | "benchmark");
+}
+declare class GitNotFoundError extends Error {
+	code: string;
+	constructor();
+}
+
+/** @deprecated use `TestProject` instead */
+type GlobalSetupContext = TestProject;
+
+declare function VitestPlugin(options?: UserConfig, vitest?: Vitest): Promise<Plugin[]>;
+
+// this is only exported as a public function and not used inside vitest
+declare function resolveConfig(options?: UserConfig, viteOverrides?: UserConfig$1): Promise<{
+	vitestConfig: ResolvedConfig
+	viteConfig: ResolvedConfig$1
+}>;
+
+declare function resolveFsAllow(projectRoot: string, rootConfigFile: string | false | undefined): string[];
+
+interface MethodsOptions {
+	cacheFs?: boolean;
+	// do not report files
+	collect?: boolean;
+}
+declare function createMethodsRPC(project: TestProject, options?: MethodsOptions): RuntimeRPC;
+
+declare class BaseSequencer implements TestSequencer {
+	protected ctx: Vitest;
+	constructor(ctx: Vitest);
+	// async so it can be extended by other sequelizers
+	shard(files: TestSpecification[]): Promise<TestSpecification[]>;
+	// async so it can be extended by other sequelizers
+	sort(files: TestSpecification[]): Promise<TestSpecification[]>;
+}
+
+declare function registerConsoleShortcuts(ctx: Vitest, stdin: NodeJS.ReadStream | undefined, stdout: NodeJS.WriteStream | Writable): () => void;
+
+// This is copy-pasted and needs to be synced from time to time. Ideally, Vite's `createLogger` should accept a custom `console`
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/logger.ts?rgh-link-date=2024-10-16T23%3A29%3A19Z
+// When Vitest supports only Vite 6 and above, we can use Vite's `createLogger({ console })`
+// https://github.com/vitejs/vite/pull/18379
+declare function createViteLogger(console: Logger, level?: LogLevel, options?: LoggerOptions): Logger$1;
+
+declare const rootDir: string;
+declare const distDir: string;
+
+declare function createDebugger(namespace: `vitest:${string}`): Debugger | undefined;
+
+declare const version: string;
+
+/** @deprecated use `createViteServer` instead */
+declare const createServer: typeof vite.createServer;
+declare const createViteServer: typeof vite.createServer;
+
+/**
+* @deprecated Use `TestModule` instead
+*/
+declare const TestFile: typeof TestModule;
+
+/**
+* @deprecated Use `ModuleDiagnostic` instead
+*/
+type FileDiagnostic = ModuleDiagnostic;
+
+// rolldownVersion is exported only by rolldown-vite
+declare const rolldownVersion: string | undefined;
+
+export { ApiConfig, BaseSequencer, GitNotFoundError, ModuleDiagnostic, ResolvedConfig, TestFile, TestModule, TestProject, TestSequencer, TestSpecification, FilesNotFoundError as TestsNotFoundError, UserConfig, Vitest, VitestOptions, VitestPlugin, VitestRunMode, TestProject as WorkspaceProject, createDebugger, createMethodsRPC, createServer, createViteLogger, createViteServer, createVitest, distDir, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
+export type { CliParseOptions, FileDiagnostic, GlobalSetupContext };

package/plugins/web-search/node_modules/vitest/dist/node.js

@@ -0,0 +1,105 @@
+import * as vite from 'vite';
+import { resolveConfig as resolveConfig$1, mergeConfig } from 'vite';
+export { esbuildVersion, isCSSRequest, isFileServingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
+import { V as Vitest, a as VitestPlugin, T as TestModule } from './chunks/cli-api.DWGBtMmz.js';
+export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, e as createViteLogger, c as createVitest, i as isValidApiRequest, d as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.DWGBtMmz.js';
+export { p as parseCLI } from './chunks/cac.0BJqEUeA.js';
+import { r as resolveConfig$2 } from './chunks/coverage.DfSpMS-b.js';
+export { b as BaseSequencer, c as createMethodsRPC, g as getFilePoolName, a as resolveApiServerConfig } from './chunks/coverage.DfSpMS-b.js';
+import { slash, deepClone } from '@vitest/utils';
+import { f as findUp } from './chunks/index.X0nbfr6-.js';
+import { resolve } from 'pathe';
+import { c as configFiles } from './chunks/constants.DnKduX2e.js';
+export { distDir, rootDir } from './path.js';
+import createDebug from 'debug';
+export { generateFileHash } from '@vitest/runner/utils';
+import 'node:fs';
+import './chunks/coverage.DVF1vEu8.js';
+import 'node:path';
+import '@vitest/snapshot/manager';
+import 'vite-node/client';
+import 'vite-node/server';
+import './chunks/index.B521nVV-.js';
+import './chunks/index.VByaPkjc.js';
+import 'node:perf_hooks';
+import '@vitest/utils/source-map';
+import 'tinyrainbow';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import './chunks/typechecker.DRKU1-1g.js';
+import 'node:os';
+import 'tinyexec';
+import 'node:util';
+import 'node:fs/promises';
+import 'node:console';
+import 'node:stream';
+import 'node:module';
+import 'events';
+import 'https';
+import 'http';
+import 'net';
+import 'tls';
+import 'crypto';
+import 'stream';
+import 'url';
+import 'zlib';
+import 'buffer';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import 'node:crypto';
+import 'node:url';
+import 'picomatch';
+import 'tinyglobby';
+import 'vite-node/utils';
+import '@vitest/mocker/node';
+import './chunks/defaults.B7q_naMc.js';
+import 'magic-string';
+import './chunks/index.BCWujgDG.js';
+import 'node:assert';
+import '@vitest/utils/error';
+import 'node:readline';
+import 'node:process';
+import 'node:v8';
+import 'node:tty';
+import 'node:events';
+import 'tinypool';
+import 'node:worker_threads';
+import 'readline';
+
+// this is only exported as a public function and not used inside vitest
+async function resolveConfig(options = {}, viteOverrides = {}) {
+	const root = slash(resolve(options.root || process.cwd()));
+	const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
+	options.config = configPath;
+	const vitest = new Vitest("test", deepClone(options));
+	const config = await resolveConfig$1(mergeConfig({
+		configFile: configPath,
+		mode: options.mode || "test",
+		plugins: [await VitestPlugin(options, vitest)]
+	}, mergeConfig(viteOverrides, { root: options.root })), "serve");
+	// Reflect just to avoid type error
+	const updatedOptions = Reflect.get(config, "_vitest");
+	const vitestConfig = resolveConfig$2(vitest, updatedOptions, config);
+	await vitest.close();
+	return {
+		viteConfig: config,
+		vitestConfig
+	};
+}
+
+function createDebugger(namespace) {
+	const debug = createDebug(namespace);
+	if (debug.enabled) return debug;
+}
+
+const version = Vitest.version;
+/** @deprecated use `createViteServer` instead */
+const createServer = vite.createServer;
+const createViteServer = vite.createServer;
+/**
+* @deprecated Use `TestModule` instead
+*/
+const TestFile = TestModule;
+// rolldownVersion is exported only by rolldown-vite
+const rolldownVersion = vite.rolldownVersion;
+
+export { TestFile, VitestPlugin, createDebugger, createServer, createViteServer, resolveConfig, rolldownVersion, version };

package/plugins/web-search/node_modules/vitest/dist/path.js

@@ -0,0 +1,7 @@
+import { resolve } from 'node:path';
+import url from 'node:url';
+
+const rootDir = resolve(url.fileURLToPath(import.meta.url), "../../");
+const distDir = resolve(url.fileURLToPath(import.meta.url), "../../dist");
+
+export { distDir, rootDir };

package/plugins/web-search/node_modules/vitest/dist/reporters.d.ts

@@ -0,0 +1,25 @@
+export { aQ as BaseReporter, aC as BasicReporter, aR as BenchmarkBuiltinReporters, aD as BenchmarkReporter, aE as BenchmarkReportsMap, aS as BuiltinReporterOptions, aT as BuiltinReporters, aF as DefaultReporter, aG as DotReporter, aH as GithubActionsReporter, aI as HangingProcessReporter, aK as JUnitReporter, aU as JsonAssertionResult, aJ as JsonReporter, aV as JsonTestResult, aW as JsonTestResults, aA as ReportedHookContext, o as Reporter, aL as ReportersMap, aM as TapFlatReporter, aN as TapReporter, aB as TestRunEndReason, aO as VerboseBenchmarkReporter, aP as VerboseReporter } from './chunks/reporters.d.BuRON0I0.js';
+import '@vitest/runner';
+import './chunks/environment.d.cL3nLXbE.js';
+import 'vitest/optional-types.js';
+import '@vitest/utils';
+import 'node:stream';
+import 'vite';
+import 'node:console';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import './chunks/worker.d.CUgIPz9V.js';
+import 'vite-node';
+import './chunks/config.d.BKdhh7Zx.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import '@vitest/utils/diff';
+import 'chai';
+import './chunks/benchmark.d.BwvBVTda.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import './chunks/coverage.d.S9RMNXIe.js';
+import 'vite-node/client';
+import '@vitest/snapshot/manager';
+import 'node:fs';

package/plugins/web-search/node_modules/vitest/dist/reporters.js

@@ -0,0 +1,23 @@
+export { B as BasicReporter, D as DefaultReporter, a as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, b as JUnitReporter, J as JsonReporter, R as ReportersMap, T as TapFlatReporter, c as TapReporter, V as VerboseReporter } from './chunks/index.VByaPkjc.js';
+export { B as BenchmarkReporter, a as BenchmarkReportsMap, V as VerboseBenchmarkReporter } from './chunks/index.BCWujgDG.js';
+import 'node:perf_hooks';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import '@vitest/utils/source-map';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import './chunks/typechecker.DRKU1-1g.js';
+import 'node:os';
+import 'tinyexec';
+import './path.js';
+import 'node:path';
+import 'node:url';
+import 'vite';
+import 'node:util';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:console';
+import 'node:stream';
+import 'node:module';

package/plugins/web-search/node_modules/vitest/dist/runners.d.ts

@@ -0,0 +1,46 @@
+import * as tinybench from 'tinybench';
+import { VitestRunner, VitestRunnerImportSource, Suite, File, Task, CancelReason, Test, TestContext, ImportDuration } from '@vitest/runner';
+export { VitestRunner } from '@vitest/runner';
+import { a as SerializedConfig } from './chunks/config.d.BKdhh7Zx.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/snapshot/environment';
+import '@vitest/utils/diff';
+
+declare class NodeBenchmarkRunner implements VitestRunner {
+	config: SerializedConfig;
+	private __vitest_executor;
+	constructor(config: SerializedConfig);
+	importTinybench(): Promise<typeof tinybench>;
+	importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+	runSuite(suite: Suite): Promise<void>;
+	runTask(): Promise<void>;
+}
+
+declare class VitestTestRunner implements VitestRunner {
+	config: SerializedConfig;
+	private snapshotClient;
+	private workerState;
+	private __vitest_executor;
+	private cancelRun;
+	private assertionsErrors;
+	pool: string;
+	constructor(config: SerializedConfig);
+	importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+	onCollectStart(file: File): void;
+	onCleanupWorkerContext(listener: () => unknown): void;
+	onAfterRunFiles(): void;
+	getWorkerContext(): Record<string, unknown>;
+	onAfterRunSuite(suite: Suite): Promise<void>;
+	onAfterRunTask(test: Task): void;
+	cancel(_reason: CancelReason): void;
+	injectValue(key: string): any;
+	onBeforeRunTask(test: Task): Promise<void>;
+	onBeforeRunSuite(suite: Suite): Promise<void>;
+	onBeforeTryTask(test: Task): void;
+	onAfterTryTask(test: Test): void;
+	extendTaskContext(context: TestContext): TestContext;
+	getImportDurations(): Record<string, ImportDuration>;
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

package/plugins/web-search/node_modules/vitest/dist/runners.js

@@ -0,0 +1,235 @@
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
+import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.CYdenmiT.js';
+import { g as getWorkerState } from './chunks/utils.XdZDrNZV.js';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { getTests, getNames, getTestName } from '@vitest/runner/utils';
+import { normalize } from 'pathe';
+import { g as getSnapshotClient, i as inject, c as createExpect, v as vi } from './chunks/vi.bdSIJ99Y.js';
+import { r as rpc } from './chunks/rpc.-pEldfrD.js';
+import 'chai';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/spy';
+import '@vitest/utils/source-map';
+import './chunks/date.Bq6ZW5rf.js';
+import './chunks/index.B521nVV-.js';
+
+function createBenchmarkResult(name) {
+	return {
+		name,
+		rank: 0,
+		rme: 0,
+		samples: []
+	};
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+	const { Task, Bench } = await runner.importTinybench();
+	const start = performance.now();
+	const benchmarkGroup = [];
+	const benchmarkSuiteGroup = [];
+	for (const task of suite.tasks) {
+		if (task.mode !== "run" && task.mode !== "queued") continue;
+		if (task.meta?.benchmark) benchmarkGroup.push(task);
+		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
+	}
+	// run sub suites sequentially
+	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+	if (benchmarkGroup.length) {
+		const defer = createDefer();
+		suite.result = {
+			state: "run",
+			startTime: start,
+			benchmark: createBenchmarkResult(suite.name)
+		};
+		updateTask$1("suite-prepare", suite);
+		const addBenchTaskListener = (task, benchmark) => {
+			task.addEventListener("complete", (e) => {
+				const task = e.task;
+				const taskRes = task.result;
+				const result = benchmark.result.benchmark;
+				benchmark.result.state = "pass";
+				Object.assign(result, taskRes);
+				// compute extra stats and free raw samples as early as possible
+				const samples = result.samples;
+				result.sampleCount = samples.length;
+				result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+				if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
+				updateTask$1("test-finished", benchmark);
+			}, { once: true });
+			task.addEventListener("error", (e) => {
+				const task = e.task;
+				defer.reject(benchmark ? task.result.error : e);
+			}, { once: true });
+		};
+		benchmarkGroup.forEach((benchmark) => {
+			const options = getBenchOptions(benchmark);
+			const benchmarkInstance = new Bench(options);
+			const benchmarkFn = getBenchFn(benchmark);
+			benchmark.result = {
+				state: "run",
+				startTime: start,
+				benchmark: createBenchmarkResult(benchmark.name)
+			};
+			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+			benchmarkTasks.set(benchmark, task);
+			addBenchTaskListener(task, benchmark);
+		});
+		const { setTimeout } = getSafeTimers();
+		const tasks = [];
+		for (const benchmark of benchmarkGroup) {
+			const task = benchmarkTasks.get(benchmark);
+			updateTask$1("test-prepare", benchmark);
+			await task.warmup();
+			tasks.push([await new Promise((resolve) => setTimeout(async () => {
+				resolve(await task.run());
+			})), benchmark]);
+		}
+		suite.result.duration = performance.now() - start;
+		suite.result.state = "pass";
+		updateTask$1("suite-finished", suite);
+		defer.resolve(null);
+		await defer;
+	}
+	function updateTask$1(event, task) {
+		updateTask(event, task, runner);
+	}
+}
+class NodeBenchmarkRunner {
+	__vitest_executor;
+	constructor(config) {
+		this.config = config;
+	}
+	async importTinybench() {
+		return await import('tinybench');
+	}
+	importFile(filepath, source) {
+		if (source === "setup") getWorkerState().moduleCache.delete(filepath);
+		return this.__vitest_executor.executeId(filepath);
+	}
+	async runSuite(suite) {
+		await runBenchmarkSuite(suite, this);
+	}
+	async runTask() {
+		throw new Error("`test()` and `it()` is only available in test mode.");
+	}
+}
+
+// worker context is shared between all tests
+const workerContext = Object.create(null);
+class VitestTestRunner {
+	snapshotClient = getSnapshotClient();
+	workerState = getWorkerState();
+	__vitest_executor;
+	cancelRun = false;
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	pool = this.workerState.ctx.pool;
+	constructor(config) {
+		this.config = config;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") this.workerState.moduleCache.delete(filepath);
+		return this.__vitest_executor.executeId(filepath);
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear();
+		this.workerState.current = void 0;
+	}
+	getWorkerContext() {
+		return workerContext;
+	}
+	async onAfterRunSuite(suite) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+		if (suite.mode !== "skip" && "filepath" in suite) {
+			// mark snapshots in skipped tests as not obsolete
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
+			}
+			const result = await this.snapshotClient.finish(suite.file.filepath);
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+		this.workerState.current = test.suite || test.file;
+	}
+	cancel(_reason) {
+		this.cancelRun = true;
+	}
+	injectValue(key) {
+		// inject has a very limiting type controlled by ProvidedContext
+		// some tests override it which causes the build to fail
+		return inject(key);
+	}
+	async onBeforeRunTask(test) {
+		if (this.cancelRun) test.mode = "skip";
+		if (test.mode !== "run" && test.mode !== "queued") return;
+		this.workerState.current = test;
+	}
+	async onBeforeRunSuite(suite) {
+		if (this.cancelRun) suite.mode = "skip";
+		// initialize snapshot state before running file suite
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+		this.workerState.current = suite;
+	}
+	onBeforeTryTask(test) {
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(test) {
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+	}
+	extendTaskContext(context) {
+		// create error during the test initialization so we have a nice stack trace
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, new Error("expected any number of assertion, but got none"));
+		let _expect;
+		Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} });
+		Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} });
+		return context;
+	}
+	getImportDurations() {
+		const entries = [...this.workerState.moduleExecutionInfo?.entries() ?? []];
+		return Object.fromEntries(entries.map(([filepath, { duration, selfTime }]) => [normalize(filepath), {
+			selfTime,
+			totalTime: duration
+		}]));
+	}
+}
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	// since each function calls another, we can just call one
+	if (restoreMocks) vi.restoreAllMocks();
+	else if (mockReset) vi.resetAllMocks();
+	else if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

package/plugins/web-search/node_modules/vitest/dist/snapshot.d.ts

@@ -0,0 +1,9 @@
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+export { SnapshotEnvironment } from '@vitest/snapshot/environment';
+
+declare class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+	getHeader(): string;
+	resolvePath(filepath: string): Promise<string>;
+}
+
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment };

package/plugins/web-search/node_modules/vitest/dist/snapshot.js

@@ -0,0 +1,4 @@
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.fjCdwEIl.js';
+import '@vitest/snapshot/environment';
+import './chunks/utils.XdZDrNZV.js';
+import '@vitest/utils';

package/plugins/web-search/node_modules/vitest/dist/spy.js

@@ -0,0 +1 @@
+export * from '@vitest/spy';

package/plugins/web-search/node_modules/vitest/dist/suite.d.ts

@@ -0,0 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.d.FvehnV49.js';
+export { VitestRunner, VitestRunnerConfig, createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
+export { createChainable } from '@vitest/runner/utils';
+import './chunks/benchmark.d.BwvBVTda.js';
+import 'tinybench';

package/plugins/web-search/node_modules/vitest/dist/suite.js

@@ -0,0 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.CYdenmiT.js';
+export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
+export { createChainable } from '@vitest/runner/utils';
+import '@vitest/utils';
+import './chunks/utils.XdZDrNZV.js';