@vitest/browser 4.1.5 → 5.0.0-beta.2

package/dist/client/__vitest_browser__/utils-Nd8hqrhP.js

@@ -0,0 +1,189 @@
+(function polyfill() {
+  const relList = document.createElement("link").relList;
+  if (relList && relList.supports && relList.supports("modulepreload")) return;
+  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) processPreload(link);
+  new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (mutation.type !== "childList") continue;
+      for (const node of mutation.addedNodes) if (node.tagName === "LINK" && node.rel === "modulepreload") processPreload(node);
+    }
+  }).observe(document, {
+    childList: true,
+    subtree: true
+  });
+  function getFetchOpts(link) {
+    const fetchOpts = {};
+    if (link.integrity) fetchOpts.integrity = link.integrity;
+    if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
+    if (link.crossOrigin === "use-credentials") fetchOpts.credentials = "include";
+    else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
+    else fetchOpts.credentials = "same-origin";
+    return fetchOpts;
+  }
+  function processPreload(link) {
+    if (link.ep) return;
+    link.ep = true;
+    const fetchOpts = getFetchOpts(link);
+    fetch(link.href, fetchOpts);
+  }
+})();
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let 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) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              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;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+async function importId(id) {
+  const name = `/@id/${id}`.replace(/\\/g, "/");
+  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
+    /* @vite-ignore */
+    name
+  ));
+}
+async function importFs(id) {
+  const name = `/@fs/${id}`.replace(/\\/g, "/");
+  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
+    /* @vite-ignore */
+    name
+  ));
+}
+const moduleRunner = {
+  isBrowser: true,
+  import: (id) => {
+    if (id[0] === "/" || id[1] === ":") {
+      return importFs(id);
+    }
+    return importId(id);
+  }
+};
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+function getConfig() {
+  return (/* @__PURE__ */ getBrowserState()).config;
+}
+// @__NO_SIDE_EFFECTS__
+function getBrowserState() {
+  return window.__vitest_browser_runner__;
+}
+// @__NO_SIDE_EFFECTS__
+function getWorkerState() {
+  const state = window.__vitest_worker__;
+  if (!state) {
+    throw new Error("Worker state is not found. This is an issue with Vitest. Please, open an issue.");
+  }
+  return state;
+}
+export {
+  getConfig as a,
+  resolve as b,
+  getWorkerState as c,
+  getBrowserState as g,
+  moduleRunner as m,
+  now as n,
+  relative as r
+};

package/dist/client/orchestrator.html

@@ -26,8 +26,8 @@
     {__VITEST_INJECTOR__}
     {__VITEST_ERROR_CATCHER__}
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-DM4mHHP0.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-DmkAiRYk.js">
+    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-BfoS0x4w.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-Nd8hqrhP.js">
   </head>
   <body>
     <div id="vitest-tester"></div>

package/dist/client/tester/locators.d.ts

@@ -0,0 +1,69 @@
+import type { LocatorByRoleOptions, LocatorOptions, LocatorScreenshotOptions, MarkOptions, SelectorOptions, UserEventClearOptions, UserEventClickOptions, UserEventDragAndDropOptions, UserEventFillOptions, UserEventHoverOptions, UserEventSelectOptions, UserEventUploadOptions, UserEventWheelOptions } from "vitest/browser";
+import { Ivya } from "ivya";
+export { ensureAwaited } from "../utils.js";
+export { convertElementToCssSelector, getIframeScale, processTimeoutOptions } from "./tester-utils.js";
+export { getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByRoleSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector } from "ivya";
+export declare const selectorEngine: Ivya;
+export declare abstract class Locator {
+	abstract selector: string;
+	private _parsedSelector;
+	protected _container?: Element | undefined;
+	protected _pwSelector?: string | undefined;
+	protected _pwLocator?: string | undefined;
+	protected _errorSource?: Error;
+	constructor();
+	click(options?: UserEventClickOptions): Promise<void>;
+	dblClick(options?: UserEventClickOptions): Promise<void>;
+	tripleClick(options?: UserEventClickOptions): Promise<void>;
+	wheel(options: UserEventWheelOptions): 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>;
+	mark(name: string, options?: MarkOptions): Promise<void>;
+	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;
+	serialize(): SerializedLocator;
+	asLocator(): string;
+	toJSON(): SerializedLocator;
+	findElement(options_?: SelectorOptions): Promise<HTMLElement | SVGElement>;
+	protected triggerCommand<T>(command: string, ...args: any[]): Promise<T>;
+}
+export declare function triggerCommandWithTrace<T>(options: {
+	name: string;
+	arguments: unknown[];
+	errorSource?: Error | undefined;
+}): Promise<T>;
+export interface SerializedLocator {
+	selector: string;
+	locator: string;
+}

package/dist/client/tester/tester.html

@@ -5,8 +5,8 @@
     <link rel="icon" href="{__VITEST_FAVICON__}" type="image/svg+xml">
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Vitest Browser Tester</title>
-    <script type="module" crossorigin src="/__vitest_browser__/tester-Bf18VQr2.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-DmkAiRYk.js">
+    <script type="module" crossorigin src="/__vitest_browser__/tester-BJtW9QqZ.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-Nd8hqrhP.js">
   </head>
   <body>
   </body>

package/dist/client/tester/trace.d.ts

@@ -0,0 +1,54 @@
+import type { Task } from "@vitest/runner";
+import type { SerializedLocator } from "./locators.js";
+export interface BrowserTraceData {
+	retry: number;
+	repeats: number;
+	recordCanvas: boolean;
+	entries: BrowserTraceEntry[];
+}
+export type BrowserTraceEntryKind = "action" | "expect" | "mark" | "lifecycle";
+export type BrowserTraceEntryStatus = "pass" | "fail";
+export type BrowserTraceSelectorResolution = "matched" | "missing" | "error";
+export interface BrowserTraceEntry {
+	name: string;
+	kind: BrowserTraceEntryKind;
+	status?: BrowserTraceEntryStatus;
+	startTime: number;
+	duration?: number;
+	stack?: string;
+	location?: {
+		file: string;
+		line: number;
+		column: number;
+	};
+	element?: SerializedLocator;
+	snapshot: TraceSnapshot;
+}
+interface TraceSnapshot {
+	serialized: unknown;
+	viewport: {
+		width: number;
+		height: number;
+	};
+	scroll: {
+		x: number;
+		y: number;
+	};
+	selectorId?: number;
+	selectorResolution?: BrowserTraceSelectorResolution;
+	selectorError?: string;
+	pseudoClassIds: Record<PseudoClassName, number[]>;
+}
+declare const PSEUDO_CLASS_NAMES: readonly [":hover", ":active", ":focus", ":focus-visible", ":focus-within"];
+type PseudoClassName = (typeof PSEUDO_CLASS_NAMES)[number];
+export type BrowserTraceState = Record<string, BrowserTraceData>;
+export interface BrowserTraceAttempt {
+	retry: number;
+	repeats: number;
+	startTime: number;
+}
+export declare function recordBrowserTraceEntry(task: Task, options: Omit<BrowserTraceEntry, "snapshot" | "startTime"> & {
+	startTime?: number;
+}): void;
+export declare function getBrowserTrace(testId: string, repeats: number, retry: number): BrowserTraceData | undefined;
+export {};

package/dist/client.js

@@ -317,6 +317,7 @@ const stringify = (value, replacer, space) => {
   }
 };
 
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 /* @__NO_SIDE_EFFECTS__ */
 function getBrowserState() {
 	// @ts-expect-error not typed global

package/dist/context.js

@@ -1,6 +1,7 @@
 import { vi } from 'vitest';
 import { __INTERNAL, stringify } from 'vitest/internal/browser';
 
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 function ensureAwaited(promise) {
 	const test = getWorkerState().current;
 	if (!test || test.type !== "test") {
@@ -49,6 +50,105 @@ function getWorkerState() {
 	return state;
 }
 
+// rrweb-snapshot rewrites pseudo-class selectors in serialized styles so replay can
+// reproduce snapshot-time states. For example:
+//   some-selector:hover { ... }
+// becomes:
+//   some-selector:hover, some-selector.\:hover { ... }
+// Vitest side integration then adds matching pseudo-state classes in the replay DOM.
+// rrweb-snapshot only handles `:hover` upstream, so we patch it locally for the
+// other user-action pseudo-classes as well.
+// https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Selectors/Pseudo-classes#user_action_pseudo-classes
+const PSEUDO_CLASS_NAMES = [
+	":hover",
+	":active",
+	":focus",
+	":focus-visible",
+	":focus-within"
+];
+function getBrowserTraceState() {
+	return getBrowserState().browserTraceState ??= {};
+}
+function getTraceStateKey(testId, repeats, retry) {
+	return `${testId}:${repeats}:${retry}`;
+}
+// TODO: should we avoid accumulating? send and immediately clear each entry to save memory?
+function recordBrowserTraceEntry(task, options) {
+	const attemptInfo = getBrowserState().browserTraceAttempts.get(task.id);
+	const relativeStartTime = (options.startTime ?? now()) - attemptInfo.startTime;
+	const snapshot = takeSnapshot(options.element);
+	const entry = {
+		...options,
+		startTime: relativeStartTime,
+		snapshot
+	};
+	const { retry, repeats } = attemptInfo;
+	const { recordCanvas } = getBrowserState().config.browser.traceView;
+	const state = getBrowserTraceState();
+	const traceKey = getTraceStateKey(task.id, repeats, retry);
+	state[traceKey] ??= {
+		retry,
+		repeats,
+		recordCanvas,
+		entries: []
+	};
+	state[traceKey].entries.push(entry);
+}
+// Resolve ivya selector to a DOM element and take a snapshot with rrweb Mirror
+// so we can store the nodeId for provider-agnostic element highlighting in the viewer.
+// Note: Playwright's alternative approach is to store the raw selector and run the
+// selector engine inside the snapshot iframe at view time via injected script.
+// Our approach resolves at collection time (same moment as snapshot) — simpler but
+// requires Mirror plumbing. nodeId-based lookup also works across shadow DOM, unlike querySelector.
+function takeSnapshot(serializedLocator) {
+	const { snapshot, createMirror } = getBrowserState().browserTraceDomSnapshot;
+	const traceView = getBrowserState().config.browser.traceView;
+	const engine = getBrowserState().selectorEngine;
+	const mirror = createMirror();
+	const serialized = snapshot(document, {
+		mirror,
+		inlineImages: traceView.inlineImages,
+		recordCanvas: traceView.recordCanvas
+	});
+	const result = {
+		serialized,
+		viewport: {
+			width: window.innerWidth,
+			height: window.innerHeight
+		},
+		scroll: {
+			x: window.scrollX,
+			y: window.scrollY
+		},
+		pseudoClassIds: {}
+	};
+	for (const className of PSEUDO_CLASS_NAMES) {
+		const elements = document.querySelectorAll(className);
+		const ids = Array.from(elements, (el) => mirror.getId(el)).filter((id) => id !== -1);
+		result.pseudoClassIds[className] = ids;
+	}
+	if (serializedLocator) {
+		try {
+			const el = engine.querySelector(engine.parseSelector(serializedLocator._pwSelector ?? serializedLocator.selector), document.documentElement, false);
+			if (!el) {
+				result.selectorResolution = "missing";
+			} else {
+				const id = mirror.getId(el);
+				if (id !== -1) {
+					result.selectorId = id;
+					result.selectorResolution = "matched";
+				} else {
+					result.selectorResolution = "missing";
+				}
+			}
+		} catch (error) {
+			result.selectorResolution = "error";
+			result.selectorError = error instanceof Error ? error.message : String(error);
+		}
+	}
+	return result;
+}
+
 /* @__NO_SIDE_EFFECTS__ */
 function convertElementToCssSelector(element) {
 	if (!element || !(element instanceof Element)) {
@@ -121,7 +221,6 @@ function getParent(el) {
 	}
 	return parent;
 }
-const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 function processTimeoutOptions(options_) {
 	if (options_ && options_.timeout != null) {
 		return options_;
@@ -153,19 +252,28 @@ function processTimeoutOptions(options_) {
 }
 const provider$1 = getBrowserState().provider;
 const kElementLocator = Symbol.for("$$vitest:locator-resolved");
-async function convertToSelector(elementOrLocator, options) {
+async function serializeElement(elementOrLocator, options) {
 	if (!elementOrLocator) {
 		throw new Error("Expected element or locator to be defined.");
 	}
 	if (elementOrLocator instanceof Element) {
-		return convertElementToCssSelector(elementOrLocator);
+		const selector = convertElementToCssSelector(elementOrLocator);
+		return {
+			selector,
+			locator: __INTERNAL._asLocator("javascript", selector)
+		};
 	}
 	if (isLocator(elementOrLocator)) {
 		if (provider$1 === "playwright" || kElementLocator in elementOrLocator) {
-			return elementOrLocator.selector;
+			return elementOrLocator.serialize();
 		}
 		const element = await elementOrLocator.findElement(options);
-		return convertElementToCssSelector(element);
+		const selector = convertElementToCssSelector(element);
+		const locator = __INTERNAL._asLocator("javascript", selector);
+		return {
+			selector,
+			locator
+		};
 	}
 	throw new Error("Expected element or locator to be an instance of Element or Locator.");
 }
@@ -271,9 +379,9 @@ function createUserEvent(__tl_user_event_base__, options) {
 		},
 		type(element, text, options) {
 			return ensureAwaited(async (error) => {
-				const selector = await convertToSelector(element, options);
+				const serializedElement = await serializeElement(element, options);
 				const { unreleased } = await triggerCommand("__vitest_type", [
-					selector,
+					serializedElement,
 					text,
 					{
 						...options,
@@ -457,7 +565,7 @@ const page = {
 		screenshotIds[repeatCount] ??= {};
 		screenshotIds[repeatCount][taskName] = number + 1;
 		const name = options.path || `${taskName.replace(/[^a-z0-9]/gi, "-")}-${number}.png`;
-		const [element, ...mask] = await Promise.all([options.element ? convertToSelector(options.element, options) : undefined, ..."mask" in options ? options.mask.map((el) => convertToSelector(el, options)) : []]);
+		const [element, ...mask] = await Promise.all([options.element ? serializeElement(options.element, options) : undefined, ..."mask" in options ? options.mask.map((el) => serializeElement(el, options)) : []]);
 		const normalizedOptions = "mask" in options ? {
 			...options,
 			mask
@@ -473,8 +581,11 @@ const page = {
 	mark(name, bodyOrOptions, options) {
 		const currentTest = getWorkerState().current;
 		const hasActiveTrace = !!currentTest && getBrowserState().activeTraceTaskIds.has(currentTest.id);
+		const hasActiveTraceView = !!currentTest && getBrowserState().browserTraceAttempts.has(currentTest.id);
 		if (typeof bodyOrOptions === "function") {
 			return ensureAwaited(async (error) => {
+				let status = "pass";
+				const startTime = now();
 				if (hasActiveTrace) {
 					await triggerCommand("__vitest_groupTraceStart", [{
 						name,
@@ -483,20 +594,46 @@ const page = {
 				}
 				try {
 					return await bodyOrOptions();
+				} catch (err) {
+					status = "fail";
+					throw err;
 				} finally {
+					if (hasActiveTraceView) {
+						// TODO: support nested trace
+						recordBrowserTraceEntry(currentTest, {
+							name,
+							kind: "mark",
+							status,
+							startTime,
+							duration: now() - startTime,
+							stack: options?.stack ?? error?.stack
+						});
+					}
 					if (hasActiveTrace) {
 						await triggerCommand("__vitest_groupTraceEnd", [], error);
 					}
 				}
 			});
 		}
-		if (!hasActiveTrace) {
+		if (!hasActiveTrace && !hasActiveTraceView) {
 			return Promise.resolve();
 		}
-		return ensureAwaited((error) => triggerCommand("__vitest_markTrace", [{
-			name,
-			stack: bodyOrOptions?.stack ?? error?.stack
-		}], error));
+		return ensureAwaited((error) => {
+			if (hasActiveTraceView) {
+				recordBrowserTraceEntry(currentTest, {
+					name,
+					kind: "mark",
+					stack: bodyOrOptions?.stack ?? error?.stack
+				});
+			}
+			if (!hasActiveTrace) {
+				return Promise.resolve();
+			}
+			return triggerCommand("__vitest_markTrace", [{
+				name,
+				stack: bodyOrOptions?.stack ?? error?.stack
+			}], error);
+		});
 	},
 	getByRole() {
 		throw new Error(`Method "getByRole" is not supported by the "${provider}" provider.`);
@@ -616,7 +753,7 @@ function prettyDOM(dom, maxLength = Number(defaultOptions?.maxLength ?? import.m
 	return dom.outerHTML.length > maxLength ? `${pretty.slice(0, maxLength)}...` : pretty;
 }
 function getElementError(selector, container) {
-	const error = new Error(`Cannot find element with locator: ${__INTERNAL._asLocator("javascript", selector)}\n\n${prettyDOM(container)}`);
+	const error = new Error(`Cannot find element with locator: ${typeof selector === "string" ? __INTERNAL._asLocator("javascript", selector) : selector.asLocator()}\n\n${prettyDOM(container)}`);
 	error.name = "VitestBrowserElementError";
 	return error;
 }
@@ -628,7 +765,10 @@ const utils = {
 	prettyDOM,
 	debug,
 	getElementLocatorSelectors,
-	configurePrettyDOM
+	configurePrettyDOM,
+	get aria() {
+		return getBrowserState().aria;
+	}
 };
 
 export { cdp, createUserEvent, locators, page, utils };