@vitest/browser 4.0.0-beta.13 → 4.0.0-beta.14

package/dist/providers/playwright.js

@@ -1,385 +0,0 @@
-import { createManualModuleSource } from '@vitest/mocker/node';
-import c from 'tinyrainbow';
-import { createDebugger, isCSSRequest } from 'vitest/node';
-
-const debug = createDebugger("vitest:browser:playwright");
-const playwrightBrowsers = [
-	"firefox",
-	"webkit",
-	"chromium"
-];
-function playwright(options = {}) {
-	return {
-		name: "playwright",
-		supportedBrowser: playwrightBrowsers,
-		options,
-		factory(project) {
-			return new PlaywrightBrowserProvider(project, options);
-		},
-		_cli: true
-	};
-}
-class PlaywrightBrowserProvider {
-	name = "playwright";
-	supportsParallelism = true;
-	browser = null;
-	contexts = new Map();
-	pages = new Map();
-	mocker;
-	browserName;
-	browserPromise = null;
-	closing = false;
-	tracingContexts = new Set();
-	pendingTraces = new Map();
-	constructor(project, options) {
-		this.project = project;
-		this.options = options;
-		this.browserName = project.config.browser.name;
-		this.mocker = this.createMocker();
-		// make sure the traces are finished if the test hangs
-		process.on("SIGTERM", () => {
-			if (!this.browser) {
-				return;
-			}
-			const promises = [];
-			for (const [trace, contextId] of this.pendingTraces.entries()) {
-				promises.push((() => {
-					const context = this.contexts.get(contextId);
-					return context?.tracing.stopChunk({ path: trace });
-				})());
-			}
-			return Promise.allSettled(promises);
-		});
-	}
-	async openBrowser() {
-		await this._throwIfClosing();
-		if (this.browserPromise) {
-			debug?.("[%s] the browser is resolving, reusing the promise", this.browserName);
-			return this.browserPromise;
-		}
-		if (this.browser) {
-			debug?.("[%s] the browser is resolved, reusing it", this.browserName);
-			return this.browser;
-		}
-		this.browserPromise = (async () => {
-			const options = this.project.config.browser;
-			const playwright = await import('playwright');
-			if (this.options.connectOptions) {
-				if (this.options.launchOptions) {
-					this.project.vitest.logger.warn(c.yellow(`Found both ${c.bold(c.italic(c.yellow("connect")))} and ${c.bold(c.italic(c.yellow("launch")))} options in browser instance configuration.
-          Ignoring ${c.bold(c.italic(c.yellow("launch")))} options and using ${c.bold(c.italic(c.yellow("connect")))} mode.
-          You probably want to remove one of the two options and keep only the one you want to use.`));
-				}
-				const browser = await playwright[this.browserName].connect(this.options.connectOptions.wsEndpoint, this.options.connectOptions);
-				this.browser = browser;
-				this.browserPromise = null;
-				return this.browser;
-			}
-			const launchOptions = {
-				...this.options.launchOptions,
-				headless: options.headless
-			};
-			if (typeof options.trace === "object" && options.trace.tracesDir) {
-				launchOptions.tracesDir = options.trace?.tracesDir;
-			}
-			const inspector = this.project.vitest.config.inspector;
-			if (inspector.enabled) {
-				// NodeJS equivalent defaults: https://nodejs.org/en/learn/getting-started/debugging#enable-inspector
-				const port = inspector.port || 9229;
-				const host = inspector.host || "127.0.0.1";
-				launchOptions.args ||= [];
-				launchOptions.args.push(`--remote-debugging-port=${port}`);
-				launchOptions.args.push(`--remote-debugging-address=${host}`);
-				this.project.vitest.logger.log(`Debugger listening on ws://${host}:${port}`);
-			}
-			// start Vitest UI maximized only on supported browsers
-			if (this.project.config.browser.ui && this.browserName === "chromium") {
-				if (!launchOptions.args) {
-					launchOptions.args = [];
-				}
-				if (!launchOptions.args.includes("--start-maximized") && !launchOptions.args.includes("--start-fullscreen")) {
-					launchOptions.args.push("--start-maximized");
-				}
-			}
-			debug?.("[%s] initializing the browser with launch options: %O", this.browserName, launchOptions);
-			this.browser = await playwright[this.browserName].launch(launchOptions);
-			this.browserPromise = null;
-			return this.browser;
-		})();
-		return this.browserPromise;
-	}
-	createMocker() {
-		const idPreficates = new Map();
-		const sessionIds = new Map();
-		function createPredicate(sessionId, url) {
-			const moduleUrl = new URL(url, "http://localhost");
-			const predicate = (url) => {
-				if (url.searchParams.has("_vitest_original")) {
-					return false;
-				}
-				// different modules, ignore request
-				if (url.pathname !== moduleUrl.pathname) {
-					return false;
-				}
-				url.searchParams.delete("t");
-				url.searchParams.delete("v");
-				url.searchParams.delete("import");
-				// different search params, ignore request
-				if (url.searchParams.size !== moduleUrl.searchParams.size) {
-					return false;
-				}
-				// check that all search params are the same
-				for (const [param, value] of url.searchParams.entries()) {
-					if (moduleUrl.searchParams.get(param) !== value) {
-						return false;
-					}
-				}
-				return true;
-			};
-			const ids = sessionIds.get(sessionId) || [];
-			ids.push(moduleUrl.href);
-			sessionIds.set(sessionId, ids);
-			idPreficates.set(predicateKey(sessionId, moduleUrl.href), predicate);
-			return predicate;
-		}
-		function predicateKey(sessionId, url) {
-			return `${sessionId}:${url}`;
-		}
-		return {
-			register: async (sessionId, module) => {
-				const page = this.getPage(sessionId);
-				await page.route(createPredicate(sessionId, module.url), async (route) => {
-					if (module.type === "manual") {
-						const exports = Object.keys(await module.resolve());
-						const body = createManualModuleSource(module.url, exports);
-						return route.fulfill({
-							body,
-							headers: getHeaders(this.project.browser.vite.config)
-						});
-					}
-					// webkit doesn't support redirect responses
-					// https://github.com/microsoft/playwright/issues/18318
-					const isWebkit = this.browserName === "webkit";
-					if (isWebkit) {
-						let url;
-						if (module.type === "redirect") {
-							const redirect = new URL(module.redirect);
-							url = redirect.href.slice(redirect.origin.length);
-						} else {
-							const request = new URL(route.request().url());
-							request.searchParams.set("mock", module.type);
-							url = request.href.slice(request.origin.length);
-						}
-						const result = await this.project.browser.vite.transformRequest(url).catch(() => null);
-						if (!result) {
-							return route.continue();
-						}
-						let content = result.code;
-						if (result.map && "version" in result.map && result.map.mappings) {
-							const type = isDirectCSSRequest(url) ? "css" : "js";
-							content = getCodeWithSourcemap(type, content.toString(), result.map);
-						}
-						return route.fulfill({
-							body: content,
-							headers: getHeaders(this.project.browser.vite.config)
-						});
-					}
-					if (module.type === "redirect") {
-						return route.fulfill({
-							status: 302,
-							headers: { Location: module.redirect }
-						});
-					} else if (module.type === "automock" || module.type === "autospy") {
-						const url = new URL(route.request().url());
-						url.searchParams.set("mock", module.type);
-						return route.fulfill({
-							status: 302,
-							headers: { Location: url.href }
-						});
-					} else ;
-				});
-			},
-			delete: async (sessionId, id) => {
-				const page = this.getPage(sessionId);
-				const key = predicateKey(sessionId, id);
-				const predicate = idPreficates.get(key);
-				if (predicate) {
-					await page.unroute(predicate).finally(() => idPreficates.delete(key));
-				}
-			},
-			clear: async (sessionId) => {
-				const page = this.getPage(sessionId);
-				const ids = sessionIds.get(sessionId) || [];
-				const promises = ids.map((id) => {
-					const key = predicateKey(sessionId, id);
-					const predicate = idPreficates.get(key);
-					if (predicate) {
-						return page.unroute(predicate).finally(() => idPreficates.delete(key));
-					}
-					return null;
-				});
-				await Promise.all(promises).finally(() => sessionIds.delete(sessionId));
-			}
-		};
-	}
-	async createContext(sessionId) {
-		await this._throwIfClosing();
-		if (this.contexts.has(sessionId)) {
-			debug?.("[%s][%s] the context already exists, reusing it", sessionId, this.browserName);
-			return this.contexts.get(sessionId);
-		}
-		const browser = await this.openBrowser();
-		await this._throwIfClosing(browser);
-		const actionTimeout = this.options.actionTimeout;
-		const contextOptions = this.options.contextOptions ?? {};
-		const options = {
-			...contextOptions,
-			ignoreHTTPSErrors: true
-		};
-		if (this.project.config.browser.ui) {
-			options.viewport = null;
-		}
-		const context = await browser.newContext(options);
-		await this._throwIfClosing(context);
-		if (actionTimeout != null) {
-			context.setDefaultTimeout(actionTimeout);
-		}
-		debug?.("[%s][%s] the context is ready", sessionId, this.browserName);
-		this.contexts.set(sessionId, context);
-		return context;
-	}
-	getPage(sessionId) {
-		const page = this.pages.get(sessionId);
-		if (!page) {
-			throw new Error(`Page "${sessionId}" not found in ${this.browserName} browser.`);
-		}
-		return page;
-	}
-	getCommandsContext(sessionId) {
-		const page = this.getPage(sessionId);
-		return {
-			page,
-			context: this.contexts.get(sessionId),
-			frame() {
-				return new Promise((resolve, reject) => {
-					const frame = page.frame("vitest-iframe");
-					if (frame) {
-						return resolve(frame);
-					}
-					const timeout = setTimeout(() => {
-						const err = new Error(`Cannot find "vitest-iframe" on the page. This is a bug in Vitest, please report it.`);
-						reject(err);
-					}, 1e3).unref();
-					page.on("frameattached", (frame) => {
-						clearTimeout(timeout);
-						resolve(frame);
-					});
-				});
-			},
-			get iframe() {
-				return page.frameLocator("[data-vitest=\"true\"]");
-			}
-		};
-	}
-	async openBrowserPage(sessionId) {
-		await this._throwIfClosing();
-		if (this.pages.has(sessionId)) {
-			debug?.("[%s][%s] the page already exists, closing the old one", sessionId, this.browserName);
-			const page = this.pages.get(sessionId);
-			await page.close();
-			this.pages.delete(sessionId);
-		}
-		const context = await this.createContext(sessionId);
-		const page = await context.newPage();
-		debug?.("[%s][%s] the page is ready", sessionId, this.browserName);
-		await this._throwIfClosing(page);
-		this.pages.set(sessionId, page);
-		if (process.env.VITEST_PW_DEBUG) {
-			page.on("requestfailed", (request) => {
-				console.error("[PW Error]", request.resourceType(), "request failed for", request.url(), "url:", request.failure()?.errorText);
-			});
-		}
-		return page;
-	}
-	async openPage(sessionId, url, beforeNavigate) {
-		debug?.("[%s][%s] creating the browser page for %s", sessionId, this.browserName, url);
-		const browserPage = await this.openBrowserPage(sessionId);
-		await beforeNavigate?.();
-		debug?.("[%s][%s] browser page is created, opening %s", sessionId, this.browserName, url);
-		await browserPage.goto(url, { timeout: 0 });
-		await this._throwIfClosing(browserPage);
-	}
-	async _throwIfClosing(disposable) {
-		if (this.closing) {
-			debug?.("[%s] provider was closed, cannot perform the action on %s", this.browserName, String(disposable));
-			await disposable?.close();
-			this.pages.clear();
-			this.contexts.clear();
-			this.browser = null;
-			this.browserPromise = null;
-			throw new Error(`[vitest] The provider was closed.`);
-		}
-	}
-	async getCDPSession(sessionid) {
-		const page = this.getPage(sessionid);
-		const cdp = await page.context().newCDPSession(page);
-		return {
-			async send(method, params) {
-				const result = await cdp.send(method, params);
-				return result;
-			},
-			on(event, listener) {
-				cdp.on(event, listener);
-			},
-			off(event, listener) {
-				cdp.off(event, listener);
-			},
-			once(event, listener) {
-				cdp.once(event, listener);
-			}
-		};
-	}
-	async close() {
-		debug?.("[%s] closing provider", this.browserName);
-		this.closing = true;
-		if (this.browserPromise) {
-			await this.browserPromise;
-			this.browserPromise = null;
-		}
-		const browser = this.browser;
-		this.browser = null;
-		await Promise.all([...this.pages.values()].map((p) => p.close()));
-		this.pages.clear();
-		await Promise.all([...this.contexts.values()].map((c) => c.close()));
-		this.contexts.clear();
-		await browser?.close();
-		debug?.("[%s] provider is closed", this.browserName);
-	}
-}
-function getHeaders(config) {
-	const headers = { "Content-Type": "application/javascript" };
-	for (const name in config.server.headers) {
-		headers[name] = String(config.server.headers[name]);
-	}
-	return headers;
-}
-function getCodeWithSourcemap(type, code, map) {
-	if (type === "js") {
-		code += `\n//# sourceMappingURL=${genSourceMapUrl(map)}`;
-	} else if (type === "css") {
-		code += `\n/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
-	}
-	return code;
-}
-function genSourceMapUrl(map) {
-	if (typeof map !== "string") {
-		map = JSON.stringify(map);
-	}
-	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
-}
-const directRequestRE = /[?&]direct\b/;
-function isDirectCSSRequest(request) {
-	return isCSSRequest(request) && directRequestRE.test(request);
-}
-
-export { PlaywrightBrowserProvider, playwright };

package/dist/providers/preview.d.ts

@@ -1,16 +0,0 @@
-import { BrowserProviderOption, BrowserProvider, TestProject } from 'vitest/node';
-
-declare function preview(): BrowserProviderOption;
-declare class PreviewBrowserProvider implements BrowserProvider {
-	name: "preview";
-	supportsParallelism: boolean;
-	private project;
-	private open;
-	constructor(project: TestProject);
-	isOpen(): boolean;
-	getCommandsContext(): {};
-	openPage(_sessionId: string, url: string): Promise<void>;
-	close(): Promise<void>;
-}
-
-export { PreviewBrowserProvider, preview };

package/dist/providers/preview.js

@@ -1,44 +0,0 @@
-function preview() {
-	return {
-		name: "preview",
-		options: {},
-		factory(project) {
-			return new PreviewBrowserProvider(project);
-		},
-		_cli: true
-	};
-}
-class PreviewBrowserProvider {
-	name = "preview";
-	supportsParallelism = false;
-	project;
-	open = false;
-	constructor(project) {
-		this.project = project;
-		this.open = false;
-		if (project.config.browser.headless) {
-			throw new Error("You've enabled headless mode for \"preview\" provider but it doesn't support it. Use \"playwright\" or \"webdriverio\" instead: https://vitest.dev/guide/browser/#configuration");
-		}
-		project.vitest.logger.printBrowserBanner(project);
-	}
-	isOpen() {
-		return this.open;
-	}
-	getCommandsContext() {
-		return {};
-	}
-	async openPage(_sessionId, url) {
-		this.open = true;
-		if (!this.project.browser) {
-			throw new Error("Browser is not initialized");
-		}
-		const options = this.project.browser.vite.config.server;
-		const _open = options.open;
-		options.open = url;
-		this.project.browser.vite.openBrowser();
-		options.open = _open;
-	}
-	async close() {}
-}
-
-export { PreviewBrowserProvider, preview };

package/dist/providers/webdriverio.d.ts

@@ -1,51 +0,0 @@
-import { ScreenshotMatcherOptions, ScreenshotComparatorRegistry } from '@vitest/browser/context';
-import { BrowserProviderOption, BrowserProvider, TestProject, CDPSession } from 'vitest/node';
-import { ClickOptions, DragAndDropOptions, remote } from 'webdriverio';
-
-interface WebdriverProviderOptions extends Partial<Parameters<typeof remote>[0]> {}
-declare function webdriverio(options?: WebdriverProviderOptions): BrowserProviderOption<WebdriverProviderOptions>;
-declare class WebdriverBrowserProvider implements BrowserProvider {
-	name: "webdriverio";
-	supportsParallelism: boolean;
-	browser: WebdriverIO.Browser | null;
-	private browserName;
-	private project;
-	private options?;
-	private closing;
-	private iframeSwitched;
-	private topLevelContext;
-	getSupportedBrowsers(): readonly string[];
-	constructor(project: TestProject, options: WebdriverProviderOptions);
-	isIframeSwitched(): boolean;
-	switchToTestFrame(): Promise<void>;
-	switchToMainFrame(): Promise<void>;
-	setViewport(options: {
-		width: number;
-		height: number;
-	}): Promise<void>;
-	getCommandsContext(): {
-		browser: WebdriverIO.Browser | null;
-	};
-	openBrowser(): Promise<WebdriverIO.Browser>;
-	private buildCapabilities;
-	openPage(sessionId: string, url: string): Promise<void>;
-	private _throwIfClosing;
-	close(): Promise<void>;
-	getCDPSession(_sessionId: string): Promise<CDPSession>;
-}
-declare module "vitest/node" {
-	interface UserEventClickOptions extends ClickOptions {}
-	interface UserEventDragOptions extends DragAndDropOptions {
-		sourceX?: number;
-		sourceY?: number;
-		targetX?: number;
-		targetY?: number;
-	}
-	interface BrowserCommandContext {
-		browser: WebdriverIO.Browser;
-	}
-	interface ToMatchScreenshotOptions extends Omit<ScreenshotMatcherOptions, "comparatorName" | "comparatorOptions"> {}
-	interface ToMatchScreenshotComparators extends ScreenshotComparatorRegistry {}
-}
-
-export { WebdriverBrowserProvider, webdriverio };

package/dist/providers/webdriverio.js

@@ -1,206 +0,0 @@
-import { createDebugger } from 'vitest/node';
-
-const debug = createDebugger("vitest:browser:wdio");
-const webdriverBrowsers = [
-	"firefox",
-	"chrome",
-	"edge",
-	"safari"
-];
-function webdriverio(options = {}) {
-	return {
-		name: "webdriverio",
-		supportedBrowser: webdriverBrowsers,
-		options,
-		factory(project) {
-			return new WebdriverBrowserProvider(project, options);
-		},
-		_cli: true
-	};
-}
-class WebdriverBrowserProvider {
-	name = "webdriverio";
-	supportsParallelism = false;
-	browser = null;
-	browserName;
-	project;
-	options;
-	closing = false;
-	iframeSwitched = false;
-	topLevelContext;
-	getSupportedBrowsers() {
-		return webdriverBrowsers;
-	}
-	constructor(project, options) {
-		// increase shutdown timeout because WDIO takes some extra time to kill the driver
-		if (!project.vitest.state._data.timeoutIncreased) {
-			project.vitest.state._data.timeoutIncreased = true;
-			project.vitest.config.teardownTimeout += 1e4;
-		}
-		this.closing = false;
-		this.project = project;
-		this.browserName = project.config.browser.name;
-		this.options = options;
-	}
-	isIframeSwitched() {
-		return this.iframeSwitched;
-	}
-	async switchToTestFrame() {
-		const browser = this.browser;
-		// support wdio@9
-		if (browser.switchFrame) {
-			await browser.switchFrame(browser.$("iframe[data-vitest]"));
-		} else {
-			const iframe = await browser.findElement("css selector", "iframe[data-vitest]");
-			await browser.switchToFrame(iframe);
-		}
-		this.iframeSwitched = true;
-	}
-	async switchToMainFrame() {
-		const page = this.browser;
-		if (page.switchFrame) {
-			await page.switchFrame(null);
-		} else {
-			await page.switchToParentFrame();
-		}
-		this.iframeSwitched = false;
-	}
-	async setViewport(options) {
-		if (this.topLevelContext == null || !this.browser) {
-			throw new Error(`The browser has no open pages.`);
-		}
-		await this.browser.send({
-			method: "browsingContext.setViewport",
-			params: {
-				context: this.topLevelContext,
-				devicePixelRatio: 1,
-				viewport: options
-			}
-		});
-	}
-	getCommandsContext() {
-		return { browser: this.browser };
-	}
-	async openBrowser() {
-		await this._throwIfClosing("opening the browser");
-		if (this.browser) {
-			debug?.("[%s] the browser is already opened, reusing it", this.browserName);
-			return this.browser;
-		}
-		const options = this.project.config.browser;
-		if (this.browserName === "safari") {
-			if (options.headless) {
-				throw new Error("You've enabled headless mode for Safari but it doesn't currently support it.");
-			}
-		}
-		const { remote } = await import('webdriverio');
-		const remoteOptions = {
-			logLevel: "silent",
-			...this.options,
-			capabilities: this.buildCapabilities()
-		};
-		debug?.("[%s] opening the browser with options: %O", this.browserName, remoteOptions);
-		// TODO: close everything, if browser is closed from the outside
-		this.browser = await remote(remoteOptions);
-		await this._throwIfClosing();
-		return this.browser;
-	}
-	buildCapabilities() {
-		const capabilities = {
-			...this.options?.capabilities,
-			browserName: this.browserName
-		};
-		const headlessMap = {
-			chrome: ["goog:chromeOptions", ["headless", "disable-gpu"]],
-			firefox: ["moz:firefoxOptions", ["-headless"]],
-			edge: ["ms:edgeOptions", ["--headless"]]
-		};
-		const options = this.project.config.browser;
-		const browser = this.browserName;
-		if (browser !== "safari" && options.headless) {
-			const [key, args] = headlessMap[browser];
-			const currentValues = (this.options?.capabilities)?.[key] || {};
-			const newArgs = [...currentValues.args || [], ...args];
-			capabilities[key] = {
-				...currentValues,
-				args: newArgs
-			};
-		}
-		// start Vitest UI maximized only on supported browsers
-		if (options.ui && (browser === "chrome" || browser === "edge")) {
-			const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
-			const args = capabilities[key]?.args || [];
-			if (!args.includes("--start-maximized") && !args.includes("--start-fullscreen")) {
-				args.push("--start-maximized");
-			}
-			capabilities[key] ??= {};
-			capabilities[key].args = args;
-		}
-		const inspector = this.project.vitest.config.inspector;
-		if (inspector.enabled && (browser === "chrome" || browser === "edge")) {
-			const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
-			const args = capabilities[key]?.args || [];
-			// NodeJS equivalent defaults: https://nodejs.org/en/learn/getting-started/debugging#enable-inspector
-			const port = inspector.port || 9229;
-			const host = inspector.host || "127.0.0.1";
-			args.push(`--remote-debugging-port=${port}`);
-			args.push(`--remote-debugging-address=${host}`);
-			this.project.vitest.logger.log(`Debugger listening on ws://${host}:${port}`);
-			capabilities[key] ??= {};
-			capabilities[key].args = args;
-		}
-		return capabilities;
-	}
-	async openPage(sessionId, url) {
-		await this._throwIfClosing("creating the browser");
-		debug?.("[%s][%s] creating the browser page for %s", sessionId, this.browserName, url);
-		const browserInstance = await this.openBrowser();
-		debug?.("[%s][%s] browser page is created, opening %s", sessionId, this.browserName, url);
-		await browserInstance.url(url);
-		this.topLevelContext = await browserInstance.getWindowHandle();
-		await this._throwIfClosing("opening the url");
-	}
-	async _throwIfClosing(action) {
-		if (this.closing) {
-			debug?.(`[%s] provider was closed, cannot perform the action${action ? ` ${action}` : ""}`, this.browserName);
-			await (this.browser?.sessionId ? this.browser?.deleteSession?.() : null);
-			throw new Error(`[vitest] The provider was closed.`);
-		}
-	}
-	async close() {
-		debug?.("[%s] closing provider", this.browserName);
-		this.closing = true;
-		const browser = this.browser;
-		const sessionId = browser?.sessionId;
-		if (!browser || !sessionId) {
-			return;
-		}
-		// https://github.com/webdriverio/webdriverio/blob/ab1a2e82b13a9c7d0e275ae87e7357e1b047d8d3/packages/wdio-runner/src/index.ts#L486
-		await browser.deleteSession();
-		browser.sessionId = undefined;
-		this.browser = null;
-	}
-	async getCDPSession(_sessionId) {
-		return {
-			send: (method, params) => {
-				if (!this.browser) {
-					throw new Error(`The environment was torn down.`);
-				}
-				return this.browser.sendCommandAndGetResult(method, params ?? {}).catch((error) => {
-					return Promise.reject(new Error(`Failed to execute "${method}" command.`, { cause: error }));
-				});
-			},
-			on: () => {
-				throw new Error(`webdriverio provider doesn't support cdp.on()`);
-			},
-			once: () => {
-				throw new Error(`webdriverio provider doesn't support cdp.once()`);
-			},
-			off: () => {
-				throw new Error(`webdriverio provider doesn't support cdp.off()`);
-			}
-		};
-	}
-}
-
-export { WebdriverBrowserProvider, webdriverio };

package/dist/utils.js

@@ -1 +0,0 @@
-import"@vitest/browser/context";export{u as debug,h as getElementError,t as getElementLocatorSelectors,v as prettyDOM}from"./public-utils-B6exS8fl.js";import"vitest/internal/browser";