@tianshu-ai/tianshu 0.3.0

package/plugins/web-search/node_modules/vitest/dist/chunks/worker.d.CUgIPz9V.d.ts

@@ -0,0 +1,176 @@
+import { File, TestAnnotation, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
+import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
+import { a as SerializedConfig } from './config.d.BKdhh7Zx.js';
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.cL3nLXbE.js';
+import { SnapshotResult } from '@vitest/snapshot';
+
+type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
+interface ChannelOptions {
+    /**
+     * Function to post raw message
+     */
+    post: (data: any, ...extras: any[]) => any | Promise<any>;
+    /**
+     * Listener to receive raw message
+     */
+    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Clear the listener when `$close` is called
+     */
+    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
+    /**
+     * Custom function to serialize data
+     *
+     * by default it passes the data as-is
+     */
+    serialize?: (data: any) => any;
+    /**
+     * Custom function to deserialize data
+     *
+     * by default it passes the data as-is
+     */
+    deserialize?: (data: any) => any;
+    /**
+     * Call the methods with the RPC context or the original functions object
+     */
+    bind?: 'rpc' | 'functions';
+}
+interface EventOptions<Remote> {
+    /**
+     * Names of remote functions that do not need response.
+     */
+    eventNames?: (keyof Remote)[];
+    /**
+     * Maximum timeout for waiting for response, in milliseconds.
+     *
+     * @default 60_000
+     */
+    timeout?: number;
+    /**
+     * Custom resolver to resolve function to be called
+     *
+     * For advanced use cases only
+     */
+    resolver?: BirpcResolver;
+    /**
+     * Custom error handler
+     *
+     * @deprecated use `onFunctionError` and `onGeneralError` instead
+     */
+    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred in local functions being called
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
+    /**
+     * Custom error handler for errors occurred during serialization or messsaging
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
+    /**
+     * Custom error handler for timeouts
+     *
+     * @returns `true` to prevent the error from being thrown
+     */
+    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+    /**
+     * Send event without asking for response
+     */
+    asEvent: (...args: ArgumentsType<T>) => void;
+};
+type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+} & {
+    $functions: LocalFunctions;
+    $close: (error?: Error) => void;
+    $closed: boolean;
+};
+
+interface RuntimeRPC {
+	fetch: (id: string, transformMode: TransformMode) => Promise<{
+		externalize?: string
+		id?: string
+	}>;
+	transform: (id: string, transformMode: TransformMode) => Promise<{
+		code?: string
+	}>;
+	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+		external?: boolean | "absolute" | "relative"
+		id: string
+		/** @deprecated */
+		meta?: Record<string, any> | null
+		/** @deprecated */
+		moduleSideEffects?: boolean | "no-treeshake" | null
+		/** @deprecated */
+		syntheticNamedExports?: boolean | string | null
+	} | null>;
+	/**
+	* @deprecated unused
+	*/
+	getSourceMap: (id: string, force?: boolean) => Promise<any>;
+	onUserConsoleLog: (log: UserConsoleLog) => void;
+	onUnhandledError: (err: unknown, type: string) => void;
+	onQueued: (file: File) => void;
+	onCollected: (files: File[]) => Promise<void>;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	onCancel: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+	onCancel: (reason: CancelReason) => void;
+}
+
+/** @deprecated unused */
+type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+	name: string;
+	transformMode?: TransformMode;
+	options: Record<string, any> | null;
+}
+type TestExecutionMethod = "run" | "collect";
+interface ContextRPC {
+	pool: string;
+	worker: string;
+	workerId: number;
+	config: SerializedConfig;
+	projectName: string;
+	files: string[] | FileSpecification[];
+	environment: ContextTestEnvironment;
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+}
+interface WorkerGlobalState {
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	environment: Environment;
+	environmentTeardownRun?: boolean;
+	onCancel: Promise<CancelReason>;
+	moduleCache: ModuleCacheMap;
+	moduleExecutionInfo?: ModuleExecutionInfo;
+	onCleanup: (listener: () => unknown) => void;
+	providedContext: Record<string, any>;
+	durations: {
+		environment: number
+		prepare: number
+	};
+	onFilterStackTrace?: (trace: string) => string;
+}
+
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };

package/plugins/web-search/node_modules/vitest/dist/chunks/worker.d.uzWsCv9X.d.ts

@@ -0,0 +1,8 @@
+import { MessagePort } from 'node:worker_threads';
+import { C as ContextRPC } from './worker.d.CUgIPz9V.js';
+
+interface WorkerContext extends ContextRPC {
+	port: MessagePort;
+}
+
+export type { WorkerContext as W };

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

@@ -0,0 +1,27 @@
+import { c as createCLI } from './chunks/cac.0BJqEUeA.js';
+import '@vitest/utils';
+import 'events';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/constants.DnKduX2e.js';
+import './chunks/index.VByaPkjc.js';
+import 'node:perf_hooks';
+import '@vitest/runner/utils';
+import '@vitest/utils/source-map';
+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';
+
+createCLI().parse();

package/plugins/web-search/node_modules/vitest/dist/config.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+var os = require('node:os');
+var stdEnv = require('std-env');
+var vite = require('vite');
+
+// if changed, update also jsdocs and docs
+const defaultBrowserPort = 63315;
+const extraInlineDeps = [
+	/^(?!.*node_modules).*\.mjs$/,
+	/^(?!.*node_modules).*\.cjs\.js$/,
+	/vite\w*\/dist\/client\/env.mjs/
+];
+
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+(isNode || isDeno) && process.platform === "win32";
+(isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;
+
+const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const defaultExclude = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/cypress/**",
+	"**/.{idea,git,cache,output,temp}/**",
+	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
+];
+const defaultCoverageExcludes = [
+	"coverage/**",
+	"dist/**",
+	"**/node_modules/**",
+	"**/[.]**",
+	"packages/*/test?(s)/**",
+	"**/*.d.ts",
+	"**/virtual:*",
+	"**/__x00__*",
+	"**/\0*",
+	"cypress/**",
+	"test?(s)/**",
+	"test?(-*).?(c|m)[jt]s?(x)",
+	"**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
+	"**/__tests__/**",
+	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
+	"**/vitest.{workspace,projects}.[jt]s?(on)",
+	"**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
+];
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
+const coverageConfigDefaults = {
+	provider: "v8",
+	enabled: false,
+	all: true,
+	clean: true,
+	cleanOnRerun: true,
+	reportsDirectory: "./coverage",
+	exclude: defaultCoverageExcludes,
+	reportOnFailure: false,
+	reporter: [
+		["text", {}],
+		["html", {}],
+		["clover", {}],
+		["json", {}]
+	],
+	extension: [
+		".js",
+		".cjs",
+		".mjs",
+		".ts",
+		".mts",
+		".tsx",
+		".jsx",
+		".vue",
+		".svelte",
+		".marko",
+		".astro"
+	],
+	allowExternal: false,
+	excludeAfterRemap: false,
+	ignoreEmptyLines: true,
+	processingConcurrency: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
+};
+const fakeTimersDefaults = {
+	loopLimit: 1e4,
+	shouldClearNativeTimers: true
+};
+const configDefaults = Object.freeze({
+	allowOnly: !stdEnv.isCI,
+	isolate: true,
+	watch: !stdEnv.isCI && process.stdin.isTTY,
+	globals: false,
+	environment: "node",
+	pool: "forks",
+	clearMocks: false,
+	restoreMocks: false,
+	mockReset: false,
+	unstubGlobals: false,
+	unstubEnvs: false,
+	include: defaultInclude,
+	exclude: defaultExclude,
+	teardownTimeout: 1e4,
+	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+	update: false,
+	reporters: [],
+	silent: false,
+	hideSkippedTests: false,
+	api: false,
+	ui: false,
+	uiBase: "/__vitest__/",
+	open: !stdEnv.isCI,
+	css: { include: [] },
+	coverage: coverageConfigDefaults,
+	fakeTimers: fakeTimersDefaults,
+	maxConcurrency: 5,
+	dangerouslyIgnoreUnhandledErrors: false,
+	typecheck: {
+		checker: "tsc",
+		include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+		exclude: defaultExclude
+	},
+	slowTestThreshold: 300,
+	disableConsoleIntercept: false
+});
+
+function defineConfig(config) {
+	return config;
+}
+function defineProject(config) {
+	return config;
+}
+/**
+* @deprecated use the `projects` field in the root config instead
+*/
+function defineWorkspace(config) {
+	return config;
+}
+
+Object.defineProperty(exports, "mergeConfig", {
+  enumerable: true,
+  get: function () { return vite.mergeConfig; }
+});
+exports.configDefaults = configDefaults;
+exports.coverageConfigDefaults = coverageConfigDefaults;
+exports.defaultBrowserPort = defaultBrowserPort;
+exports.defaultExclude = defaultExclude;
+exports.defaultInclude = defaultInclude;
+exports.defineConfig = defineConfig;
+exports.defineProject = defineProject;
+exports.defineWorkspace = defineWorkspace;
+exports.extraInlineDeps = extraInlineDeps;

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

@@ -0,0 +1,100 @@
+import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
+export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
+import { c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, b as TestProjectConfiguration } from './chunks/reporters.d.BuRON0I0.js';
+export { f as TestProjectInlineConfiguration, g as WatcherTriggerPattern, W as WorkspaceProjectConfiguration } from './chunks/reporters.d.BuRON0I0.js';
+import './chunks/vite.d.BnOPPc46.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.BKdhh7Zx.js';
+import '@vitest/runner';
+import './chunks/environment.d.cL3nLXbE.js';
+import 'vitest/optional-types.js';
+import '@vitest/utils';
+import 'node:stream';
+import 'node:console';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import './chunks/worker.d.CUgIPz9V.js';
+import 'vite-node';
+import '@vitest/snapshot';
+import '@vitest/pretty-format';
+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';
+import '@vitest/snapshot/environment';
+
+declare const defaultBrowserPort = 63315;
+declare const extraInlineDeps: RegExp[];
+
+declare const defaultInclude: string[];
+declare const defaultExclude: string[];
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
+declare const coverageConfigDefaults: ResolvedCoverageOptions;
+declare const configDefaults: Readonly<{
+	allowOnly: boolean
+	isolate: boolean
+	watch: boolean
+	globals: boolean
+	environment: "node"
+	pool: "forks"
+	clearMocks: boolean
+	restoreMocks: boolean
+	mockReset: boolean
+	unstubGlobals: boolean
+	unstubEnvs: boolean
+	include: string[]
+	exclude: string[]
+	teardownTimeout: number
+	forceRerunTriggers: string[]
+	update: boolean
+	reporters: never[]
+	silent: boolean
+	hideSkippedTests: boolean
+	api: boolean
+	ui: boolean
+	uiBase: string
+	open: boolean
+	css: {
+		include: never[]
+	}
+	coverage: CoverageV8Options
+	fakeTimers: FakeTimerInstallOpts
+	maxConcurrency: number
+	dangerouslyIgnoreUnhandledErrors: boolean
+	typecheck: {
+		checker: "tsc"
+		include: string[]
+		exclude: string[]
+	}
+	slowTestThreshold: number
+	disableConsoleIntercept: boolean
+}>;
+
+/**
+* @deprecated Use `ViteUserConfig` instead
+*/
+type UserConfig = UserConfig$1;
+
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
+type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
+declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
+declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
+declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
+/**
+* @deprecated use the `projects` field in the root config instead
+*/
+declare function defineWorkspace(config: TestProjectConfiguration[]): TestProjectConfiguration[];
+
+export { TestProjectConfiguration, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export type { UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise };

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

@@ -0,0 +1,21 @@
+export { d as defaultBrowserPort, e as extraInlineDeps } from './chunks/constants.DnKduX2e.js';
+export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.B7q_naMc.js';
+export { mergeConfig } from 'vite';
+import 'node:os';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+
+function defineConfig(config) {
+	return config;
+}
+function defineProject(config) {
+	return config;
+}
+/**
+* @deprecated use the `projects` field in the root config instead
+*/
+function defineWorkspace(config) {
+	return config;
+}
+
+export { defineConfig, defineProject, defineWorkspace };

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

@@ -0,0 +1,108 @@
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.BuRON0I0.js';
+import { TransformResult } from 'vite';
+import { A as AfterSuiteRunMeta } from './chunks/environment.d.cL3nLXbE.js';
+import '@vitest/runner';
+import '@vitest/utils';
+import 'node:stream';
+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';
+import 'vitest/optional-types.js';
+
+type Threshold = "lines" | "functions" | "statements" | "branches";
+interface ResolvedThreshold {
+	coverageMap: CoverageMap;
+	name: string;
+	thresholds: Partial<Record<Threshold, number | undefined>>;
+}
+/**
+* Holds info about raw coverage results that are stored on file system:
+*
+* ```json
+* "project-a": {
+*   "web": {
+*     "tests/math.test.ts": "coverage-1.json",
+*     "tests/utils.test.ts": "coverage-2.json",
+* //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+*   },
+*   "ssr": { ... },
+*   "browser": { ... },
+* },
+* "project-b": ...
+* ```
+*/
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["transformMode"], {
+	[TestFilenames: string]: string
+}>>;
+declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"istanbul" | "v8">> {
+	ctx: Vitest;
+	readonly name: "v8" | "istanbul";
+	version: string;
+	options: Options;
+	coverageFiles: CoverageFiles;
+	pendingPromises: Promise<void>[];
+	coverageFilesDirectory: string;
+	_initialize(ctx: Vitest): void;
+	createCoverageMap(): CoverageMap;
+	generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+	parseConfigModule(_: string): Promise<{
+		generate: () => {
+			code: string
+		}
+	}>;
+	resolveOptions(): Options;
+	clean(clean?: boolean): Promise<void>;
+	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+		/** Callback invoked with a single coverage result */
+		onFileRead: (data: CoverageType) => void
+		/** Callback invoked once all results of a project for specific transform mode are read */
+		onFinished: (project: Vitest["projects"][number], transformMode: AfterSuiteRunMeta["transformMode"]) => Promise<void>
+		onDebug: ((...logs: any[]) => void) & {
+			enabled: boolean
+		}
+	}): Promise<void>;
+	cleanAfterRun(): Promise<void>;
+	onTestFailure(): Promise<void>;
+	reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+	reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
+	/**
+	* Constructs collected coverage and users' threshold options into separate sets
+	* where each threshold set holds their own coverage maps. Threshold set is either
+	* for specific files defined by glob pattern or global for all other files.
+	*/
+	private resolveThresholds;
+	/**
+	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+	*/
+	private checkThresholds;
+	/**
+	* Check if current coverage is above configured thresholds and bump the thresholds if needed
+	*/
+	updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+		thresholds: ResolvedThreshold[]
+		configurationFile: unknown
+		onUpdate: () => void
+	}): Promise<void>;
+	mergeReports(coverageMaps: unknown[]): Promise<void>;
+	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;
+	toSlices<T>(array: T[], size: number): T[][];
+	createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<TransformResult | null | undefined>;
+}
+
+export { BaseCoverageProvider };

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

@@ -0,0 +1,34 @@
+export { B as BaseCoverageProvider } from './chunks/coverage.DfSpMS-b.js';
+import 'node:fs';
+import 'pathe';
+import 'picomatch';
+import 'tinyrainbow';
+import './chunks/defaults.B7q_naMc.js';
+import 'node:os';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import 'node:crypto';
+import '@vitest/utils';
+import 'node:module';
+import 'node:path';
+import 'node:process';
+import 'node:fs/promises';
+import 'node:url';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
+import 'vite';
+import './chunks/constants.DnKduX2e.js';
+import 'node:tty';
+import 'node:events';
+import './chunks/index.B521nVV-.js';
+import 'tinypool';
+import './chunks/typechecker.DRKU1-1g.js';
+import 'node:perf_hooks';
+import '@vitest/utils/source-map';
+import 'tinyexec';
+import './path.js';
+import '@vitest/runner/utils';
+import 'node:worker_threads';
+import 'vite-node/utils';
+import './chunks/coverage.DVF1vEu8.js';

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

@@ -0,0 +1,26 @@
+import { E as Environment } from './chunks/environment.d.cL3nLXbE.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.cL3nLXbE.js';
+import 'vitest/optional-types.js';
+
+declare const environments: {
+	"node": Environment
+	"jsdom": Environment
+	"happy-dom": Environment
+	"edge-runtime": Environment
+};
+
+interface PopulateOptions {
+	// we bind functions such as addEventListener and others
+	// because they rely on `this` in happy-dom, and in jsdom it
+	// has a priority for getting implementation from symbols
+	// (global doesn't have these symbols, but window - does)
+	bindFunctions?: boolean;
+	additionalKeys?: string[];
+}
+declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
+	keys: Set<string>
+	skipKeys: string[]
+	originals: Map<string | symbol, any>
+};
+
+export { Environment, environments as builtinEnvironments, populateGlobal };

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

@@ -0,0 +1,2 @@
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.CmSc2RE5.js';
+import 'node:console';