@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/browser/locators.d.ts

@@ -0,0 +1,354 @@
+import { UserEventClickOptions, UserEventClearOptions, UserEventHoverOptions, UserEventFillOptions, UserEventUploadOptions, UserEventDragAndDropOptions, UserEventSelectOptions, LocatorScreenshotOptions, LocatorByRoleOptions, LocatorOptions } from './index.js';
+
+type ClauseCombinator = '' | '>' | '+' | '~' | '>=';
+type CSSFunctionArgument = CSSComplexSelector | number | string;
+interface CSSFunction {
+    name: string;
+    args: CSSFunctionArgument[];
+}
+interface CSSSimpleSelector {
+    css?: string;
+    functions: CSSFunction[];
+}
+interface CSSComplexSelector {
+    simples: {
+        selector: CSSSimpleSelector;
+        combinator: ClauseCombinator;
+    }[];
+}
+type CSSComplexSelectorList = CSSComplexSelector[];
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface NestedSelectorBody {
+    parsed: ParsedSelector;
+    distance?: number;
+}
+interface ParsedSelectorPart {
+    name: string;
+    body: string | CSSComplexSelectorList | NestedSelectorBody;
+    source: string;
+}
+interface ParsedSelector {
+    parts: ParsedSelectorPart[];
+    capture?: number;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface GenerateSelectorOptions {
+    testIdAttributeName: string;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface ElementText {
+    full: string;
+    normalized: string;
+    immediate: string[];
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface QueryContext {
+    scope: Element | Document;
+    pierceShadow: boolean;
+    originalScope?: Element | Document;
+}
+type Selector = any;
+interface SelectorEvaluator {
+    query: (context: QueryContext, selector: Selector) => Element[];
+    matches: (element: Element, selector: Selector, context: QueryContext) => boolean;
+}
+interface SelectorEngine$1 {
+    matches?: (element: Element, args: (string | number | Selector)[], context: QueryContext, evaluator: SelectorEvaluator) => boolean;
+    query?: (context: QueryContext, args: (string | number | Selector)[], evaluator: SelectorEvaluator) => Element[];
+}
+declare class SelectorEvaluatorImpl implements SelectorEvaluator {
+    private _engines;
+    private _cacheQueryCSS;
+    private _cacheMatches;
+    private _cacheQuery;
+    private _cacheMatchesSimple;
+    private _cacheMatchesParents;
+    private _cacheCallMatches;
+    private _cacheCallQuery;
+    private _cacheQuerySimple;
+    _cacheText: Map<Element | ShadowRoot, ElementText>;
+    private _scoreMap;
+    private _retainCacheCounter;
+    constructor(extraEngines: Map<string, SelectorEngine$1>);
+    begin(): void;
+    end(): void;
+    private _cached;
+    private _checkSelector;
+    matches(element: Element, s: Selector, context: QueryContext): boolean;
+    query(context: QueryContext, s: any): Element[];
+    _markScore(element: Element, score: number): void;
+    private _hasScopeClause;
+    private _expandContextForScopeMatching;
+    private _matchesSimple;
+    private _querySimple;
+    private _matchesParents;
+    private _matchesEngine;
+    private _queryEngine;
+    private _callMatches;
+    private _callQuery;
+    private _matchesCSS;
+    _queryCSS(context: QueryContext, css: string): Element[];
+    private _getEngine;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+interface ByRoleOptions {
+    checked?: boolean;
+    disabled?: boolean;
+    exact?: boolean;
+    expanded?: boolean;
+    includeHidden?: boolean;
+    level?: number;
+    name?: string | RegExp;
+    pressed?: boolean;
+    selected?: boolean;
+}
+declare function getByTestIdSelector(testIdAttributeName: string, testId: string | RegExp): string;
+declare function getByLabelSelector(text: string | RegExp, options?: {
+    exact?: boolean;
+}): string;
+declare function getByAltTextSelector(text: string | RegExp, options?: {
+    exact?: boolean;
+}): string;
+declare function getByTitleSelector(text: string | RegExp, options?: {
+    exact?: boolean;
+}): string;
+declare function getByPlaceholderSelector(text: string | RegExp, options?: {
+    exact?: boolean;
+}): string;
+declare function getByTextSelector(text: string | RegExp, options?: {
+    exact?: boolean;
+}): string;
+declare function getByRoleSelector(role: string, options?: ByRoleOptions): string;
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface IvyaOptions {
+    testIdAttribute: string;
+    browser: 'webkit' | 'chromium' | 'firefox';
+}
+interface IvyaConfiguration {
+    testIdAttribute?: string;
+    browser: 'webkit' | 'chromium' | 'firefox';
+}
+declare class Ivya {
+    /** @internal */
+    _engines: Map<string, SelectorEngine>;
+    /** @internal */
+    _evaluator: SelectorEvaluatorImpl;
+    static options: IvyaOptions;
+    private static singleton;
+    static create(options: IvyaConfiguration): Ivya;
+    private constructor();
+    queryLocatorSelector(locator: string, root?: Node, strict?: boolean): Element | null;
+    queryLocatorSelectorAll(locator: string, root?: Node): Element[];
+    querySelector(selector: ParsedSelector, root: Node, strict?: boolean): Element | null;
+    queryAllByRole(text: string, options?: ByRoleOptions, container?: Node): Element[];
+    queryAllByLabelText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element[];
+    queryAllByTestId(text: string | RegExp, container?: Node): Element[];
+    queryAllByText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element[];
+    queryAllByTitle(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element[];
+    queryAllByPlaceholder(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element[];
+    queryAllByAltText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element[];
+    queryByRole(text: string, options?: ByRoleOptions, container?: Node): Element | null;
+    queryByLabelText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element | null;
+    queryByTestId(text: string | RegExp, container?: Node): Element | null;
+    queryByText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element | null;
+    queryByTitle(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element | null;
+    queryByPlaceholder(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element | null;
+    queryByAltText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }, container?: Node): Element | null;
+    private strictModeViolationError;
+    generateSelectorSimple(targetElement: Element, options?: GenerateSelectorOptions): string;
+    parseSelector(selector: string): ParsedSelector;
+    previewNode(node: Node): string;
+    querySelectorAll(selector: ParsedSelector, root: Node): Element[];
+    private _queryEngineAll;
+    private _queryNth;
+    private _queryLayoutSelector;
+    private createStacklessError;
+    private _createTextEngine;
+    private _createAttributeEngine;
+    private _createCSSEngine;
+    private _createNamedAttributeEngine;
+    private _createVisibleEngine;
+    private _createControlEngine;
+    private _createHasEngine;
+    private _createHasNotEngine;
+    private _createInternalChainEngine;
+    private _createInternalLabelEngine;
+    private _createInternalHasTextEngine;
+    private _createInternalHasNotTextEngine;
+}
+type SelectorRoot = Element | ShadowRoot | Document;
+interface SelectorEngine {
+    queryAll: (root: SelectorRoot, selector: string | any) => Element[];
+}
+
+declare function convertElementToCssSelector(element: Element): string;
+declare function processTimeoutOptions<T extends {
+	timeout?: number;
+}>(options_?: T): T | undefined;
+declare function getIframeScale(): number;
+
+declare const selectorEngine: Ivya;
+declare abstract class Locator {
+	abstract selector: string;
+	private _parsedSelector;
+	protected _container?: Element | undefined;
+	protected _pwSelector?: string | undefined;
+	constructor();
+	click(options?: UserEventClickOptions): Promise<void>;
+	dblClick(options?: UserEventClickOptions): Promise<void>;
+	tripleClick(options?: UserEventClickOptions): Promise<void>;
+	clear(options?: UserEventClearOptions): Promise<void>;
+	hover(options?: UserEventHoverOptions): Promise<void>;
+	unhover(options?: UserEventHoverOptions): Promise<void>;
+	fill(text: string, options?: UserEventFillOptions): Promise<void>;
+	upload(files: string | string[] | File | File[], options?: UserEventUploadOptions): Promise<void>;
+	dropTo(target: Locator, options?: UserEventDragAndDropOptions): Promise<void>;
+	selectOptions(value: HTMLElement | HTMLElement[] | Locator | Locator[] | string | string[], options?: UserEventSelectOptions): Promise<void>;
+	screenshot(options: Omit<LocatorScreenshotOptions, "base64"> & {
+		base64: true;
+	}): Promise<{
+		path: string;
+		base64: string;
+	}>;
+	screenshot(options?: LocatorScreenshotOptions): Promise<string>;
+	protected abstract locator(selector: string): Locator;
+	protected abstract elementLocator(element: Element): Locator;
+	getByRole(role: string, options?: LocatorByRoleOptions): Locator;
+	getByAltText(text: string | RegExp, options?: LocatorOptions): Locator;
+	getByLabelText(text: string | RegExp, options?: LocatorOptions): Locator;
+	getByPlaceholder(text: string | RegExp, options?: LocatorOptions): Locator;
+	getByTestId(testId: string | RegExp): Locator;
+	getByText(text: string | RegExp, options?: LocatorOptions): Locator;
+	getByTitle(title: string | RegExp, options?: LocatorOptions): Locator;
+	filter(filter: LocatorOptions): Locator;
+	and(locator: Locator): Locator;
+	or(locator: Locator): Locator;
+	query(): HTMLElement | SVGElement | null;
+	element(): HTMLElement | SVGElement;
+	elements(): (HTMLElement | SVGElement)[];
+	get length(): number;
+	all(): Locator[];
+	nth(index: number): Locator;
+	first(): Locator;
+	last(): Locator;
+	toString(): string;
+	toJSON(): string;
+	protected triggerCommand<T>(command: string, ...args: any[]): Promise<T>;
+}
+
+export { Locator, convertElementToCssSelector, getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByRoleSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector, getIframeScale, processTimeoutOptions, selectorEngine };

package/dist/@vitest/browser/locators.js

@@ -0,0 +1 @@
+export{L as Locator,n as convertElementToCssSelector,q as getByAltTextSelector,r as getByLabelSelector,t as getByPlaceholderSelector,u as getByRoleSelector,v as getByTestIdSelector,w as getByTextSelector,x as getByTitleSelector,o as getIframeScale,p as processTimeoutOptions,s as selectorEngine}from"./index-D6m36C6U.js";import'../../browser.js';

package/dist/@vitest/browser/matchers.d.ts

@@ -0,0 +1,29 @@
+import type { Locator } from './context.js'
+import type { TestingLibraryMatchers } from './jest-dom.js'
+import type { Assertion, ExpectPollOptions } from '../../index.js'
+
+declare module 'vitest' {
+  interface JestAssertion<T = any> extends TestingLibraryMatchers<void, T> {}
+  interface AsymmetricMatchersContaining extends TestingLibraryMatchers<void, void> {}
+
+  type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R
+      ? O extends R
+        ? Promisify<O[K]>
+        : (...args: A) => Promise<R>
+      : O[K];
+  }
+
+  type PromisifyDomAssertion<T> = Promisify<Assertion<T>>
+
+  interface ExpectStatic {
+    /**
+     * `expect.element(locator)` is a shorthand for `expect.poll(() => locator.element())`.
+     * You can set default timeout via `expect.poll.timeout` option in the config.
+     * @see {@link https://vitest.dev/api/expect#poll}
+     */
+    element: <T extends HTMLElement | SVGElement | null | Locator>(element: T, options?: ExpectPollOptions) => PromisifyDomAssertion<Awaited<HTMLElement | SVGElement | null>>
+  }
+}
+
+export {}

package/dist/@vitest/browser/shared/screenshotMatcher/types.d.ts

@@ -0,0 +1,22 @@
+import type { ScreenshotComparatorRegistry, ScreenshotMatcherOptions } from "../../../context.js";
+export type ScreenshotMatcherArguments<ComparatorName extends keyof ScreenshotComparatorRegistry = keyof ScreenshotComparatorRegistry> = [name: string, testName: string, options: ScreenshotMatcherOptions<ComparatorName> & {
+	element: string;
+	screenshotOptions?: ScreenshotMatcherOptions<ComparatorName>["screenshotOptions"] & {
+		mask?: readonly string[];
+	};
+}];
+interface ScreenshotData {
+	path: string;
+	width: number;
+	height: number;
+}
+export type ScreenshotMatcherOutput = Promise<{
+	pass: false;
+	reference: ScreenshotData | null;
+	actual: ScreenshotData | null;
+	diff: ScreenshotData | null;
+	message: string;
+} | {
+	pass: true;
+}>;
+export {};

package/dist/@vitest/browser/state.js

@@ -0,0 +1,280 @@
+(function () {
+  'use strict';
+
+  let SOURCEMAPPING_URL = "sourceMa";
+  SOURCEMAPPING_URL += "ppingURL";
+  const isWindows = typeof process < "u" && process.platform === "win32";
+  function unwrapId(id) {
+    return id.startsWith("/@id/") ? id.slice(5).replace("__x00__", "\0") : id;
+  }
+  const windowsSlashRE = /\\/g;
+  function slash(p) {
+    return p.replace(windowsSlashRE, "/");
+  }
+  const postfixRE = /[?#].*$/;
+  function cleanUrl(url) {
+    return url.replace(postfixRE, "");
+  }
+  const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+  function normalizeWindowsPath(input = "") {
+    return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+  }
+  const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+  function cwd() {
+    return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+  }
+  const resolve = function(...arguments_) {
+    arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+    let resolvedPath = "", resolvedAbsolute = false;
+    for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+      let path = index >= 0 ? arguments_[index] : cwd();
+      !path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+    }
+    return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+  };
+  function normalizeString(path, allowAboveRoot) {
+    let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+    for (let index = 0; index <= path.length; ++index) {
+      if (index < path.length) char = path[index];
+      else if (char === "/") break;
+      else char = "/";
+      if (char === "/") {
+        if (!(lastSlash === index - 1 || dots === 1)) if (dots === 2) {
+          if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+            if (res.length > 2) {
+              let lastSlashIndex = res.lastIndexOf("/");
+              lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index, dots = 0;
+              continue;
+            } else if (res.length > 0) {
+              res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+              continue;
+            }
+          }
+          allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+        } else res.length > 0 ? res += `/${path.slice(lastSlash + 1, index)}` : res = path.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+        lastSlash = index, dots = 0;
+      } else char === "." && dots !== -1 ? ++dots : dots = -1;
+    }
+    return res;
+  }
+  const isAbsolute = function(p) {
+    return _IS_ABSOLUTE_RE.test(p);
+  }, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8");
+  const posixResolve = resolve;
+  const intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
+  for (let i = 0; i < 64; i++) {
+    let c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charCodeAt(i);
+    intToChar[i] = c, charToInt[c] = i;
+  }
+  var DecodedMap = class {
+    _encoded;
+    _decoded;
+    _decodedMemo;
+    url;
+    version;
+    names = [];
+    resolvedSources;
+    constructor(map, from) {
+      this.map = map;
+      let { mappings, names, sources } = map;
+      this.version = map.version, this.names = names || [], this._encoded = mappings || "", this._decodedMemo = memoizedState(), this.url = from, this.resolvedSources = (sources || []).map((s) => posixResolve(s || "", from));
+    }
+  };
+  function memoizedState() {
+    return {
+      lastKey: -1,
+      lastNeedle: -1,
+      lastIndex: -1
+    };
+  }
+  const MODULE_RUNNER_SOURCEMAPPING_REGEXP = /* @__PURE__ */ RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
+  var EvaluatedModuleNode = class {
+    importers = /* @__PURE__ */ new Set();
+    imports = /* @__PURE__ */ new Set();
+    evaluated = false;
+    meta;
+    promise;
+    exports;
+    file;
+    map;
+    constructor(id, url) {
+      this.id = id, this.url = url, this.file = cleanUrl(id);
+    }
+  }, EvaluatedModules = class {
+    idToModuleMap = /* @__PURE__ */ new Map();
+    fileToModulesMap = /* @__PURE__ */ new Map();
+    urlToIdModuleMap = /* @__PURE__ */ new Map();
+    getModuleById(id) {
+      return this.idToModuleMap.get(id);
+    }
+    getModulesByFile(file) {
+      return this.fileToModulesMap.get(file);
+    }
+    getModuleByUrl(url) {
+      return this.urlToIdModuleMap.get(unwrapId(url));
+    }
+    ensureModule(id, url) {
+      if (id = normalizeModuleId(id), this.idToModuleMap.has(id)) {
+        let moduleNode$1 = this.idToModuleMap.get(id);
+        return this.urlToIdModuleMap.set(url, moduleNode$1), moduleNode$1;
+      }
+      let moduleNode = new EvaluatedModuleNode(id, url);
+      this.idToModuleMap.set(id, moduleNode), this.urlToIdModuleMap.set(url, moduleNode);
+      let fileModules = this.fileToModulesMap.get(moduleNode.file) || /* @__PURE__ */ new Set();
+      return fileModules.add(moduleNode), this.fileToModulesMap.set(moduleNode.file, fileModules), moduleNode;
+    }
+    invalidateModule(node) {
+      node.evaluated = false, node.meta = void 0, node.map = void 0, node.promise = void 0, node.exports = void 0, node.imports.clear();
+    }
+    getModuleSourceMapById(id) {
+      let mod = this.getModuleById(id);
+      if (!mod) return null;
+      if (mod.map) return mod.map;
+      if (!mod.meta || !("code" in mod.meta)) return null;
+      let pattern = `//# ${SOURCEMAPPING_URL}=data:application/json;base64,`, lastIndex = mod.meta.code.lastIndexOf(pattern);
+      if (lastIndex === -1) return null;
+      let mapString = MODULE_RUNNER_SOURCEMAPPING_REGEXP.exec(mod.meta.code.slice(lastIndex))?.[1];
+      return mapString ? (mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), mod.file), mod.map) : null;
+    }
+    clear() {
+      this.idToModuleMap.clear(), this.fileToModulesMap.clear(), this.urlToIdModuleMap.clear();
+    }
+  };
+  const prefixedBuiltins = new Set([
+    "node:sea",
+    "node:sqlite",
+    "node:test",
+    "node:test/reporters"
+  ]);
+  function normalizeModuleId(file) {
+    if (prefixedBuiltins.has(file)) return file;
+    let unixFile = slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+    return unixFile.replace(/^file:\/+/, isWindows ? "" : "/");
+  }
+  const customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/"; `
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+
+  return nextResolve(specifier, context)
+}
+
+`;
+  new Proxy({}, { get(_, p) {
+    throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+  } });
+
+  /* @__NO_SIDE_EFFECTS__ */
+  function getBrowserState() {
+    // @ts-expect-error not typed global
+    return window.__vitest_browser_runner__;
+  }
+
+  const config = getBrowserState().config;
+  const sessionId = getBrowserState().sessionId;
+  const state = {
+    ctx: {
+      rpc: null,
+      pool: "browser",
+      workerId: 1,
+      config,
+      projectName: config.name || "",
+      files: [],
+      environment: {
+        name: "browser",
+        options: null
+      },
+      providedContext: {},
+      invalidates: []
+    },
+    onCancel: null,
+    config,
+    environment: {
+      name: "browser",
+      viteEnvironment: "client",
+      setup() {
+        throw new Error("Not called in the browser");
+      }
+    },
+    onCleanup: (fn) => getBrowserState().cleanups.push(fn),
+    evaluatedModules: new EvaluatedModules(),
+    resolvingModules: new Set(),
+    moduleExecutionInfo: new Map(),
+    metaEnv: null,
+    rpc: null,
+    durations: {
+      environment: 0,
+      prepare: performance.now()
+    },
+    providedContext: {}
+  };
+  // @ts-expect-error not typed global
+  globalThis.__vitest_browser__ = true;
+  // @ts-expect-error not typed global
+  globalThis.__vitest_worker__ = state;
+  getBrowserState().cdp = createCdp();
+  function rpc() {
+    return state.rpc;
+  }
+  function createCdp() {
+    const listenersMap = new WeakMap();
+    function getId(listener) {
+      const id = listenersMap.get(listener) || crypto.randomUUID();
+      listenersMap.set(listener, id);
+      return id;
+    }
+    const listeners = {};
+    const cdp = {
+      send(method, params) {
+        return rpc().sendCdpEvent(sessionId, method, params);
+      },
+      on(event, listener) {
+        const listenerId = getId(listener);
+        listeners[event] = listeners[event] || [];
+        listeners[event].push(listener);
+        rpc().trackCdpEvent(sessionId, "on", event, listenerId).catch(error);
+        return cdp;
+      },
+      once(event, listener) {
+        const listenerId = getId(listener);
+        const handler = (data) => {
+          listener(data);
+          cdp.off(event, listener);
+        };
+        listeners[event] = listeners[event] || [];
+        listeners[event].push(handler);
+        rpc().trackCdpEvent(sessionId, "once", event, listenerId).catch(error);
+        return cdp;
+      },
+      off(event, listener) {
+        const listenerId = getId(listener);
+        if (listeners[event]) {
+          listeners[event] = listeners[event].filter((l) => l !== listener);
+        }
+        rpc().trackCdpEvent(sessionId, "off", event, listenerId).catch(error);
+        return cdp;
+      },
+      emit(event, payload) {
+        if (listeners[event]) {
+          listeners[event].forEach((l) => {
+            try {
+              l(payload);
+            } catch (err) {
+              error(err);
+            }
+          });
+        }
+      }
+    };
+    return cdp;
+  }
+  function error(err) {
+    window.dispatchEvent(new ErrorEvent("error", { error: err }));
+  }
+
+})();