@atomic-testing/component-driver-mui-v9 0.0.0

package/dist/index.mjs

@@ -0,0 +1,2386 @@
+import { HTMLButtonDriver, HTMLCheckboxDriver, HTMLElementDriver, HTMLRadioButtonGroupDriver, HTMLSelectDriver, HTMLTextInputDriver } from "@atomic-testing/component-driver-html";
+import { ComponentDriver, ContainerDriver, ErrorBase, ListComponentDriver, byAttribute, byCssClass, byCssSelector, byDataTestId, byInputType, byLinkedElement, byRole, byTagName, byValue, escapeUtil, listHelper, locatorUtil, timingUtil } from "@atomic-testing/core";
+//#region src/components/AccordionDriver.ts
+const parts$13 = {
+	/**
+	* The clickable area to expand/collapse the accordion.
+	*/
+	disclosure: {
+		locator: byCssClass("MuiAccordionSummary-root"),
+		driver: HTMLElementDriver
+	},
+	summary: {
+		locator: byCssClass("MuiAccordionSummary-content"),
+		driver: HTMLElementDriver
+	},
+	content: {
+		locator: byRole("region"),
+		driver: HTMLElementDriver
+	}
+};
+/**
+* Driver for Material UI v9 Accordion component.
+* @see https://mui.com/material-ui/react-accordion/
+*/
+var AccordionDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$13
+		});
+	}
+	/**
+	* Get the title/summary of the accordion.
+	* @returns The title/summary of the accordion.
+	*/
+	async getSummary() {
+		return await this.parts.summary.getText() ?? null;
+	}
+	/**
+	* Whether the accordion is expanded.
+	* @returns True if the accordion is expanded, false if collapsed.
+	*/
+	async isExpanded() {
+		await this.enforcePartExistence("disclosure");
+		return await this.parts.disclosure.getAttribute("aria-expanded") === "true";
+	}
+	/**
+	* Whether the accordion is disabled.
+	* @returns True if the accordion is disabled, false if enabled.
+	*/
+	async isDisabled() {
+		await this.enforcePartExistence("disclosure");
+		return await this.parts.disclosure.getAttribute("disabled") != null;
+	}
+	async click() {
+		await this.parts.disclosure.click();
+	}
+	/**
+	* Expand the accordion.
+	*/
+	async expand() {
+		if (!await this.isExpanded()) {
+			await this.parts.disclosure.click();
+			await timingUtil.waitUntil({
+				probeFn: () => this.isExpanded(),
+				terminateCondition: true,
+				timeoutMs: 1e3
+			});
+		}
+	}
+	/**
+	* Collapse the accordion.
+	*/
+	async collapse() {
+		if (await this.isExpanded()) {
+			await this.parts.disclosure.click();
+			await timingUtil.waitUntil({
+				probeFn: () => this.isExpanded(),
+				terminateCondition: false,
+				timeoutMs: 1e3
+			});
+		}
+	}
+	get driverName() {
+		return "MuiV9AccordionDriver";
+	}
+};
+//#endregion
+//#region src/components/AlertDriver.ts
+const parts$12 = {
+	title: {
+		locator: byCssClass("MuiAlertTitle-root"),
+		driver: HTMLElementDriver
+	},
+	message: {
+		locator: byCssClass("MuiAlert-message"),
+		driver: HTMLElementDriver
+	}
+};
+const alertSeverityEvaluators = [
+	{
+		value: "error",
+		pattern: /MuiAlert-.*Error/
+	},
+	{
+		value: "warning",
+		pattern: /MuiAlert-.*Warning/
+	},
+	{
+		value: "info",
+		pattern: /MuiAlert-.*Info/
+	},
+	{
+		value: "success",
+		pattern: /MuiAlert-.*Success/
+	}
+];
+/**
+* Driver for Material UI v9 Alert component.
+* @see https://mui.com/material-ui/react-alert/
+*/
+var AlertDriver = class extends ContainerDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$12,
+			content: option?.content ?? {}
+		});
+	}
+	async getTitle() {
+		return await this.parts.title.getText() ?? null;
+	}
+	async getMessage() {
+		return await this.parts.message.getText() ?? null;
+	}
+	async getSeverity() {
+		const cssClassString = await this.interactor.getAttribute(this.locator, "class");
+		if (cssClassString != null) {
+			const cssClasses = cssClassString.split(/\s+/);
+			for (const cssClassName of cssClasses) for (const evaluator of alertSeverityEvaluators) if (evaluator.pattern.test(cssClassName)) return evaluator.value;
+		}
+		return null;
+	}
+	get driverName() {
+		return "MuiV9AlertDriver";
+	}
+};
+//#endregion
+//#region src/components/AvatarDriver.ts
+const imageLocator = byCssSelector("img.MuiAvatar-img");
+/**
+* Driver for the Material UI v9 Avatar component.
+*
+* An Avatar renders a `.MuiAvatar-root`; with a `src` it contains an
+* `img.MuiAvatar-img`, otherwise it shows letter initials (or an icon). The
+* driver reads the image's `alt`, the presence of the image, and the letter
+* initials accordingly.
+* @see https://mui.com/material-ui/react-avatar/
+*/
+var AvatarDriver = class extends ComponentDriver {
+	get imageLocator() {
+		return locatorUtil.append(this.locator, imageLocator);
+	}
+	/**
+	* Whether the avatar renders an image (vs letter/icon fallback).
+	*/
+	async hasImage() {
+		return this.interactor.exists(this.imageLocator);
+	}
+	/**
+	* The image's alt text, or `undefined` when the avatar has no image.
+	*/
+	async getAltText() {
+		if (!await this.hasImage()) return;
+		return await this.interactor.getAttribute(this.imageLocator, "alt") ?? void 0;
+	}
+	/**
+	* The letter initials of a text avatar, or `undefined` for an image or icon
+	* avatar (which render no text).
+	*/
+	async getInitials() {
+		if (await this.hasImage()) return;
+		const text = (await this.getText())?.trim();
+		return text ? text : void 0;
+	}
+	get driverName() {
+		return "MuiV9AvatarDriver";
+	}
+};
+//#endregion
+//#region src/components/AvatarGroupDriver.ts
+const avatarItemLocator = byCssSelector(".MuiAvatarGroup-avatar");
+const surplusPattern = /^\+\d+$/;
+const defaultAvatarGroupDriverOption = {
+	itemClass: AvatarDriver,
+	itemLocator: avatarItemLocator
+};
+/**
+* Driver for the Material UI v9 AvatarGroup component.
+*
+* AvatarGroup renders up to `max` avatars plus a surplus "+N" avatar when there
+* are more. This is a {@link ListComponentDriver} over the rendered avatars
+* (surplus included via `getItems`), with helpers to count the real avatars and
+* read the surplus label.
+* @see https://mui.com/material-ui/react-avatar/#grouped
+*/
+var AvatarGroupDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...defaultAvatarGroupDriverOption,
+			...option
+		});
+	}
+	/**
+	* The number of real avatars shown, excluding the surplus "+N" indicator.
+	*/
+	async getVisibleCount() {
+		let count = 0;
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), AvatarDriver)) {
+			const text = (await item.getText())?.trim();
+			if (text == null || !surplusPattern.test(text)) count++;
+		}
+		return count;
+	}
+	/**
+	* The surplus indicator's label (e.g. "+3"), or `undefined` when every avatar
+	* fits within `max` and no surplus is shown.
+	*/
+	async getSurplusLabel() {
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), AvatarDriver)) {
+			const text = (await item.getText())?.trim();
+			if (text != null && surplusPattern.test(text)) return text;
+		}
+	}
+	get driverName() {
+		return "MuiV9AvatarGroupDriver";
+	}
+};
+//#endregion
+//#region src/components/AutoCompleteDriver.ts
+const parts$11 = {
+	input: {
+		locator: byRole("combobox"),
+		driver: HTMLTextInputDriver
+	},
+	dropdown: {
+		locator: byLinkedElement("Root").onLinkedElement(byRole("combobox")).extractAttribute("aria-controls").toMatchMyAttribute("id"),
+		driver: HTMLElementDriver
+	}
+};
+const optionLocator$1 = byRole("option");
+const noOptionsLocator = byCssClass("MuiAutocomplete-noOptions");
+const loadingLocator = byCssClass("MuiAutocomplete-loading");
+const defaultAutoCompleteDriverOption = { matchType: "exact" };
+var AutoCompleteDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$11
+		});
+		this._option = {};
+		this._option = option ?? {};
+	}
+	/**
+	* Get the display of the autocomplete
+	*/
+	async getValue() {
+		return await this.parts.input.getValue() ?? null;
+	}
+	/**
+	* Set the value of the autocomplete, how selection happens
+	* depends on the option assigned to AutoCompleteDriver
+	* By default, when the option has matchType set to exact, only option with matching text would be selected
+	* When the option has matchType set to first-available, the first option would be selected regardless of the text
+	*
+	* Option of auto complete can be set at the time of part definition, for example
+	* ```
+	* {
+	*   myAutoComplete: {
+	*     locator: byCssSelector('my-auto-complete'),
+	*     driver: AutoCompleteDriver,
+	*     option: {
+	*       matchType: 'first-available',
+	*     },
+	*   },
+	* }
+	* ```
+	*
+	* @param value
+	* @returns
+	*/
+	async setValue(value) {
+		await this.parts.input.setValue(value ?? "");
+		if (value === null) return true;
+		const option = locatorUtil.append(this.parts.dropdown.locator, optionLocator$1);
+		let index = 0;
+		const matchType = this._option?.matchType ?? defaultAutoCompleteDriverOption.matchType;
+		for await (const optionDriver of listHelper.getListItemIterator(this, option, HTMLButtonDriver)) {
+			const optionValue = await optionDriver.getText();
+			if (matchType === "exact" && optionValue?.trim() === value || matchType === "first-available" && index === 0) {
+				await optionDriver.click();
+				return true;
+			}
+			index++;
+		}
+		return false;
+	}
+	async isDisabled() {
+		return this.parts.input.isDisabled();
+	}
+	async isReadonly() {
+		return this.parts.input.isReadonly();
+	}
+	/**
+	* Whether the popup is currently showing its loading indicator (the
+	* `loadingText`). Only meaningful while the popup is open — open it first
+	* (e.g. by typing into the input), since MUI renders nothing otherwise.
+	*/
+	async isLoading() {
+		return this.interactor.exists(loadingLocator);
+	}
+	/**
+	* Whether the popup is currently showing its "no options" message. Same
+	* open-the-popup-first caveat as {@link AutoCompleteDriver.isLoading}.
+	*/
+	async hasNoOptions() {
+		return this.interactor.exists(noOptionsLocator);
+	}
+	get driverName() {
+		return "MuiV9AutoCompleteDriver";
+	}
+};
+//#endregion
+//#region src/components/BadgeDriver.ts
+const parts$10 = { contentDisplay: {
+	locator: byCssClass("MuiBadge-badge"),
+	driver: HTMLElementDriver
+} };
+/**
+* Driver for Material UI v9 Badge component.
+* @see https://mui.com/material-ui/react-badge/
+*/
+var BadgeDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$10
+		});
+	}
+	/**
+	* Get the content of the badge.
+	* @returns The content of the badge.
+	*/
+	async getContent() {
+		await this.enforcePartExistence("contentDisplay");
+		return await this.parts.contentDisplay.getText() ?? null;
+	}
+	get driverName() {
+		return "MuiV9BadgeDriver";
+	}
+};
+//#endregion
+//#region src/components/BottomNavigationActionDriver.ts
+/**
+* Driver for a single Material UI v9 BottomNavigationAction.
+*
+* Each action renders as a `<button>` (no explicit ARIA role); MUI marks the
+* active one with the `Mui-selected` state class, so selection is read from the
+* class while `getText`/`click`/`isDisabled` come from {@link HTMLButtonDriver}
+* and the base `ComponentDriver`.
+* @see https://mui.com/material-ui/react-bottom-navigation/
+*/
+var BottomNavigationActionDriver = class extends HTMLButtonDriver {
+	/**
+	* Whether this action is selected (MUI applies the `Mui-selected` state class).
+	*/
+	async isSelected() {
+		return this.interactor.hasCssClass(this.locator, "Mui-selected");
+	}
+	get driverName() {
+		return "MuiV9BottomNavigationActionDriver";
+	}
+};
+//#endregion
+//#region src/components/BottomNavigationDriver.ts
+/**
+* BottomNavigation actions are direct-child `<button>` siblings of the root (no
+* ARIA role). They are located by their `MuiBottomNavigationAction-root` class
+* rather than a bare `button` tag, so positional enumeration is not thrown off by
+* any incidental nested button inside an action.
+*/
+const defaultBottomNavigationDriverOption = {
+	itemClass: BottomNavigationActionDriver,
+	itemLocator: byCssSelector(".MuiBottomNavigationAction-root")
+};
+/**
+* Driver for the Material UI v9 BottomNavigation component.
+*
+* A {@link ListComponentDriver} over the action buttons, exposing the selected
+* index/label, selection by index/label, and per-action info, plus per-action
+* {@link BottomNavigationActionDriver} instances via `getItems`/`getItemByIndex`/
+* `getItemByLabel`.
+* @see https://mui.com/material-ui/react-bottom-navigation/
+*/
+var BottomNavigationDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...defaultBottomNavigationDriverOption,
+			...option
+		});
+	}
+	/**
+	* Every action with its label and selected state, in order.
+	*/
+	async getActions() {
+		const actions = [];
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), BottomNavigationActionDriver)) actions.push({
+			label: (await item.getText())?.trim(),
+			selected: await item.isSelected()
+		});
+		return actions;
+	}
+	/**
+	* Zero-based index of the selected action, or `-1` when none is selected.
+	*/
+	async getSelectedIndex() {
+		let index = 0;
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), BottomNavigationActionDriver)) {
+			if (await item.isSelected()) return index;
+			index++;
+		}
+		return -1;
+	}
+	/**
+	* Label of the selected action, or `null` when none is selected. Returns `null`
+	* (not `undefined`) to match the sibling `TabsDriver.getSelectedLabel` contract.
+	*/
+	async getSelectedLabel() {
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), BottomNavigationActionDriver)) if (await item.isSelected()) return (await item.getText())?.trim() ?? null;
+		return null;
+	}
+	/**
+	* Select the action at the given zero-based index.
+	* @returns `false` when the index is out of range.
+	*/
+	async selectByIndex(index) {
+		const item = await this.getItemByIndex(index);
+		if (item == null) return false;
+		await item.click();
+		return true;
+	}
+	/**
+	* Select the first action whose visible label equals `label`.
+	* @returns `false` when no action matches.
+	*/
+	async selectByLabel(label) {
+		const item = await this.getItemByLabel(label);
+		if (item == null) return false;
+		await item.click();
+		return true;
+	}
+	get driverName() {
+		return "MuiV9BottomNavigationDriver";
+	}
+};
+//#endregion
+//#region src/components/ButtonDriver.ts
+/**
+* Driver for Material UI v9 Button component.
+* @see https://mui.com/material-ui/react-button/
+*/
+var ButtonDriver = class extends HTMLButtonDriver {
+	async getValue() {
+		return await this.interactor.getAttribute(this.locator, "value") ?? null;
+	}
+	get driverName() {
+		return "MuiV9ButtonDriver";
+	}
+};
+//#endregion
+//#region src/components/CheckboxDriver.ts
+const checkboxPart = { checkbox: {
+	locator: byTagName("input"),
+	driver: HTMLCheckboxDriver
+} };
+var CheckboxDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: checkboxPart
+		});
+	}
+	isSelected() {
+		return this.parts.checkbox.isSelected();
+	}
+	async setSelected(selected) {
+		if (await this.isIndeterminate() && selected === false) await this.parts.checkbox.setSelected(true);
+		await this.parts.checkbox.setSelected(selected);
+	}
+	getValue() {
+		return this.parts.checkbox.getValue();
+	}
+	async isIndeterminate() {
+		return await this.interactor.getAttribute(this.parts.checkbox.locator, "data-indeterminate") === "true";
+	}
+	isDisabled() {
+		return this.parts.checkbox.isDisabled();
+	}
+	isReadonly() {
+		return this.parts.checkbox.isReadonly();
+	}
+	/**
+	* Get the text of the label associated with the checkbox, or `undefined` when the checkbox
+	* is rendered without one (e.g. a bare `<Checkbox>` outside of a `FormControlLabel`).
+	*
+	* MUI's `FormControlLabel` does not expose a `for`/`id` or `aria-labelledby` association; it
+	* labels the control implicitly by wrapping it in a `<label>` and rendering the text as a
+	* sibling. The label therefore lives outside this driver's own subtree, so we re-root at the
+	* enclosing `<label>` — matched against this checkbox via `:has()`, while preserving the
+	* surrounding scope — and read its text. This resolves to a single CSS selector, so it behaves
+	* identically across every interactor (DOM/React/Vue and Playwright).
+	*/
+	async getLabel() {
+		const labelLocator = this.getEnclosingLabelLocator();
+		return await this.interactor.exists(labelLocator) ? this.interactor.getText(labelLocator) : void 0;
+	}
+	/**
+	* Build a locator for the `<label>` that encloses this checkbox, scoped to the same ancestor
+	* context as the checkbox itself so that sibling checkboxes are never mismatched.
+	*/
+	getEnclosingLabelLocator() {
+		const chain = locatorUtil.toChain(this.locator);
+		const selfSelector = chain[chain.length - 1].selector;
+		return locatorUtil.append(chain.slice(0, -1), byCssSelector(`label:has(${selfSelector})`));
+	}
+	get driverName() {
+		return "MuiV9CheckboxDriver";
+	}
+};
+//#endregion
+//#region src/components/ChipDriver.ts
+const parts$9 = {
+	contentDisplay: {
+		locator: byCssClass("MuiChip-label"),
+		driver: HTMLElementDriver
+	},
+	removeButton: {
+		locator: byDataTestId("CancelIcon"),
+		driver: HTMLElementDriver
+	}
+};
+/**
+* Driver for Material UI v9 Chip component.
+* @see https://mui.com/material-ui/react-chip/
+*/
+var ChipDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$9
+		});
+	}
+	/**
+	* Get the label content of the chip.
+	* @returns The label text content of the chip.
+	*/
+	async getLabel() {
+		await this.enforcePartExistence("contentDisplay");
+		return await this.parts.contentDisplay.getText() ?? null;
+	}
+	async clickRemove() {
+		await this.enforcePartExistence("removeButton");
+		await this.parts.removeButton.click();
+	}
+	get driverName() {
+		return "MuiV9ChipDriver";
+	}
+};
+//#endregion
+//#region src/components/DialogDriver.ts
+const parts$8 = {
+	title: {
+		locator: byCssClass("MuiDialogTitle-root"),
+		driver: HTMLElementDriver
+	},
+	dialogContainer: {
+		locator: byRole("presentation"),
+		driver: HTMLElementDriver
+	}
+};
+const dialogRootLocator = byRole("presentation", "Root");
+const defaultTransitionDuration$1 = 250;
+var DialogDriver = class extends ContainerDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$8,
+			content: option?.content ?? {}
+		});
+	}
+	overriddenParentLocator() {
+		return dialogRootLocator;
+	}
+	overrideLocatorRelativePosition() {
+		return "Same";
+	}
+	async getTitle() {
+		await this.enforcePartExistence("title");
+		return await this.parts.title.getText() ?? null;
+	}
+	/**
+	* Dismiss the dialog by clicking outside its content, then wait for it to close.
+	*
+	* MUI's "backdrop click" is handled on the `.MuiDialog-container` surface (which
+	* overlays the visual `.MuiBackdrop-root`), firing `onClose` only when the click
+	* target is the container itself. The click therefore lands on the container near
+	* its top-left corner to avoid the centered paper. Whether it actually closes
+	* depends on the consumer's `onClose` handling (MUI reports a `"backdropClick"`
+	* reason); the returned boolean reflects the observed close, not merely the click.
+	*
+	* @param timeoutMs How long to wait for the close transition to finish
+	* @returns true if the dialog closed
+	*/
+	async closeByBackdropClick(timeoutMs = defaultTransitionDuration$1) {
+		await this.enforcePartExistence("dialogContainer");
+		const cornerClick = { position: {
+			x: 5,
+			y: 5
+		} };
+		await this.parts.dialogContainer.mouseDown(cornerClick);
+		await this.parts.dialogContainer.mouseUp(cornerClick);
+		await this.parts.dialogContainer.click(cornerClick);
+		return this.waitForClose(timeoutMs);
+	}
+	/**
+	* Wait for dialog to open
+	* @param timeoutMs
+	* @returns true open has performed successfully
+	*/
+	async waitForOpen(timeoutMs = defaultTransitionDuration$1) {
+		return await this.interactor.waitUntil({
+			probeFn: () => this.isOpen(),
+			terminateCondition: true,
+			timeoutMs
+		}) === true;
+	}
+	/**
+	* Wait for dialog to close
+	* @param timeoutMs
+	* @returns true open has performed successfully
+	*/
+	async waitForClose(timeoutMs = defaultTransitionDuration$1) {
+		return await this.interactor.waitUntil({
+			probeFn: () => this.isOpen(),
+			terminateCondition: false,
+			timeoutMs
+		}) === false;
+	}
+	/**
+	* Check if the dialog box is open.  Caution, because of animation, upon an open/close action is performed
+	* use waitForOpen() or waitForClose() before using isOpen() would result a more accurate open state of the dialog
+	* @returns true if dialog box is open
+	*/
+	async isOpen() {
+		if (!await this.exists()) return false;
+		return await this.interactor.isVisible(this.parts.dialogContainer.locator);
+	}
+	get driverName() {
+		return "MuiV9DialogDriver";
+	}
+};
+//#endregion
+//#region src/components/OverlayDriver.ts
+const backdropLocator = byCssClass("MuiBackdrop-root");
+const defaultTransitionDuration = 250;
+/**
+* Shared base for MUI portal-rendered overlays (Drawer today; Dialog, Menu,
+* Popover and SpeedDial are prospective consumers). It owns the open/close
+* lifecycle that {@link DialogDriver} first proved out: `isOpen` derived from the
+* visible surface, `waitForOpen`/`waitForClose` spanning the transition, and
+* `closeByBackdrop`.
+*
+* Subclasses supply {@link getSurfaceLocator} (the element whose visibility means
+* "open") and, when the overlay is portal-rendered, override
+* `overriddenParentLocator()`/`overrideLocatorRelativePosition()` to re-root.
+*
+* `closeByEscape` is intentionally absent: keyboard dismissal needs a key-press
+* primitive the `Interactor` interface does not yet expose, which would have to be
+* added to every interactor (DOM/React/Vue/Playwright). It is deferred rather than
+* partially implemented.
+*/
+var OverlayDriver = class extends ContainerDriver {
+	/**
+	* Locator of the dismissible backdrop. Defaults to MUI's `.MuiBackdrop-root`.
+	*/
+	getBackdropLocator() {
+		return locatorUtil.append(this.locator, backdropLocator);
+	}
+	/**
+	* Whether the overlay is mounted and its surface is visible. Because of open/close
+	* transitions, prefer `waitForOpen()`/`waitForClose()` immediately after an action.
+	*/
+	async isOpen() {
+		if (!await this.exists()) return false;
+		return this.interactor.isVisible(this.getSurfaceLocator());
+	}
+	/**
+	* Wait until the overlay is open.
+	* @returns true once open within the timeout.
+	*/
+	async waitForOpen(timeoutMs = defaultTransitionDuration) {
+		return await this.interactor.waitUntil({
+			probeFn: () => this.isOpen(),
+			terminateCondition: true,
+			timeoutMs
+		}) === true;
+	}
+	/**
+	* Wait until the overlay is closed.
+	* @returns true once closed within the timeout.
+	*/
+	async waitForClose(timeoutMs = defaultTransitionDuration) {
+		if (await this.interactor.waitUntil({
+			probeFn: () => this.isOpen(),
+			terminateCondition: false,
+			timeoutMs
+		}) === false) return true;
+		return !await this.isOpen();
+	}
+	/**
+	* Dismiss by clicking the backdrop, then wait for the close transition. Whether
+	* it actually closes depends on the consumer honoring the backdrop dismissal; the
+	* returned boolean reflects the observed close, not merely the click.
+	*/
+	async closeByBackdrop(timeoutMs = defaultTransitionDuration) {
+		const backdrop = this.getBackdropLocator();
+		if (await this.interactor.exists(backdrop)) await this.interactor.click(backdrop);
+		return this.waitForClose(timeoutMs);
+	}
+};
+//#endregion
+//#region src/components/DrawerDriver.ts
+const drawerParts = { paper: {
+	locator: byCssClass("MuiDrawer-paper"),
+	driver: HTMLElementDriver
+} };
+const anchorClassByAnchor = {
+	left: "MuiDrawer-anchorLeft",
+	right: "MuiDrawer-anchorRight",
+	top: "MuiDrawer-anchorTop",
+	bottom: "MuiDrawer-anchorBottom"
+};
+const drawerRootLocator = byRole("presentation", "Root");
+/**
+* Driver for the Material UI v9 Drawer (and SwipeableDrawer) component.
+*
+* A temporary Drawer is a portal-rendered Modal: its root `role="presentation"`
+* (`.MuiDrawer-root`) carries the anchor class and holds a `.MuiBackdrop-root` plus
+* the `.MuiDrawer-paper` panel. Open/close/backdrop behavior is inherited from
+* {@link OverlayDriver}; this driver adds the anchor read and the portal re-rooting.
+* @see https://mui.com/material-ui/react-drawer/
+*/
+var DrawerDriver = class extends OverlayDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: drawerParts,
+			content: option?.content ?? {}
+		});
+	}
+	overriddenParentLocator() {
+		return drawerRootLocator;
+	}
+	overrideLocatorRelativePosition() {
+		return "Same";
+	}
+	getSurfaceLocator() {
+		return this.parts.paper.locator;
+	}
+	/**
+	* The side the drawer is anchored to, read from the portal root's anchor class, or
+	* `undefined` when the drawer is closed/unmounted.
+	*
+	* The anchor class sits on the `role="presentation"` root itself, so it is read
+	* directly off {@link drawerRootLocator} rather than through a part (parts resolve
+	* as descendants of that root, but the class is on the root).
+	*/
+	async getAnchor() {
+		if (!await this.interactor.exists(drawerRootLocator)) return;
+		for (const anchor of Object.keys(anchorClassByAnchor)) if (await this.interactor.hasCssClass(drawerRootLocator, anchorClassByAnchor[anchor])) return anchor;
+	}
+	get driverName() {
+		return "MuiV9DrawerDriver";
+	}
+};
+//#endregion
+//#region src/components/FabDriver.ts
+/**
+* Driver for Material UI v9 Floating Action Button component.
+* @see https://mui.com/material-ui/react-floating-action-button/
+*/
+var FabDriver = class extends ButtonDriver {
+	get driverName() {
+		return "MuiV9FabDriver";
+	}
+};
+//#endregion
+//#region src/components/InputDriver.ts
+const parts$7 = {
+	singlelineInput: {
+		locator: byCssSelector("input:not([aria-hidden])"),
+		driver: HTMLTextInputDriver
+	},
+	multilineInput: {
+		locator: byCssSelector("textarea:not([aria-hidden])"),
+		driver: HTMLTextInputDriver
+	}
+};
+/**
+* A driver for the Material UI v9 Input, FilledInput, OutlinedInput, and StandardInput components.
+*/
+var InputDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$7
+		});
+	}
+	async getInputType() {
+		if (await this.interactor.exists(this.parts.singlelineInput.locator)) return "singleLine";
+		if (await this.interactor.exists(this.parts.multilineInput.locator)) return "multiline";
+		throw new Error("Unable to determine input type in TextFieldInput");
+	}
+	/**
+	* Retrieve the current value of the input element, handling both single line
+	* and multiline configurations.
+	*/
+	async getValue() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.getValue();
+			case "multiline": return this.parts.multilineInput.getValue();
+		}
+	}
+	/**
+	* Set the value of the underlying input element.
+	*
+	* @param value The text to assign to the input.
+	*/
+	async setValue(value) {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.setValue(value);
+			case "multiline": return this.parts.multilineInput.setValue(value);
+		}
+	}
+	/**
+	* Determine whether the input element is disabled.
+	*/
+	async isDisabled() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.isDisabled();
+			case "multiline": return this.parts.multilineInput.isDisabled();
+		}
+	}
+	/**
+	* Determine whether the input element is read only.
+	*/
+	async isReadonly() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.isReadonly();
+			case "multiline": return this.parts.multilineInput.isReadonly();
+		}
+	}
+	/**
+	* Identifier for this driver.
+	*/
+	get driverName() {
+		return "MuiV9InputDriver";
+	}
+};
+//#endregion
+//#region src/errors/MenuItemDisabledError.ts
+const MenuItemDisabledErrorId = "MenuItemDisabledError";
+function getErrorMessage$1(label) {
+	return `The menu item with label: ${label} is disabled`;
+}
+var MenuItemDisabledError = class extends ErrorBase {
+	constructor(label, driver) {
+		super(getErrorMessage$1(label), driver);
+		this.label = label;
+		this.driver = driver;
+		this.name = MenuItemDisabledErrorId;
+	}
+};
+//#endregion
+//#region src/components/ListItemDriver.ts
+/**
+* @internal
+*/
+var ListItemDriver = class extends ComponentDriver {
+	async label() {
+		return (await this.getText())?.trim() || null;
+	}
+	async isSelected() {
+		return await this.interactor.hasCssClass(this.locator, "Mui-selected");
+	}
+	async isDisabled() {
+		return await this.interactor.getAttribute(this.locator, "aria-disabled") === "true";
+	}
+	async click() {
+		if (await this.isDisabled()) throw new MenuItemDisabledError(await this.label() ?? "", this);
+		await this.interactor.click(this.locator);
+	}
+	get driverName() {
+		return "MuiV9ListItemDriver";
+	}
+};
+//#endregion
+//#region src/components/ListDriver.ts
+const defaultListDriverOption = {
+	itemClass: ListItemDriver,
+	itemLocator: byRole("option")
+};
+var ListDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = { ...defaultListDriverOption }) {
+		super(locator, interactor, option);
+	}
+	async getSelected() {
+		for await (const item of listHelper.getListItemIterator(this, this.getItemLocator(), ListItemDriver)) if (await item.isSelected()) return item;
+		return null;
+	}
+	get driverName() {
+		return "MuiV9ListDriver";
+	}
+};
+//#endregion
+//#region src/errors/MenuItemNotFoundError.ts
+const MenuItemNotFoundErrorId = "MenuItemNotFoundError";
+function getErrorMessage(label) {
+	return `Cannot find menu item with label: ${label}`;
+}
+var MenuItemNotFoundError = class extends ErrorBase {
+	constructor(label, driver) {
+		super(getErrorMessage(label), driver);
+		this.label = label;
+		this.driver = driver;
+		this.name = MenuItemNotFoundErrorId;
+	}
+};
+//#endregion
+//#region src/components/MenuItemDriver.ts
+/**
+* @internal
+*/
+var MenuItemDriver = class extends ListItemDriver {
+	async value() {
+		return await this.interactor.getAttribute(this.locator, "data-value") ?? null;
+	}
+	get driverName() {
+		return "MuiV9MenuItemDriver";
+	}
+};
+//#endregion
+//#region src/components/MenuDriver.ts
+const parts$6 = { menu: {
+	locator: byRole("menu"),
+	driver: HTMLElementDriver
+} };
+const menuRootLocator = byRole("presentation", "Root");
+const menuItemLocator = byRole("menuitem");
+var MenuDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$6
+		});
+	}
+	overriddenParentLocator() {
+		return menuRootLocator;
+	}
+	overrideLocatorRelativePosition() {
+		return "Same";
+	}
+	async getMenuItemByLabel(label) {
+		for await (const item of listHelper.getListItemIterator(this, menuItemLocator, MenuItemDriver)) if (await item.label() === label) return item;
+		return null;
+	}
+	async selectByLabel(label) {
+		const item = await this.getMenuItemByLabel(label);
+		if (item) await item.click();
+		else throw new MenuItemNotFoundError(label, this);
+	}
+	get driverName() {
+		return "MuiV9MenuDriver";
+	}
+};
+//#endregion
+//#region src/components/PaginationDriver.ts
+const pageItemLocator = byCssSelector(".MuiPaginationItem-page");
+const selectedPageLocator = byCssSelector("[aria-current]");
+const firstButtonLocator = byAttribute("aria-label", "Go to first page");
+const previousButtonLocator$1 = byAttribute("aria-label", "Go to previous page");
+const nextButtonLocator$1 = byAttribute("aria-label", "Go to next page");
+const lastButtonLocator = byAttribute("aria-label", "Go to last page");
+/**
+* Driver for the Material UI v9 Pagination component.
+*
+* Pagination renders a `<nav>` whose `MuiPaginationItem` buttons are each wrapped
+* in their own `<li>` (so they are not siblings — positional `:nth-of-type`
+* iteration does not apply). Page controls are read by their accessible name
+* instead: every page button's aria-label ends in its page number ("Go to page N",
+* or "page N" once selected), and first/previous/next/last carry stable
+* aria-labels and become `disabled` at the bounds.
+* @see https://mui.com/material-ui/react-pagination/
+*/
+var PaginationDriver = class extends ComponentDriver {
+	get pageItemsLocator() {
+		return locatorUtil.append(this.locator, pageItemLocator);
+	}
+	/**
+	* The selected page number, or `-1` when no page is marked current.
+	*/
+	async getSelectedPage() {
+		const locator = locatorUtil.append(this.locator, selectedPageLocator);
+		if (!await this.interactor.exists(locator)) return -1;
+		const text = await this.interactor.getText(locator);
+		const page = Number.parseInt(text?.trim() ?? "", 10);
+		return Number.isNaN(page) ? -1 : page;
+	}
+	/**
+	* Total number of pages, taken from the highest numbered page control. MUI
+	* always renders the upper boundary page (boundaryCount >= 1), so this is exact
+	* even when middle pages collapse into an ellipsis.
+	*/
+	async getPageCount() {
+		const labels = await this.interactor.getAttribute(this.pageItemsLocator, "aria-label", true);
+		let max = 0;
+		for (const label of labels) {
+			const match = label?.match(/(\d+)\s*$/);
+			if (match != null) {
+				const page = Number.parseInt(match[1], 10);
+				if (page > max) max = page;
+			}
+		}
+		return max;
+	}
+	/**
+	* Click the numbered control for `page`. A no-op (returns `true`) when `page` is
+	* already selected.
+	* @returns `false` when that page is not currently rendered (e.g. hidden behind
+	* an ellipsis) or is disabled.
+	*/
+	async goToPage(page) {
+		if (await this.getSelectedPage() === page) return true;
+		const locator = locatorUtil.append(this.locator, byAttribute("aria-label", `Go to page ${page}`));
+		if (!await this.interactor.exists(locator) || await this.interactor.isDisabled(locator)) return false;
+		await this.interactor.click(locator);
+		return true;
+	}
+	/**
+	* Click a navigation control unless it is absent or disabled (at a bound).
+	* @returns whether the click was performed.
+	*/
+	async clickNavButton(navLocator) {
+		const locator = locatorUtil.append(this.locator, navLocator);
+		if (!await this.interactor.exists(locator) || await this.interactor.isDisabled(locator)) return false;
+		await this.interactor.click(locator);
+		return true;
+	}
+	/** Go to the next page. Returns `false` when on the last page or the control is hidden. */
+	async next() {
+		return this.clickNavButton(nextButtonLocator$1);
+	}
+	/** Go to the previous page. Returns `false` when on the first page or the control is hidden. */
+	async previous() {
+		return this.clickNavButton(previousButtonLocator$1);
+	}
+	/** Jump to the first page. Returns `false` when already there or the control is hidden (needs `showFirstButton`). */
+	async first() {
+		return this.clickNavButton(firstButtonLocator);
+	}
+	/** Jump to the last page. Returns `false` when already there or the control is hidden (needs `showLastButton`). */
+	async last() {
+		return this.clickNavButton(lastButtonLocator);
+	}
+	get driverName() {
+		return "MuiV9PaginationDriver";
+	}
+};
+//#endregion
+//#region src/components/ProgressDriver.ts
+const parts$5 = { choices: {
+	locator: byInputType("radio"),
+	driver: HTMLRadioButtonGroupDriver
+} };
+var ProgressDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$5
+		});
+	}
+	async getValue() {
+		const rawValue = await this.getAttribute("aria-valuenow");
+		const numValue = Number(rawValue);
+		if (rawValue == null || isNaN(numValue)) return null;
+		return Number(rawValue);
+	}
+	async getType() {
+		if ((await this.getAttribute("class"))?.includes("MuiCircularProgress-root")) return "circular";
+		return "linear";
+	}
+	async isDeterminate() {
+		return await this.getValue() != null;
+	}
+	async setValue(value) {
+		const currentValue = await this.getValue();
+		if (value === currentValue) return true;
+		const valueToClick = value == null ? currentValue : value;
+		const targetLocator = locatorUtil.append(this.parts.choices.locator, byValue(valueToClick.toString(), "Same"));
+		const targetExists = await this.interactor.exists(targetLocator);
+		if (targetExists) {
+			const id = await this.interactor.getAttribute(targetLocator, "id");
+			const labelLocator = locatorUtil.append(this.locator, byCssSelector(`label[for="${id}"]`));
+			await this.interactor.click(labelLocator);
+		}
+		return targetExists;
+	}
+	get driverName() {
+		return "MuiV9ProgressDriver";
+	}
+};
+//#endregion
+//#region src/components/RadioDriver.ts
+const inputLocator = byCssSelector("input");
+const checkedInputLocator = byCssSelector("input:checked");
+/**
+* Driver for a single Material UI v9 Radio option (a `FormControlLabel` wrapping a
+* `Radio`). Its label text is the `FormControlLabel`'s text; selected/value/disabled
+* state is read from the underlying radio `<input>`.
+*
+* Used as the item driver of {@link RadioGroupDriver}, but also usable on its own
+* when a single radio option is addressed directly. It declares no parts (so it
+* composes as a list item) and reads the input via descendant locators.
+* @see https://mui.com/material-ui/react-radio-button/
+*/
+var RadioDriver = class extends ComponentDriver {
+	get input() {
+		return locatorUtil.append(this.locator, inputLocator);
+	}
+	/**
+	* The option's visible label, or `undefined` when it renders without text.
+	*/
+	async getLabel() {
+		return (await this.getText())?.trim() || void 0;
+	}
+	/**
+	* The option's `value` attribute.
+	*/
+	async getValue() {
+		return await this.interactor.getAttribute(this.input, "value") ?? null;
+	}
+	/**
+	* Whether this option is the selected one in its group.
+	*/
+	isSelected() {
+		return this.interactor.exists(locatorUtil.append(this.locator, checkedInputLocator));
+	}
+	/**
+	* Whether this option is disabled.
+	*/
+	isDisabled() {
+		return this.interactor.isDisabled(this.input);
+	}
+	/**
+	* Select this option by clicking its radio input. No-op effect when already selected.
+	*/
+	async select() {
+		await this.interactor.click(this.input);
+	}
+	get driverName() {
+		return "MuiV9RadioDriver";
+	}
+};
+//#endregion
+//#region src/components/RadioGroupDriver.ts
+/**
+* Radio options are located by their `FormControlLabel` root, which wraps the
+* radio `<input>` and renders the label text — the unit a {@link RadioDriver}
+* drives.
+*/
+const defaultRadioGroupDriverOption = {
+	itemClass: RadioDriver,
+	itemLocator: byCssSelector(".MuiFormControlLabel-root")
+};
+/**
+* Driver for the Material UI v9 RadioGroup component.
+*
+* `<RadioGroup>` renders a `role="radiogroup"` whose options are `FormControlLabel`s
+* wrapping a radio `<input>`. This driver is a {@link ListComponentDriver} over those
+* options, so per-option {@link RadioDriver} instances are available via
+* `getItems`/`getItemByIndex`/`getItemByLabel`, on top of the group-level value and
+* label helpers. The selected value is read from the checked `<input>` and selection
+* is made by value or label.
+* @see https://mui.com/material-ui/react-radio-button/
+*/
+var RadioGroupDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...defaultRadioGroupDriverOption,
+			...option
+		});
+	}
+	/**
+	* The `value` of the selected option, or `null` when none is selected.
+	*/
+	async getValue() {
+		const checked = locatorUtil.append(this.locator, byCssSelector("input:checked"));
+		return await this.interactor.getAttribute(checked, "value") ?? null;
+	}
+	/**
+	* Select the option whose radio `<input>` has the given `value`.
+	* @returns `false` when no option has that value, or when `value` is `null`.
+	*/
+	async setValue(value) {
+		if (value == null) return false;
+		const input = locatorUtil.append(this.locator, byCssSelector(`input[value="${escapeUtil.escapeValue(value)}"]`));
+		if (!await this.interactor.exists(input)) return false;
+		await this.interactor.click(input);
+		return true;
+	}
+	/**
+	* The visible label of every option, in DOM order.
+	*/
+	async getOptions() {
+		const items = await this.getItems();
+		const labels = [];
+		for (const item of items) labels.push(await item.getLabel() ?? "");
+		return labels;
+	}
+	/**
+	* The label of the selected option, or `null` when none is selected.
+	*/
+	async getSelectedLabel() {
+		const items = await this.getItems();
+		for (const item of items) if (await item.isSelected()) return await item.getLabel() ?? null;
+		return null;
+	}
+	/**
+	* Select the first option whose visible label equals `label`.
+	* @returns `false` when no option matches.
+	*/
+	async selectByLabel(label) {
+		const option = await this.getItemByLabel(label);
+		if (option == null) return false;
+		await option.select();
+		return true;
+	}
+	/**
+	* Whether the option with the given label is disabled.
+	* @returns `false` when no option matches.
+	*/
+	async isOptionDisabled(label) {
+		const option = await this.getItemByLabel(label);
+		return option == null ? false : option.isDisabled();
+	}
+	get driverName() {
+		return "MuiV9RadioGroupDriver";
+	}
+};
+//#endregion
+//#region src/components/RatingDriver.ts
+const parts$4 = { choices: {
+	locator: byInputType("radio"),
+	driver: HTMLRadioButtonGroupDriver
+} };
+/**
+* MUI marks the disabled/read-only state with a class on the Rating root span
+* (`Mui-disabled` / `Mui-readOnly`), not on the visually-hidden radio inputs that
+* the composed {@link HTMLRadioButtonGroupDriver} can see — so these states are
+* only observable from the root element.
+*/
+const disabledClassName = "Mui-disabled";
+const readOnlyClassName = "Mui-readOnly";
+const filledIconClassName = "MuiRating-iconFilled";
+var RatingDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$4
+		});
+	}
+	async getValue() {
+		if (await this.interactor.hasCssClass(this.locator, readOnlyClassName)) return this.getReadOnlyValue();
+		await this.enforcePartExistence("choices");
+		const value = await this.parts.choices.getValue();
+		if (value == null || value === "") return null;
+		return parseFloat(value);
+	}
+	/**
+	* Read the value of a read-only Rating.
+	*
+	* Primary source is the root's `aria-label`, which MUI populates with the accessible
+	* name (e.g. `"2.5 Stars"`) — accessibility-first and precision-accurate. When a
+	* caller supplies a custom, non-numeric `aria-label`, fall back to counting the
+	* filled star icons; that count is exact for whole-star ratings.
+	*/
+	async getReadOnlyValue() {
+		const label = await this.interactor.getAttribute(this.locator, "aria-label");
+		if (label != null) {
+			const parsed = parseFloat(label);
+			if (!Number.isNaN(parsed)) return parsed;
+		}
+		const filledLocator = locatorUtil.append(this.locator, byCssClass(filledIconClassName));
+		const filledIcons = await this.interactor.getAttribute(filledLocator, "class", true);
+		return filledIcons.length > 0 ? filledIcons.length : null;
+	}
+	/**
+	* Whether the Rating is disabled. `disabled` is reflected as the `Mui-disabled`
+	* class on the root span (the composed radio-group driver exposes no `isDisabled`).
+	*/
+	async isDisabled() {
+		return this.interactor.hasCssClass(this.locator, disabledClassName);
+	}
+	async setValue(value) {
+		const currentValue = await this.getValue();
+		if (value === currentValue) return true;
+		const valueToClick = value ?? currentValue;
+		if (valueToClick == null) return true;
+		const targetLocator = locatorUtil.append(this.parts.choices.locator, byValue(valueToClick.toString(), "Same"));
+		const targetExists = await this.interactor.exists(targetLocator);
+		if (targetExists) {
+			const id = await this.interactor.getAttribute(targetLocator, "id");
+			const labelLocator = locatorUtil.append(this.locator, byCssSelector(`label[for="${id}"]`));
+			await this.interactor.click(labelLocator);
+		}
+		return targetExists;
+	}
+	get driverName() {
+		return "MuiV9RatingDriver";
+	}
+};
+//#endregion
+//#region src/components/SelectDriver.ts
+const selectPart = {
+	trigger: {
+		locator: byRole("combobox"),
+		driver: HTMLButtonDriver
+	},
+	dropdown: {
+		locator: byCssSelector("[role=presentation] [role=listbox]", "Root"),
+		driver: HTMLElementDriver
+	},
+	input: {
+		locator: byTagName("input"),
+		driver: HTMLTextInputDriver
+	},
+	nativeSelect: {
+		locator: byTagName("select"),
+		driver: HTMLSelectDriver
+	}
+};
+const optionLocator = byRole("option");
+var SelectDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: selectPart
+		});
+	}
+	async isNative() {
+		const nativeSelectExists = await this.interactor.exists(this.parts.nativeSelect.locator);
+		return Promise.resolve(nativeSelectExists);
+	}
+	async getValue() {
+		if (await this.isNative()) return await this.parts.nativeSelect.getValue();
+		await this.enforcePartExistence("input");
+		return await this.parts.input.getValue() ?? null;
+	}
+	async setValue(value) {
+		let success = false;
+		if (await this.isNative()) {
+			success = await this.parts.nativeSelect.setValue(value);
+			return success;
+		}
+		await this.openDropdown();
+		await this.enforcePartExistence("dropdown");
+		const optionSelector = byAttribute("data-value", value);
+		const optionLocator = locatorUtil.append(this.parts.dropdown.locator, optionSelector);
+		if (await this.interactor.exists(optionLocator)) {
+			await this.interactor.click(optionLocator);
+			success = true;
+		}
+		return success;
+	}
+	/**
+	* Select menu item by its label, if it exists
+	* Limitation, this method will not work if the dropdown is a native select.
+	* @param label
+	* @returns
+	*/
+	async getMenuItemByLabel(label, option) {
+		if (!option?.skipDropdownCheck) await this.openDropdown();
+		for await (const item of listHelper.getListItemIterator(this, optionLocator, MenuItemDriver)) if (await item.label() === label) return item;
+		return null;
+	}
+	/**
+	* Selects an option by its label
+	* @param label
+	* @returns
+	*/
+	async selectByLabel(label) {
+		if (await this.isNative()) {
+			await this.parts.nativeSelect.selectByLabel(label);
+			return;
+		}
+		await this.enforcePartExistence("trigger");
+		await this.parts.trigger.click();
+		await this.enforcePartExistence("dropdown");
+		const item = await this.getMenuItemByLabel(label, { skipDropdownCheck: true });
+		if (item) await item.click();
+		else throw new MenuItemNotFoundError(label, this);
+	}
+	async getSelectedLabel() {
+		if (await this.isNative()) return await this.parts.nativeSelect.getSelectedLabel();
+		await this.enforcePartExistence("trigger");
+		return await this.parts.trigger.getText() ?? null;
+	}
+	async exists() {
+		if (await this.interactor.exists(this.parts.trigger.locator)) return true;
+		return await this.interactor.exists(this.parts.nativeSelect.locator);
+	}
+	/**
+	* Check if the dropdown is open, or if it is a native select, it is always open because there is no known way check its open state
+	* @returns For native dropdown it is always true. For custom dropdown, it is true if the dropdown is open.
+	*/
+	async isDropdownOpen() {
+		if (await this.isNative()) return true;
+		else return this.parts.dropdown.exists();
+	}
+	async openDropdown() {
+		if (await this.isDropdownOpen()) return;
+		await this.parts.trigger.click();
+	}
+	async closeDropdown() {
+		if (!await this.isDropdownOpen()) return;
+		await this.parts.trigger.click();
+	}
+	async isDisabled() {
+		if (await this.isNative()) return this.parts.nativeSelect.isDisabled();
+		else {
+			await this.enforcePartExistence("trigger");
+			return await this.interactor.getAttribute(this.parts.trigger.locator, "aria-disabled") === "true";
+		}
+	}
+	async isReadonly() {
+		if (await this.isNative()) return this.parts.nativeSelect.isReadonly();
+		else return false;
+	}
+	get driverName() {
+		return "MuiV9SelectDriver";
+	}
+};
+//#endregion
+//#region src/components/SliderDriver.ts
+const parts$3 = { input: {
+	locator: byCssSelector("input[type=\"range\"][data-index=\"0\"]"),
+	driver: HTMLTextInputDriver
+} };
+var SliderDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$3
+		});
+	}
+	/**
+	* Return the first occurrence of the Slider input
+	* @returns
+	*/
+	async getValue() {
+		return (await this.getRangeValues(1))[0];
+	}
+	/**
+	* Set slider's range value.  Do not use as it will throw an error
+	* @param values
+	* @see https://github.com/atomic-testing/atomic-testing/issues/73
+	*/
+	async setValue(value) {
+		return await this.setRangeValues([value]);
+	}
+	async getRangeValues(count) {
+		await this.enforcePartExistence("input");
+		const result = [];
+		let index = 0;
+		let done = false;
+		while (!done) {
+			const locator = locatorUtil.append(this.locator, this.getInputLocator(index));
+			if (await this.interactor.exists(locator)) {
+				index++;
+				done = count != null && index >= count;
+				const value = await this.interactor.getAttribute(locator, "value");
+				result.push(parseFloat(value));
+			} else done = true;
+		}
+		return result;
+	}
+	getInputLocator(index) {
+		return byCssSelector(`input[type="range"][data-index="${index}"]`);
+	}
+	/**
+	* Set slider's range values.  Do not use as it will throw an error
+	* @param values
+	* @see https://github.com/atomic-testing/atomic-testing/issues/73
+	*/
+	async setRangeValues(_values) {
+		await this.enforcePartExistence("input");
+		throw new Error("setRangeValue is not supported.");
+	}
+	async isDisabled() {
+		await this.enforcePartExistence("input");
+		return await this.parts.input.isDisabled();
+	}
+	get driverName() {
+		return "MuiV9SliderDriver";
+	}
+};
+//#endregion
+//#region src/components/SnackbarDriver.ts
+const parts$2 = {
+	contentDisplay: {
+		locator: byCssClass("MuiSnackbarContent-message"),
+		driver: HTMLElementDriver
+	},
+	actionArea: {
+		locator: byCssClass("MuiSnackbarContent-action"),
+		driver: HTMLElementDriver
+	}
+};
+/**
+* Driver for Material UI v9 Snackbar component.
+* @see https://mui.com/material-ui/react-snackbar/
+*/
+var SnackbarDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$2
+		});
+	}
+	/**
+	* Get the label content of the snackbar.
+	* @returns The label text content of the snackbar.
+	*/
+	async getLabel() {
+		await this.enforcePartExistence("contentDisplay");
+		return await this.parts.contentDisplay.getText() ?? null;
+	}
+	/**
+	* Get a driver instance of a component in the action area of the snackbar.
+	* @param locator
+	* @param driverClass
+	* @returns
+	*/
+	async getActionComponent(locator, driverClass) {
+		await this.enforcePartExistence("actionArea");
+		const componentLocator = locatorUtil.append(this.parts.actionArea.locator, locator);
+		if (await this.interactor.exists(componentLocator)) return new driverClass(componentLocator, this.interactor, this.commutableOption);
+		return null;
+	}
+	get driverName() {
+		return "MuiV9SnackbarDriver";
+	}
+};
+//#endregion
+//#region src/components/SpeedDialDriver.ts
+const fabLocator = byCssSelector(".MuiSpeedDial-fab");
+const actionLocator = byCssSelector(".MuiSpeedDialAction-fab");
+/**
+* Driver for the Material UI v9 SpeedDial component.
+*
+* SpeedDial renders a trigger FAB (`.MuiSpeedDial-fab`, `aria-expanded` reflects
+* open state) and a set of action FABs (`.MuiSpeedDialAction-fab`, each
+* aria-labelled with its name). The actions stay mounted but are only revealed
+* when open, so open state is read from the FAB's `aria-expanded` rather than
+* action presence.
+* @see https://mui.com/material-ui/react-speed-dial/
+*/
+var SpeedDialDriver = class extends ComponentDriver {
+	get fab() {
+		return locatorUtil.append(this.locator, fabLocator);
+	}
+	/**
+	* Whether the speed dial is open (its FAB reports `aria-expanded="true"`).
+	*/
+	async isOpen() {
+		return await this.interactor.getAttribute(this.fab, "aria-expanded") === "true";
+	}
+	/**
+	* Open the speed dial by hovering its FAB. No-op when already open.
+	*
+	* Hover (`onMouseEnter`) is the trigger that opens consistently across MUI
+	* versions and browsers — clicking only focuses-then-opens in Chromium, and
+	* focus opens in v7 but not v5, whereas hover opens everywhere.
+	*/
+	async open() {
+		if (!await this.isOpen()) await this.interactor.hover(this.fab);
+	}
+	/**
+	* Close the speed dial by moving the pointer off its FAB. No-op when already closed.
+	*/
+	async close() {
+		if (await this.isOpen()) await this.interactor.mouseLeave(this.fab);
+	}
+	/**
+	* The labels of every action, in order (read from each action FAB's aria-label).
+	*/
+	async getActionLabels() {
+		return (await this.interactor.getAttribute(locatorUtil.append(this.locator, actionLocator), "aria-label", true)).filter((label) => label != null);
+	}
+	/**
+	* Trigger the action with the given label, opening the dial first if needed.
+	* @returns `false` when no action has that label.
+	*/
+	async triggerActionByLabel(label) {
+		await this.open();
+		const actionByLabel = byCssSelector(`.MuiSpeedDialAction-fab[aria-label="${escapeUtil.escapeValue(label)}"]`);
+		const locator = locatorUtil.append(this.locator, actionByLabel);
+		if (!await this.interactor.exists(locator)) return false;
+		await this.interactor.click(locator);
+		return true;
+	}
+	get driverName() {
+		return "MuiV9SpeedDialDriver";
+	}
+};
+//#endregion
+//#region src/components/StepperDriver.ts
+const stepLabelLocator = byCssSelector(".MuiStepLabel-label");
+/**
+* Locator for the label of the step at `index`. In Material UI v9 the connector
+* is rendered *inside* each `.MuiStep-root` (in v7 it was an interleaved sibling),
+* so the step elements are now consecutive siblings and the step at `index` is the
+* `index+1`-th element of its type; nth-of-type addresses it directly.
+*/
+function stepLabelAt(index) {
+	return byCssSelector(`.MuiStep-root:nth-of-type(${index + 1}) .MuiStepLabel-label`);
+}
+function stepButtonAt(index) {
+	return byCssSelector(`.MuiStep-root:nth-of-type(${index + 1}) .MuiStepButton-root`);
+}
+/**
+* Driver for the Material UI v9 Stepper component.
+*
+* Each step's state lives on its `.MuiStepLabel-label` (`Mui-active`,
+* `Mui-completed`, `Mui-disabled`); reading every label's class in one pass gives
+* the step states and count in document order. Steps are addressed positionally
+* for label text and clicks via {@link stepLabelAt}/{@link stepButtonAt}.
+*
+* Supported layouts: the default horizontal stepper and the vertical orientation.
+* In v9 every `.MuiStep-root` is a consecutive sibling (the connector lives inside
+* the step), and every step renders a text label, so positional addressing lines up
+* with the document-order class list. The unsupported case is icon-only steps, which
+* render no `.MuiStepLabel-label`; under those the document-order class list has fewer
+* entries than steps and the two desynchronize. Robustly supporting that needs an
+* interactor primitive to address the n-th of non-sibling matches
+* (CSS `:nth-child(of S)` is unsupported in jsdom), which is out of this driver's scope.
+* @see https://mui.com/material-ui/react-stepper/
+*/
+var StepperDriver = class extends ComponentDriver {
+	async getStepClassList() {
+		return this.interactor.getAttribute(locatorUtil.append(this.locator, stepLabelLocator), "class", true);
+	}
+	/**
+	* The number of steps.
+	*/
+	async getStepCount() {
+		return (await this.getStepClassList()).length;
+	}
+	/**
+	* Zero-based index of the active step, or `-1` when none is active.
+	*/
+	async getActiveStepIndex() {
+		return (await this.getStepClassList()).findIndex((c) => c.split(/\s+/).includes("Mui-active"));
+	}
+	/**
+	* Every step with its label and active/completed/disabled state, in order.
+	*/
+	async getSteps() {
+		const classes = await this.getStepClassList();
+		const steps = [];
+		for (let index = 0; index < classes.length; index++) {
+			const stateClasses = classes[index].split(/\s+/);
+			const label = await this.interactor.getText(locatorUtil.append(this.locator, stepLabelAt(index)));
+			steps.push({
+				label: label?.trim(),
+				active: stateClasses.includes("Mui-active"),
+				completed: stateClasses.includes("Mui-completed"),
+				disabled: stateClasses.includes("Mui-disabled")
+			});
+		}
+		return steps;
+	}
+	/**
+	* Navigate to the step at `index` by clicking its control (requires a clickable
+	* `StepButton`, e.g. a non-linear stepper).
+	* @returns `false` when the step is out of range, has no button, or is disabled.
+	*/
+	async goToStep(index) {
+		if (index < 0 || index >= await this.getStepCount()) return false;
+		const button = locatorUtil.append(this.locator, stepButtonAt(index));
+		if (!await this.interactor.exists(button) || await this.interactor.isDisabled(button)) return false;
+		await this.interactor.click(button);
+		return true;
+	}
+	get driverName() {
+		return "MuiV9StepperDriver";
+	}
+};
+//#endregion
+//#region src/components/SwitchDriver.ts
+const parts$1 = { input: {
+	locator: byAttribute("type", "checkbox"),
+	driver: HTMLCheckboxDriver
+} };
+var SwitchDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts: parts$1
+		});
+	}
+	async exists() {
+		return this.interactor.exists(this.parts.input.locator);
+	}
+	async isSelected() {
+		await this.enforcePartExistence("input");
+		return this.parts.input.isSelected();
+	}
+	async setSelected(selected) {
+		await this.enforcePartExistence("input");
+		await this.parts.input.setSelected(selected);
+	}
+	async getValue() {
+		await this.enforcePartExistence("input");
+		return this.parts.input.getValue();
+	}
+	async isDisabled() {
+		await this.enforcePartExistence("input");
+		return this.parts.input.isDisabled();
+	}
+	async isReadonly() {
+		return Promise.resolve(false);
+	}
+	get driverName() {
+		return "MuiV9SwitchDriver";
+	}
+};
+//#endregion
+//#region src/components/TableCellDriver.ts
+/**
+* Driver for a single Material UI v9 TableCell (`<td>`/`<th>`, `.MuiTableCell-root`).
+*
+* A cell's content is plain text, so it relies on the inherited `getText()`/`exists()`;
+* it exists as a distinct type so {@link TableRowDriver} can expose typed cell drivers.
+* @see https://mui.com/material-ui/react-table/
+*/
+var TableCellDriver = class extends ComponentDriver {
+	get driverName() {
+		return "MuiV9TableCellDriver";
+	}
+};
+//#endregion
+//#region src/components/TableRowDriver.ts
+/**
+* Cells are located by `.MuiTableCell-root`, covering both `<td>` body cells and
+* `<th>` header cells.
+*/
+const defaultTableRowDriverOption = {
+	itemClass: TableCellDriver,
+	itemLocator: byCssSelector(".MuiTableCell-root")
+};
+/**
+* Driver for a single Material UI v9 TableRow (`.MuiTableRow-root`).
+*
+* A {@link ListComponentDriver} over the row's cells, exposing per-cell
+* {@link TableCellDriver}s (via `getItems`/`getItemByIndex`) plus convenience reads
+* of the cell texts.
+*
+* Cells are addressed positionally via `:nth-of-type`, which counts per element type.
+* This assumes a row's cells are homogeneous (all `<td>`, or all `<th>` for a header
+* row) — the common MUI rendering. A row mixing a leading `<th scope="row">` with
+* `<td>` data cells would desynchronize the index (the `<td>`s start at type-index 1
+* after the `<th>`); such rows are out of scope.
+* @see https://mui.com/material-ui/react-table/
+*/
+var TableRowDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...option,
+			...defaultTableRowDriverOption
+		});
+	}
+	/**
+	* The number of cells in the row.
+	*/
+	async getCellCount() {
+		return this.getItemCount();
+	}
+	/**
+	* The cell driver at the given zero-based column index, or `null` when out of range.
+	*/
+	async getCell(index) {
+		return this.getItemByIndex(index);
+	}
+	/**
+	* The text of every cell, in column order.
+	*/
+	async getCellTexts() {
+		const cells = await this.getItems();
+		const texts = [];
+		for (const cell of cells) texts.push((await cell.getText())?.trim() ?? "");
+		return texts;
+	}
+	get driverName() {
+		return "MuiV9TableRowDriver";
+	}
+};
+//#endregion
+//#region src/components/TableDriver.ts
+const headerRowLocator = byCssSelector(".MuiTableHead-root .MuiTableRow-root");
+/**
+* Body rows are located under `.MuiTableBody-root`, so header rows are never
+* mistaken for data rows.
+*/
+const defaultTableDriverOption = {
+	itemClass: TableRowDriver,
+	itemLocator: byCssSelector(".MuiTableBody-root .MuiTableRow-root")
+};
+function headerCellAt(columnIndex) {
+	return byCssSelector(`.MuiTableHead-root .MuiTableRow-root .MuiTableCell-root:nth-of-type(${columnIndex + 1})`);
+}
+/**
+* Driver for the Material UI v9 Table component.
+*
+* A {@link ListComponentDriver} over the data rows (`.MuiTableBody-root > .MuiTableRow-root`),
+* exposing per-row {@link TableRowDriver}s plus header reads and column sort state.
+* Locators key off MUI's structural classes (`MuiTableHead/Body/Row/Cell-root`),
+* which are stable across v9. Sort state is read from the header cell's `aria-sort`
+* and driven by clicking its `TableSortLabel`.
+* @see https://mui.com/material-ui/react-table/
+*/
+var TableDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...defaultTableDriverOption,
+			...option
+		});
+	}
+	/**
+	* The number of data (body) rows.
+	*/
+	async getRowCount() {
+		return this.getItemCount();
+	}
+	/**
+	* The data-row driver at the given zero-based index, or `null` when out of range.
+	*/
+	async getRow(index) {
+		return this.getItemByIndex(index);
+	}
+	/**
+	* The header row as a {@link TableRowDriver}, or `null` when the table has no header.
+	*/
+	async getHeaderRow() {
+		const locator = locatorUtil.append(this.locator, headerRowLocator);
+		if (!await this.interactor.exists(locator)) return null;
+		return new TableRowDriver(locator, this.interactor);
+	}
+	/**
+	* The number of columns, derived from the header cell count (0 when no header).
+	*/
+	async getColumnCount() {
+		const header = await this.getHeaderRow();
+		return header == null ? 0 : header.getCellCount();
+	}
+	/**
+	* The header cell texts, in column order (empty when no header).
+	*/
+	async getHeaderTexts() {
+		const header = await this.getHeaderRow();
+		return header == null ? [] : header.getCellTexts();
+	}
+	/**
+	* The text of the data cell at the given row/column, or `undefined` when either
+	* index is out of range.
+	*/
+	async getCellText(rowIndex, columnIndex) {
+		const row = await this.getRow(rowIndex);
+		if (row == null) return;
+		const cell = await row.getCell(columnIndex);
+		if (cell == null) return;
+		return (await cell.getText())?.trim();
+	}
+	/**
+	* The sort direction applied to the column at `columnIndex`, read from the header
+	* cell's `aria-sort`, or `undefined` when that column is not the sorted one.
+	*/
+	async getSortDirection(columnIndex) {
+		const cell = headerCellAt(columnIndex);
+		const fullLocator = locatorUtil.append(this.locator, cell);
+		if (!await this.interactor.exists(fullLocator)) return;
+		const ariaSort = await this.interactor.getAttribute(fullLocator, "aria-sort");
+		return ariaSort === "ascending" || ariaSort === "descending" ? ariaSort : void 0;
+	}
+	/**
+	* Toggle/apply sorting on the column at `columnIndex` by clicking its
+	* `TableSortLabel`.
+	* @returns `false` when the column has no sort control.
+	*/
+	async sortByColumn(columnIndex) {
+		const sortLabel = locatorUtil.append(this.locator, byCssSelector(`.MuiTableHead-root .MuiTableRow-root .MuiTableCell-root:nth-of-type(${columnIndex + 1}) .MuiTableSortLabel-root`));
+		if (!await this.interactor.exists(sortLabel)) return false;
+		await this.interactor.click(sortLabel);
+		return true;
+	}
+	get driverName() {
+		return "MuiV9TableDriver";
+	}
+};
+//#endregion
+//#region src/components/TablePaginationDriver.ts
+const previousButtonLocator = byAttribute("aria-label", "Go to previous page");
+const nextButtonLocator = byAttribute("aria-label", "Go to next page");
+const displayedRowsLocator = byCssSelector(".MuiTablePagination-displayedRows");
+/**
+* Driver for the Material UI v9 TablePagination component.
+*
+* TablePagination is a composite: a "rows per page" MUI Select (a portal-backed
+* `role="combobox"`), an aria-labelled previous/next pair that disables at the
+* bounds, and a `.MuiTablePagination-displayedRows` label ("1–5 of 13"). The
+* rows-per-page control is delegated to {@link SelectDriver} rather than
+* reimplemented — the driver's own root contains exactly one combobox/input, so
+* SelectDriver scoped to that root resolves it unambiguously.
+* @see https://mui.com/material-ui/react-pagination/#table-pagination
+*/
+var TablePaginationDriver = class extends ComponentDriver {
+	get rowsPerPageSelect() {
+		return new SelectDriver(this.locator, this.interactor);
+	}
+	/**
+	* The current rows-per-page value (read from the select's hidden input), or
+	* `-1` when it cannot be parsed.
+	*/
+	async getRowsPerPage() {
+		const value = await this.rowsPerPageSelect.getValue();
+		const parsed = Number.parseInt(value ?? "", 10);
+		return Number.isNaN(parsed) ? -1 : parsed;
+	}
+	/**
+	* Choose a rows-per-page value by opening the select and picking the option.
+	* @returns `false` when no such option exists.
+	*/
+	async setRowsPerPage(rowsPerPage) {
+		return this.rowsPerPageSelect.setValue(String(rowsPerPage));
+	}
+	/**
+	* The raw "displayed rows" label (e.g. "1–5 of 13"), or `undefined` when absent.
+	* Returned verbatim because its exact format (separator, "of") is locale-defined.
+	*/
+	async getDisplayedRowsText() {
+		const locator = locatorUtil.append(this.locator, displayedRowsLocator);
+		if (!await this.interactor.exists(locator)) return;
+		return (await this.interactor.getText(locator))?.trim();
+	}
+	/** Whether the previous-page control is disabled (i.e. on the first page). */
+	async isPreviousDisabled() {
+		return this.isNavDisabled(previousButtonLocator);
+	}
+	/** Whether the next-page control is disabled (i.e. on the last page). */
+	async isNextDisabled() {
+		return this.isNavDisabled(nextButtonLocator);
+	}
+	/**
+	* An absent control counts as disabled — both to stay consistent with
+	* {@link clickNavButton} (which reports a no-op for a missing control) and
+	* because Playwright's `isDisabled` throws on a zero-match locator rather than
+	* returning false the way jsdom does.
+	*/
+	async isNavDisabled(navLocator) {
+		const locator = locatorUtil.append(this.locator, navLocator);
+		if (!await this.interactor.exists(locator)) return true;
+		return this.interactor.isDisabled(locator);
+	}
+	/**
+	* Advance to the next page unless the control is disabled (last page).
+	* @returns whether the click was performed.
+	*/
+	async nextPage() {
+		return this.clickNavButton(nextButtonLocator);
+	}
+	/**
+	* Go back to the previous page unless the control is disabled (first page).
+	* @returns whether the click was performed.
+	*/
+	async previousPage() {
+		return this.clickNavButton(previousButtonLocator);
+	}
+	async clickNavButton(navLocator) {
+		const locator = locatorUtil.append(this.locator, navLocator);
+		if (!await this.interactor.exists(locator) || await this.interactor.isDisabled(locator)) return false;
+		await this.interactor.click(locator);
+		return true;
+	}
+	get driverName() {
+		return "MuiV9TablePaginationDriver";
+	}
+};
+//#endregion
+//#region src/components/TabDriver.ts
+/**
+* Driver for a single Material UI v9 Tab.
+*
+* A `<Tab>` renders as a `<button role="tab">`; MUI marks the active one with
+* `aria-selected="true"` and renders a real `disabled` button when disabled, so
+* selection and disabled state are read straight off the accessible attributes
+* (`isDisabled` is inherited from {@link HTMLButtonDriver}; `getText`/`click` from
+* the base `ComponentDriver`).
+*
+* Unlike a toggle button this is intentionally not an `IToggleDriver`: a tab can
+* be selected but not toggled off (selecting another tab deselects it), so only
+* `isSelected`/`select` are exposed.
+* @see https://mui.com/material-ui/react-tabs/
+*/
+var TabDriver = class extends HTMLButtonDriver {
+	/**
+	* Whether this tab is the selected one, i.e. MUI set `aria-selected="true"`.
+	*/
+	async isSelected() {
+		return await this.interactor.getAttribute(this.locator, "aria-selected") === "true";
+	}
+	/**
+	* Activate this tab by clicking it, unless it is already selected. A selected
+	* tab cannot be toggled off, so this is a no-op when already active.
+	*/
+	async select() {
+		if (!await this.isSelected()) await this.interactor.click(this.locator);
+	}
+	get driverName() {
+		return "MuiV9TabDriver";
+	}
+};
+//#endregion
+//#region src/components/TabsDriver.ts
+/**
+* Tabs are located by their accessible `role="tab"` children rather than by MUI
+* class names, so the driver is resilient to MUI styling/version changes.
+*/
+const defaultTabsDriverOption = {
+	itemClass: TabDriver,
+	itemLocator: byRole("tab")
+};
+/**
+* Driver for the Material UI v9 Tabs component.
+*
+* `<Tabs>` renders a `role="tablist"` whose `role="tab"` buttons carry the
+* selected (`aria-selected`) and disabled state. This driver is a
+* {@link ListComponentDriver} over those tabs, exposing both group-level helpers
+* (selected index/label, select by index/label) and per-tab {@link TabDriver}
+* instances via `getItems`/`getItemByIndex`/`getItemByLabel`.
+* @see https://mui.com/material-ui/react-tabs/
+*/
+var TabsDriver = class extends ListComponentDriver {
+	constructor(locator, interactor, option = {}) {
+		super(locator, interactor, {
+			...defaultTabsDriverOption,
+			...option
+		});
+	}
+	/**
+	* The visible label of every tab, in DOM order.
+	*/
+	async getTabLabels() {
+		const labels = [];
+		for await (const tab of listHelper.getListItemIterator(this, this.getItemLocator(), TabDriver)) {
+			const text = await tab.getText();
+			labels.push(text?.trim() ?? "");
+		}
+		return labels;
+	}
+	/**
+	* The number of tabs in the group.
+	*/
+	async getTabCount() {
+		return this.getItemCount();
+	}
+	/**
+	* Zero-based index of the selected tab, or `-1` when no tab is selected
+	* (e.g. `<Tabs value={false}>`).
+	*/
+	async getSelectedIndex() {
+		let index = 0;
+		for await (const tab of listHelper.getListItemIterator(this, this.getItemLocator(), TabDriver)) {
+			if (await tab.isSelected()) return index;
+			index++;
+		}
+		return -1;
+	}
+	/**
+	* Label of the selected tab, or `null` when no tab is selected. Returns `null`
+	* (not `undefined`) to match the sibling `SelectDriver.getSelectedLabel` contract.
+	*/
+	async getSelectedLabel() {
+		for await (const tab of listHelper.getListItemIterator(this, this.getItemLocator(), TabDriver)) if (await tab.isSelected()) return (await tab.getText())?.trim() ?? null;
+		return null;
+	}
+	/**
+	* Select the tab at the given zero-based index.
+	* @returns `false` when the index is out of range.
+	*/
+	async selectByIndex(index) {
+		const tab = await this.getItemByIndex(index);
+		if (tab == null) return false;
+		await tab.click();
+		return true;
+	}
+	/**
+	* Select the first tab whose visible label equals `label`.
+	* @returns `false` when no tab matches.
+	*/
+	async selectByLabel(label) {
+		const tab = await this.getItemByLabel(label);
+		if (tab == null) return false;
+		await tab.click();
+		return true;
+	}
+	/**
+	* Whether the tab at the given index is disabled.
+	* @returns `false` when the index is out of range.
+	*/
+	async isTabDisabled(index) {
+		const tab = await this.getItemByIndex(index);
+		return tab == null ? false : tab.isDisabled();
+	}
+	get driverName() {
+		return "MuiV9TabsDriver";
+	}
+};
+//#endregion
+//#region src/components/TextFieldDriver.ts
+const parts = {
+	label: {
+		locator: byCssSelector(">.MuiInputLabel-root"),
+		driver: HTMLElementDriver
+	},
+	helperText: {
+		locator: byCssSelector(">p"),
+		driver: HTMLElementDriver
+	},
+	singlelineInput: {
+		locator: byCssSelector("input:not([aria-hidden])"),
+		driver: HTMLTextInputDriver
+	},
+	multilineInput: {
+		locator: byCssSelector("textarea:not([aria-hidden])"),
+		driver: HTMLTextInputDriver
+	},
+	selectInput: {
+		locator: byCssSelector(">.MuiInputBase-root"),
+		driver: SelectDriver
+	},
+	richSelectInputDetect: {
+		locator: byRole("combobox"),
+		driver: HTMLElementDriver
+	},
+	nativeSelectInputDetect: {
+		locator: byTagName("SELECT"),
+		driver: HTMLElementDriver
+	}
+};
+/**
+* A driver for the Material UI v9 TextField component with single line or multiline text input.
+*/
+var TextFieldDriver = class extends ComponentDriver {
+	constructor(locator, interactor, option) {
+		super(locator, interactor, {
+			...option,
+			parts
+		});
+	}
+	async getInputType() {
+		return await Promise.all([
+			this.parts.singlelineInput.exists(),
+			this.parts.richSelectInputDetect.exists(),
+			this.parts.nativeSelectInputDetect.exists(),
+			this.parts.multilineInput.exists()
+		]).then(([singlelineExists, richSelectExists, nativeSelectExists, multilineExists]) => {
+			if (singlelineExists) return "singleLine";
+			if (richSelectExists || nativeSelectExists) return "select";
+			if (multilineExists) return "multiline";
+			throw new Error("Unable to determine input type in TextFieldInput");
+		});
+	}
+	async getValue() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.getValue();
+			case "select": return this.parts.selectInput.getValue();
+			case "multiline": return this.parts.multilineInput.getValue();
+		}
+	}
+	async setValue(value) {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.setValue(value);
+			case "select": return this.parts.selectInput.setValue(value);
+			case "multiline": return this.parts.multilineInput.setValue(value);
+		}
+	}
+	async getLabel() {
+		return this.parts.label.getText();
+	}
+	async getHelperText() {
+		if (await this.interactor.exists(this.parts.helperText.locator)) return this.parts.helperText.getText();
+	}
+	async isDisabled() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.isDisabled();
+			case "select": return this.parts.selectInput.isDisabled();
+			case "multiline": return this.parts.multilineInput.isDisabled();
+		}
+	}
+	async isReadonly() {
+		switch (await this.getInputType()) {
+			case "singleLine": return this.parts.singlelineInput.isReadonly();
+			case "select": return this.interactor.hasCssClass(this.parts.selectInput.locator, "MuiInputBase-readOnly");
+			case "multiline": return this.parts.multilineInput.isReadonly();
+		}
+	}
+	get driverName() {
+		return "MuiV9TextFieldDriver";
+	}
+};
+//#endregion
+//#region src/components/ToggleButtonDriver.ts
+var ToggleButtonDriver = class extends ButtonDriver {
+	async isSelected() {
+		return await this.interactor.getAttribute(this.locator, "aria-pressed") === "true";
+	}
+	async setSelected(targetState) {
+		if (await this.isSelected() !== targetState) await this.interactor.click(this.locator);
+	}
+	get driverName() {
+		return "MuiV9ToggleButtonDriver";
+	}
+};
+//#endregion
+//#region src/components/ToggleButtonGroupDriver.ts
+const toggleButtonLocator = byTagName("button");
+var ToggleButtonGroupDriver = class extends ComponentDriver {
+	constructor(..._args) {
+		super(..._args);
+		this.itemLocator = locatorUtil.append(this.locator, toggleButtonLocator);
+	}
+	/**
+	* Get all the selected toggle buttons' values.
+	* @returns
+	*/
+	async getValue() {
+		const result = [];
+		for await (const itemDriver of listHelper.getListItemIterator(this, this.itemLocator, ToggleButtonDriver)) if (await itemDriver.isSelected()) {
+			const value = await itemDriver.getValue();
+			if (value != null) result.push(value);
+		}
+		return result;
+	}
+	/**
+	* Toggle all the toggle buttons such that only those with value in the given array are selected.
+	* @param value Always true
+	* @returns
+	*/
+	async setValue(value) {
+		const valueSet = new Set(value);
+		for await (const itemDriver of listHelper.getListItemIterator(this, this.itemLocator, ToggleButtonDriver)) {
+			const value = await itemDriver.getValue();
+			await itemDriver.setSelected(valueSet.has(value));
+		}
+		return true;
+	}
+	get driverName() {
+		return "MuiV9ToggleButtonGroupDriver";
+	}
+};
+/**
+* A toggle button group driver that only allows a single selection.
+*
+* INTENTIONAL @ts-ignore comments below: This class intentionally narrows the return type
+* from `readonly string[]` to `string | null` for exclusive selection mode. TypeScript
+* correctly flags this as a type incompatibility because the subclass changes the interface
+* contract. However, this design is intentional as exclusive and multi-select toggle groups
+* have fundamentally different value semantics, and we want the type system to reflect
+* `string | null` for exclusive mode rather than forcing consumers to work with arrays.
+*/
+var ExclusiveToggleButtonGroupDriver = class extends ToggleButtonGroupDriver {
+	async getValue() {
+		return (await super.getValue())?.[0] ?? null;
+	}
+	async setValue(value) {
+		if (value === null) return super.setValue([]);
+		else return super.setValue([value]);
+	}
+	get driverName() {
+		return "MuiV9ExclusiveToggleButtonGroupDriver";
+	}
+};
+//#endregion
+//#region src/components/TooltipDriver.ts
+const tooltipLocator = byRole("tooltip", "Root");
+const defaultRevealTimeout = 250;
+/**
+* Driver for the Material UI v9 Tooltip component.
+*
+* The driver is rooted at the **trigger** element. MUI shows the tooltip on
+* hover/focus and renders it into a portal (a `role="tooltip"` popper) outside the
+* trigger's subtree, so the text is read from the document root via
+* {@link tooltipLocator} after revealing it. The tooltip unmounts when not shown,
+* so presence of that element doubles as the visible state.
+*
+* Note: hover reveal depends on the tooltip's `enterDelay`; with a non-zero delay
+* the reveal is timer-bound. {@link getTitle} waits for the tooltip to appear.
+* @see https://mui.com/material-ui/react-tooltip/
+*/
+var TooltipDriver = class extends ComponentDriver {
+	/**
+	* Reveal the tooltip by hovering its trigger, waiting until it is shown (or the
+	* timeout elapses, e.g. when the trigger has no tooltip).
+	*/
+	async show(timeoutMs = defaultRevealTimeout) {
+		await this.interactor.hover(this.locator);
+		await this.interactor.waitUntil({
+			probeFn: () => this.isVisible(),
+			terminateCondition: true,
+			timeoutMs
+		});
+	}
+	/**
+	* Hide the tooltip by moving the pointer off its trigger, waiting until it is gone.
+	*/
+	async hide(timeoutMs = defaultRevealTimeout) {
+		await this.interactor.mouseLeave(this.locator);
+		await this.interactor.waitUntil({
+			probeFn: () => this.isVisible(),
+			terminateCondition: false,
+			timeoutMs
+		});
+	}
+	/**
+	* Whether a tooltip is currently shown.
+	*/
+	async isVisible() {
+		if (!await this.interactor.exists(tooltipLocator)) return false;
+		return this.interactor.isVisible(tooltipLocator);
+	}
+	/**
+	* Reveal the tooltip, read its text, then restore the un-hovered state. Returns
+	* `undefined` when the trigger has no tooltip (none appears within the timeout).
+	*
+	* The hover is undone before returning so a subsequent read on a *different*
+	* trigger isn't shadowed by this still-open tooltip: MUI renders all tooltips into
+	* one portal and provides no per-trigger DOM link, and jsdom's synthetic hover does
+	* not fire `mouseout` on the previously-hovered sibling.
+	*
+	* @param timeoutMs How long to wait for the tooltip to appear after hovering.
+	*/
+	async getTitle(timeoutMs = defaultRevealTimeout) {
+		await this.show(timeoutMs);
+		if (!await this.interactor.exists(tooltipLocator)) return;
+		const text = (await this.interactor.getText(tooltipLocator))?.trim();
+		await this.hide(timeoutMs);
+		return text;
+	}
+	get driverName() {
+		return "MuiV9TooltipDriver";
+	}
+};
+//#endregion
+export { AccordionDriver, AlertDriver, AutoCompleteDriver, AvatarDriver, AvatarGroupDriver, BadgeDriver, BottomNavigationActionDriver, BottomNavigationDriver, ButtonDriver, CheckboxDriver, ChipDriver, DialogDriver, DrawerDriver, ExclusiveToggleButtonGroupDriver, FabDriver, InputDriver, ListDriver, ListItemDriver, MenuDriver, MenuItemDisabledError, MenuItemDisabledErrorId, MenuItemDriver, MenuItemNotFoundError, MenuItemNotFoundErrorId, OverlayDriver, PaginationDriver, ProgressDriver, RadioDriver, RadioGroupDriver, RatingDriver, SelectDriver, SliderDriver, SnackbarDriver, SpeedDialDriver, StepperDriver, SwitchDriver, TabDriver, TableCellDriver, TableDriver, TablePaginationDriver, TableRowDriver, TabsDriver, TextFieldDriver, ToggleButtonDriver, ToggleButtonGroupDriver, TooltipDriver, defaultAutoCompleteDriverOption, defaultAvatarGroupDriverOption, defaultRadioGroupDriverOption, defaultTableDriverOption, defaultTableRowDriverOption, defaultTabsDriverOption, drawerParts };
+
+//# sourceMappingURL=index.mjs.map