webdriverio 9.5.1 → 9.5.3

package/build/index.js

@@ -2995,9 +2995,69 @@ var ReferenceValue = class {
   }
 };
 
-// src/context.ts
+// src/session/context.ts
 import logger4 from "@wdio/logger";
 
+// src/session/session.ts
+var sessionManager = /* @__PURE__ */ new Map();
+var SessionManager = class {
+  #browser;
+  #scope;
+  /**
+   * SessionManager constructor
+   * Logic in here should be executed for all session singletons, e.g. remove instance
+   * of itself when a session was deleted.
+   * @param browser WebdriverIO.Browser
+   * @param scope   scope of the session manager, e.g. context, network etc.
+   */
+  constructor(browser, scope) {
+    this.#browser = browser;
+    this.#browser.on("command", this.#onCommand.bind(this));
+    this.#scope = scope;
+  }
+  #onCommand(ev) {
+    if (ev.command === "deleteSession") {
+      const sessionManagerInstances = sessionManager.get(this.#scope);
+      const sessionManagerInstance = sessionManagerInstances?.get(this.#browser);
+      if (sessionManagerInstance && sessionManagerInstances) {
+        sessionManagerInstance.removeListeners();
+        sessionManagerInstances.delete(this.#browser);
+      }
+    }
+  }
+  removeListeners() {
+    this.#browser.off("result", this.#onCommand.bind(this));
+  }
+  initialize() {
+    return void 0;
+  }
+  /**
+   * check if session manager should be enabled, if
+   */
+  isEnabled() {
+    return (
+      // we are in a Bidi session
+      this.#browser.isBidi && // we are not running unit tests
+      !process.env.WDIO_UNIT_TESTS && // we are running a WebDriver session
+      this.#browser.options?.automationProtocol === "webdriver"
+    );
+  }
+  static getSessionManager(browser, Manager) {
+    const scope = Manager.name;
+    let sessionManagerInstances = sessionManager.get(scope);
+    if (!sessionManagerInstances) {
+      sessionManagerInstances = /* @__PURE__ */ new Map();
+      sessionManager.set(scope, sessionManagerInstances);
+    }
+    let sessionManagerInstance = sessionManagerInstances.get(browser);
+    if (!sessionManagerInstance) {
+      sessionManagerInstance = new Manager(browser);
+      sessionManagerInstances.set(browser, sessionManagerInstance);
+    }
+    return sessionManagerInstance;
+  }
+};
+
 // src/utils/mobile.ts
 var appiumKeys = ["app", "bundleId", "appPackage", "appActivity", "appWaitActivity", "appWaitPackage"];
 function getNativeContext({ capabilities, isMobile }) {
@@ -3049,24 +3109,19 @@ function validatePinchAndZoomOptions({ browser, gesture, options }) {
   };
 }
 
-// src/context.ts
-var contextManager = /* @__PURE__ */ new Map();
+// src/session/context.ts
 var log4 = logger4("webdriverio:context");
+var COMMANDS_REQUIRING_RESET = ["deleteSession", "refresh", "switchToParentFrame"];
 function getContextManager(browser) {
-  const existingContextManager = contextManager.get(browser);
-  if (existingContextManager) {
-    return existingContextManager;
-  }
-  const newContext = new ContextManager(browser);
-  contextManager.set(browser, newContext);
-  return newContext;
+  return SessionManager.getSessionManager(browser, ContextManager);
 }
-var ContextManager = class {
+var ContextManager = class _ContextManager extends SessionManager {
   #browser;
   #currentContext;
   #mobileContext;
   #isNativeContext;
   constructor(browser) {
+    super(browser, _ContextManager.name);
     this.#browser = browser;
     const capabilities = this.#browser.capabilities;
     this.#isNativeContext = getNativeContext({ capabilities, isMobile: this.#browser.isMobile });
@@ -3075,46 +3130,53 @@ var ContextManager = class {
       isAndroid: this.#browser.isAndroid,
       isNativeContext: this.#isNativeContext
     });
-    if (!this.#isEnabled()) {
+    this.#browser.on("result", this.#onCommandResultBidiAndClassic.bind(this));
+    if (!this.isEnabled()) {
       return;
     }
-    this.#browser.on("command", (event) => {
-      if (event.command === "switchToWindow") {
-        this.setCurrentContext(event.body.handle);
-      }
-      if (event.command === "switchToParentFrame" || event.command === "refresh") {
-        this.#currentContext = void 0;
-      }
-      if (this.#browser.isMobile && event.command === "switchContext") {
-        this.#mobileContext = event.body.name;
-      }
-    });
-    this.#browser.on("result", (event) => {
-      if (event.command === "closeWindow") {
-        this.#currentContext = event.result.value[0];
-        return this.#browser.switchToWindow(this.#currentContext);
-      }
-      if (this.#browser.isMobile) {
-        if (event.command === "getContext") {
-          this.setCurrentContext(event.result.value);
-        }
-        if (event.command === "switchContext" && event.result.value === null && this.#mobileContext) {
-          this.setCurrentContext(this.#mobileContext);
-        }
-      }
-    });
+    this.#browser.on("command", this.#onCommand.bind(this));
+    if (this.#browser.isMobile) {
+      this.#browser.on("result", this.#onCommandResultMobile.bind(this));
+    }
   }
-  /**
-   * Only run this session helper if BiDi is enabled and we're not in unit tests.
-   */
-  #isEnabled() {
-    return !process.env.WDIO_UNIT_TESTS && (this.#browser.isBidi || this.#browser.isMobile);
+  removeListeners() {
+    super.removeListeners();
+    this.#browser.off("result", this.#onCommandResultBidiAndClassic.bind(this));
+    this.#browser.off("command", this.#onCommand.bind(this));
+    if (this.#browser.isMobile) {
+      this.#browser.off("result", this.#onCommandResultMobile.bind(this));
+    }
+  }
+  #onCommandResultBidiAndClassic(event) {
+    if (event.command === "closeWindow") {
+      this.#currentContext = event.result.value[0];
+      return this.#browser.switchToWindow(this.#currentContext);
+    }
+  }
+  #onCommand(event) {
+    if (event.command === "switchToWindow") {
+      this.setCurrentContext(event.body.handle);
+    }
+    if (COMMANDS_REQUIRING_RESET.includes(event.command)) {
+      this.#currentContext = void 0;
+    }
+    if (this.#browser.isMobile && event.command === "switchContext") {
+      this.#mobileContext = event.body.name;
+    }
+  }
+  #onCommandResultMobile(event) {
+    if (event.command === "getContext") {
+      this.setCurrentContext(event.result.value);
+    }
+    if (event.command === "switchContext" && event.result.value === null && this.#mobileContext) {
+      this.setCurrentContext(this.#mobileContext);
+    }
   }
   /**
    * set context at the start of the session
    */
   async initialize() {
-    if (!this.#isEnabled()) {
+    if (process.env.WDIO_UNIT_TESTS) {
       return "";
     }
     if (this.#browser.isMobile && !this.#isNativeContext && !this.#mobileContext) {
@@ -3154,24 +3216,18 @@ Requested WebDriver capabilities: ${JSON.stringify(this.#browser.requestedCapabi
   }
 };
 
-// src/polyfill.ts
+// src/session/polyfill.ts
 import logger5 from "@wdio/logger";
-var polyfillManager = /* @__PURE__ */ new Map();
-var log5 = logger5("webdriverio:PolyfillManager");
-var NAME_POLYFILL = "var __defProp = Object.defineProperty;var __name = function (target, value) { return __defProp(target, 'name', { value: value, configurable: true }); };var __globalThis = (typeof globalThis === 'object' && globalThis) || (typeof window === 'object' && window);__globalThis.__name = __name;";
 function getPolyfillManager(browser) {
-  const existingPolyfillManager = polyfillManager.get(browser);
-  if (existingPolyfillManager) {
-    return existingPolyfillManager;
-  }
-  const newContext = new PolyfillManager(browser);
-  polyfillManager.set(browser, newContext);
-  return newContext;
+  return SessionManager.getSessionManager(browser, PolyfillManager);
 }
-var PolyfillManager = class {
+var log5 = logger5("webdriverio:PolyfillManager");
+var NAME_POLYFILL = "var __defProp = Object.defineProperty;var __name = function (target, value) { return __defProp(target, 'name', { value: value, configurable: true }); };var __globalThis = (typeof globalThis === 'object' && globalThis) || (typeof window === 'object' && window);__globalThis.__name = __name;";
+var PolyfillManager = class _PolyfillManager extends SessionManager {
   #initialize;
   constructor(browser) {
-    if (!browser.isBidi || process.env.WDIO_UNIT_TESTS || browser.options?.automationProtocol !== "webdriver") {
+    super(browser, _PolyfillManager.name);
+    if (!this.isEnabled()) {
       this.#initialize = Promise.resolve(true);
       return;
     }
@@ -3199,8 +3255,8 @@ async function execute(script, ...args) {
   }
   if (this.isBidi && !this.isMultiremote) {
     const browser = getBrowserObject3(this);
-    const contextManager2 = getContextManager(browser);
-    const context = await contextManager2.getCurrentContext();
+    const contextManager = getContextManager(browser);
+    const context = await contextManager.getCurrentContext();
     const userScript = typeof script === "string" ? new Function(script) : script;
     const functionDeclaration = new Function(`
             return (${SCRIPT_PREFIX}${userScript.toString()}${SCRIPT_SUFFIX}).apply(this, arguments);
@@ -3233,8 +3289,8 @@ async function executeAsync(script, ...args) {
   }
   if (this.isBidi && !this.isMultiremote) {
     const browser = getBrowserObject4(this);
-    const contextManager2 = getContextManager(browser);
-    const context = await contextManager2.getCurrentContext();
+    const contextManager = getContextManager(browser);
+    const context = await contextManager.getCurrentContext();
     const userScript = typeof script === "string" ? new Function(script) : script;
     const functionDeclaration = new Function(`
             const args = Array.from(arguments)
@@ -3934,8 +3990,8 @@ async function mock(url6, filterOptions) {
     throw new Error("Mocking is only supported when running tests using WebDriver Bidi");
   }
   const browser = getBrowserObject6(this);
-  const contextManager2 = getContextManager(browser);
-  const context = await contextManager2.getCurrentContext();
+  const contextManager = getContextManager(browser);
+  const context = await contextManager.getCurrentContext();
   if (!SESSION_MOCKS[context]) {
     SESSION_MOCKS[context] = /* @__PURE__ */ new Set();
   }
@@ -3989,9 +4045,9 @@ async function newWindow(url6, { type = "window", windowName = "", windowFeature
   }
   const tabsBefore = await this.getWindowHandles();
   if (this.isBidi) {
-    const contextManager2 = getContextManager(this);
+    const contextManager = getContextManager(this);
     const { context } = await this.browsingContextCreate({ type });
-    contextManager2.setCurrentContext(context);
+    contextManager.setCurrentContext(context);
     await this.browsingContextNavigate({ context, url: url6 });
   } else {
     await this.execute(newWindowHelper, url6, windowName, windowFeatures);
@@ -4064,306 +4120,873 @@ async function react$(selector, { props = {}, state = {} } = {}) {
 }
 
 // src/commands/browser/reloadSession.ts
+import logger13 from "@wdio/logger";
+
+// src/session/shadowRoot.ts
 import logger12 from "@wdio/logger";
-var log12 = logger12("webdriverio");
-async function reloadSession(newCapabilities) {
-  const oldSessionId = this.sessionId;
-  const shutdownDriver = Boolean(newCapabilities?.browserName);
-  try {
-    await this.deleteSession({ shutdownDriver });
-  } catch (err) {
-    log12.warn(`Suppressing error closing the session: ${err.stack}`);
-  }
-  if (this.puppeteer?.connected) {
-    this.puppeteer.disconnect();
-    log12.debug("Disconnected puppeteer session");
-  }
-  const ProtocolDriver = (await import(
-    /* @vite-ignore */
-    this.options.automationProtocol
-  )).default;
-  await ProtocolDriver.reloadSession(this, newCapabilities);
-  const options = this.options;
-  if (Array.isArray(options.onReload) && options.onReload.length) {
-    await Promise.all(options.onReload.map((hook) => hook(oldSessionId, this.sessionId)));
-  }
-  return this.sessionId;
+import customElementWrapper from "./scripts/customElement.js";
+var log12 = logger12("webdriverio:ShadowRootManager");
+function getShadowRootManager(browser) {
+  return SessionManager.getSessionManager(browser, ShadowRootManager);
 }
-
-// src/commands/browser/restore.ts
-async function restore(scopes2) {
-  const scopeArray = !scopes2 || Array.isArray(scopes2) ? scopes2 : [scopes2];
-  const instanceRestoreFunctions = restoreFunctions.get(this);
-  if (!instanceRestoreFunctions) {
-    return;
-  }
-  await Promise.all(Array.from(instanceRestoreFunctions.entries()).map(async ([scope, restoreFunctionsList]) => {
-    if (!scopeArray || scopeArray.includes(scope)) {
-      await Promise.all(restoreFunctionsList.map((fn) => fn()));
-      instanceRestoreFunctions.set(scope, []);
+var ShadowRootManager = class _ShadowRootManager extends SessionManager {
+  #browser;
+  #initialize;
+  #shadowRoots = /* @__PURE__ */ new Map();
+  #documentElement;
+  #frameDepth = 0;
+  constructor(browser) {
+    super(browser, _ShadowRootManager.name);
+    this.#browser = browser;
+    if (!this.isEnabled()) {
+      this.#initialize = Promise.resolve(true);
+      return;
     }
-  }));
-}
-
-// src/commands/browser/savePDF.ts
-import fs4 from "node:fs";
-async function savePDF(filepath, options) {
-  if (typeof filepath !== "string" || !filepath.endsWith(".pdf")) {
-    throw new Error('savePDF expects a filepath of type string and ".pdf" file ending');
-  }
-  const absoluteFilepath = getAbsoluteFilepath(filepath);
-  await assertDirectoryExists(absoluteFilepath);
-  const pdf = await this.printPage(
-    options?.orientation,
-    options?.scale,
-    options?.background,
-    options?.width,
-    options?.height,
-    options?.top,
-    options?.bottom,
-    options?.left,
-    options?.right,
-    options?.shrinkToFit,
-    options?.pageRanges
-  );
-  const page = Buffer.from(pdf, "base64");
-  fs4.writeFileSync(absoluteFilepath, page);
-  return page;
-}
-
-// src/commands/browser/saveRecordingScreen.ts
-import fs5 from "node:fs";
-async function saveRecordingScreen(filepath) {
-  if (typeof filepath !== "string") {
-    throw new Error("saveRecordingScreen expects a filepath");
-  }
-  const absoluteFilepath = getAbsoluteFilepath(filepath);
-  await assertDirectoryExists(absoluteFilepath);
-  const videoBuffer = await this.stopRecordingScreen();
-  const video = Buffer.from(videoBuffer, "base64");
-  fs5.writeFileSync(absoluteFilepath, video);
-  return video;
-}
-
-// src/commands/browser/saveScreenshot.ts
-import fs6 from "node:fs";
-import { getBrowserObject as getBrowserObject7 } from "@wdio/utils";
-async function saveScreenshot(filepath) {
-  if (typeof filepath !== "string" || !filepath.endsWith(".png")) {
-    throw new Error('saveScreenshot expects a filepath of type string and ".png" file ending');
-  }
-  const absoluteFilepath = getAbsoluteFilepath(filepath);
-  await assertDirectoryExists(absoluteFilepath);
-  let screenBuffer;
-  if (this.isBidi) {
-    const browser = getBrowserObject7(this);
-    const contextManager2 = getContextManager(browser);
-    const context = await contextManager2.getCurrentContext();
-    const { data } = await this.browsingContextCaptureScreenshot({ context });
-    screenBuffer = data;
-  } else {
-    screenBuffer = await this.takeScreenshot();
-  }
-  const screenshot = Buffer.from(screenBuffer, "base64");
-  fs6.writeFileSync(absoluteFilepath, screenshot);
-  return screenshot;
-}
-
-// src/commands/browser/scroll.ts
-import logger13 from "@wdio/logger";
-var log13 = logger13("webdriverio");
-function scroll(x = 0, y = 0) {
-  if (!x && !y) {
-    return log13.warn('"scroll" command was called with no parameters, skipping execution');
+    this.#initialize = this.#browser.sessionSubscribe({
+      events: ["log.entryAdded", "browsingContext.navigationStarted"]
+    }).then(() => true, () => false);
+    this.#browser.on("log.entryAdded", this.handleLogEntry.bind(this));
+    this.#browser.on("result", this.#commandResultHandler.bind(this));
+    this.#browser.on("bidiCommand", this.#handleBidiCommand.bind(this));
+    this.#browser.scriptAddPreloadScript({
+      functionDeclaration: customElementWrapper.toString()
+    });
   }
-  if (this.isMobile) {
-    return this.execute((x2, y2) => window.scrollBy(x2, y2), x, y);
+  removeListeners() {
+    super.removeListeners();
+    this.#browser.off("log.entryAdded", this.handleLogEntry.bind(this));
+    this.#browser.off("result", this.#commandResultHandler.bind(this));
+    this.#browser.off("bidiCommand", this.#handleBidiCommand.bind(this));
   }
-  return this.action("wheel").scroll({
-    deltaX: x,
-    deltaY: y,
-    duration: 0
-  }).perform();
-}
-
-// src/commands/browser/setCookies.ts
-async function setCookies(cookieObjs) {
-  const cookieObjsList = !Array.isArray(cookieObjs) ? [cookieObjs] : cookieObjs;
-  if (cookieObjsList.some((obj) => typeof obj !== "object")) {
-    throw new Error("Invalid input (see https://webdriver.io/docs/api/browser/setCookies for documentation)");
+  async initialize() {
+    return this.#initialize;
   }
-  if (!this.isBidi) {
-    for (const cookieObj of cookieObjsList) {
-      await this.addCookie(cookieObj);
+  /**
+   * keep track of navigation events and remove shadow roots when they are no longer needed
+   */
+  #handleBidiCommand(command) {
+    if (command.method !== "browsingContext.navigate") {
+      return;
     }
-    return;
-  }
-  let url6 = new URL("http://localhost");
-  if (cookieObjsList.some((cookie) => typeof cookie.domain !== "string")) {
-    url6 = new URL(await this.getUrl());
+    const params = command.params;
+    this.#shadowRoots.delete(params.context);
   }
-  await Promise.all(cookieObjsList.map((cookie) => this.storageSetCookie({
-    cookie: {
-      ...cookie,
-      domain: cookie.domain || url6.hostname,
-      value: {
-        type: "string",
-        value: cookie.value
-      }
+  /**
+   * keep track of frame depth
+   */
+  #commandResultHandler(result) {
+    const noResultError = typeof result.result === "object" && result.result && "error" in result.result && !result.result.error;
+    if (result.command === "switchToFrame" && noResultError) {
+      this.#frameDepth++;
+    }
+    if (result.command === "switchToParentFrame" && noResultError) {
+      this.#frameDepth = Math.max(0, this.#frameDepth - 1);
     }
-  })));
-  return;
-}
-
-// src/commands/browser/setTimeout.ts
-async function setTimeout2(timeouts) {
-  if (typeof timeouts !== "object") {
-    throw new Error('Parameter for "setTimeout" command needs to be an object');
-  }
-  const timeoutValues = Object.values(timeouts);
-  if (timeoutValues.length && timeoutValues.every((timeout) => typeof timeout !== "number" || timeout < 0 || timeout > Number.MAX_SAFE_INTEGER)) {
-    throw new Error("Specified timeout values are not valid integer (see https://webdriver.io/docs/api/browser/setTimeout for documentation).");
-  }
-  const implicit = timeouts.implicit;
-  const pageLoad = timeouts["page load"] || timeouts.pageLoad;
-  const script = timeouts.script;
-  const setTimeouts = this.setTimeouts.bind(this);
-  return setTimeouts(implicit, pageLoad, script);
-}
-
-// src/commands/browser/setViewport.ts
-var minWindowSize = 0;
-var maxWindowSize = Number.MAX_SAFE_INTEGER;
-async function setViewport(options) {
-  if (typeof options.width !== "number" || typeof options.height !== "number") {
-    throw new Error("setViewport expects width and height of type number");
   }
-  if (options.width < minWindowSize || options.width > maxWindowSize || options.height < minWindowSize || options.height > maxWindowSize) {
-    throw new Error("setViewport expects width and height to be a number in the 0 to 2^31 \u2212 1 range");
+  /**
+   * check if we are within a frame
+   * @returns {boolean} true if we are within a frame
+   */
+  isWithinFrame() {
+    return this.#frameDepth > 0;
   }
-  if (options.devicePixelRatio && (typeof options.devicePixelRatio !== "number" || options.devicePixelRatio < 0)) {
-    throw new Error("setViewport expects devicePixelRatio to be a number in the 0 to 2^31 \u2212 1 range");
+  /**
+   * capture shadow root elements propagated through console.debug
+   */
+  handleLogEntry(logEntry) {
+    const args = "args" in logEntry && logEntry.level === "debug" ? logEntry.args : void 0;
+    if (!args || args[0].type !== "string" || args[0].value !== "[WDIO]" || args[1].type !== "string") {
+      return;
+    }
+    if (!logEntry.source.context) {
+      return;
+    }
+    const eventType = args[1].value;
+    if (eventType === "newShadowRoot" && args[2].type === "node" && args[3].type === "node") {
+      const [
+        /* [WDIO] */
+        ,
+        /* newShadowRoot */
+        ,
+        shadowElem,
+        rootElem,
+        isDocument,
+        documentElement
+      ] = args;
+      if (!this.#shadowRoots.has(logEntry.source.context)) {
+        if (!rootElem.sharedId) {
+          throw new Error(`Expected "sharedId" parameter from object ${rootElem}`);
+        }
+        this.#shadowRoots.set(logEntry.source.context, new ShadowRootTree(rootElem.sharedId));
+      } else if (isDocument.type === "boolean" && isDocument.value) {
+        if (!rootElem.sharedId) {
+          throw new Error(`Expected "sharedId" parameter from object ${rootElem}`);
+        }
+        const tree2 = this.#shadowRoots.get(logEntry.source.context);
+        if (tree2?.element !== rootElem.sharedId) {
+          this.#shadowRoots.set(logEntry.source.context, new ShadowRootTree(rootElem.sharedId));
+        }
+      }
+      this.#documentElement = documentElement;
+      const tree = this.#shadowRoots.get(logEntry.source.context);
+      if (!tree) {
+        throw new Error(`Couldn't find tree for context id ${logEntry.source.context}`);
+      }
+      if (
+        // we expect an element id
+        !shadowElem.sharedId || // we expect the element to have a shadow root
+        !shadowElem.value?.shadowRoot?.sharedId || // we expect the shadow root to have a proper type
+        shadowElem.value.shadowRoot.value?.nodeType !== 11
+      ) {
+        return log12.warn(`Expected element with shadow root but found <${shadowElem.value?.localName} />`);
+      }
+      log12.info(`Registered new shadow root for element <${shadowElem.value.localName} /> with id ${shadowElem.value.shadowRoot.sharedId}`);
+      const newTree = new ShadowRootTree(
+        shadowElem.sharedId,
+        shadowElem.value.shadowRoot.sharedId,
+        shadowElem.value.shadowRoot.value.mode
+      );
+      if (rootElem.sharedId) {
+        tree.addShadowElement(rootElem.sharedId, newTree);
+      } else {
+        tree.addShadowElement(newTree);
+      }
+      return;
+    }
+    if (eventType === "removeShadowRoot" && args[2].type === "node" && args[2].sharedId) {
+      const tree = this.#shadowRoots.get(logEntry.source.context);
+      if (!tree) {
+        return;
+      }
+      return tree.remove(args[2].sharedId);
+    }
+    throw new Error(`Invalid parameters for "${eventType}" event: ${args.join(", ")}`);
   }
-  const contextManager2 = getContextManager(this);
-  const context = await contextManager2.getCurrentContext();
-  await this.browsingContextSetViewport({
-    context,
-    devicePixelRatio: options.devicePixelRatio || 1,
-    viewport: {
-      width: options.width,
-      height: options.height
+  getShadowElementsByContextId(contextId, scope) {
+    let tree = this.#shadowRoots.get(contextId);
+    if (!tree) {
+      return [];
     }
-  });
-}
-
-// src/commands/browser/setWindowSize.ts
-import { getBrowserObject as getBrowserObject8 } from "@wdio/utils";
-var minWindowSize2 = 0;
-var maxWindowSize2 = Number.MAX_SAFE_INTEGER;
-async function setWindowSize(width, height) {
-  if (typeof width !== "number" || typeof height !== "number") {
-    throw new Error("setWindowSize expects width and height of type number");
+    let documentElement;
+    if (scope) {
+      const subTree = tree.find(scope);
+      if (subTree) {
+        tree = subTree;
+      }
+    } else {
+      documentElement = this.#documentElement?.sharedId;
+    }
+    const elements = tree.getAllLookupScopes();
+    return [
+      ...documentElement ? [documentElement] : [],
+      ...new Set(elements).values()
+    ];
   }
-  if (width < minWindowSize2 || width > maxWindowSize2 || height < minWindowSize2 || height > maxWindowSize2) {
-    throw new Error("setWindowSize expects width and height to be a number in the 0 to 2^31 \u2212 1 range");
+  getShadowElementPairsByContextId(contextId, scope) {
+    let tree = this.#shadowRoots.get(contextId);
+    if (!tree) {
+      return [];
+    }
+    if (scope) {
+      const subTree = tree.find(scope);
+      if (subTree) {
+        tree = subTree;
+      }
+    }
+    return tree.flat().map((tree2) => [tree2.element, tree2.shadowRoot]);
   }
-  const browser = getBrowserObject8(this);
-  await browser.setWindowRect(null, null, width, height);
-}
-
-// src/commands/browser/switchWindow.ts
-async function switchWindow(matcher) {
-  if (typeof matcher !== "string" && !(matcher instanceof RegExp)) {
-    throw new Error('Unsupported parameter for switchWindow, required is "string" or a RegExp');
+  getShadowRootModeById(contextId, element) {
+    const tree = this.#shadowRoots.get(contextId);
+    if (!tree) {
+      return;
+    }
+    const shadowTree = tree.find(element);
+    if (!shadowTree) {
+      return;
+    }
+    return shadowTree.mode;
   }
-  const currentWindow = await this.getWindowHandle();
-  if (typeof matcher === "string" && currentWindow === matcher) {
-    return currentWindow;
+  deleteShadowRoot(element, contextId) {
+    const tree = this.#shadowRoots.get(contextId);
+    if (!tree) {
+      return;
+    }
+    return tree.remove(element);
   }
-  const contextManager2 = getContextManager(this);
-  const tabs = await this.getWindowHandles();
-  if (typeof matcher === "string" && tabs.includes(matcher)) {
-    await this.switchToWindow(matcher);
-    contextManager2.setCurrentContext(matcher);
-    return matcher;
+};
+var ShadowRootTree = class _ShadowRootTree {
+  element;
+  shadowRoot;
+  mode;
+  children = /* @__PURE__ */ new Set();
+  constructor(element, shadowRoot, mode) {
+    this.element = element;
+    this.shadowRoot = shadowRoot;
+    this.mode = mode;
   }
-  const matchesTarget = (target) => {
-    if (typeof matcher === "string") {
-      return target.includes(matcher);
-    }
-    return !!target.match(matcher);
-  };
-  for (const tab of tabs) {
-    await this.switchToWindow(tab);
-    contextManager2.setCurrentContext(tab);
-    const url6 = await this.getUrl();
-    if (matchesTarget(url6)) {
-      return tab;
+  addShadowElement(...args) {
+    const [scope, treeArg] = args;
+    if (!scope && !treeArg) {
+      throw new Error('Method "addShadowElement" expects at least 2 arguments');
     }
-    const title = await this.getTitle();
-    if (matchesTarget(title)) {
-      return tab;
+    if (scope instanceof _ShadowRootTree) {
+      this.children.add(scope);
+      return;
     }
-    const windowName = await this.execute(
-      /* istanbul ignore next */
-      () => window.name
-    );
-    if (windowName && matchesTarget(windowName)) {
-      return tab;
+    if (typeof scope === "string" && treeArg instanceof _ShadowRootTree) {
+      const tree = this.find(scope) || this.findByShadowId(scope);
+      if (!tree) {
+        throw new Error(`Couldn't find element with id ${scope}`);
+      }
+      tree.addShadowElement(treeArg);
+      return;
     }
+    throw new Error('Invalid arguments for "addShadowElement" method');
   }
-  await this.switchToWindow(currentWindow);
-  throw new Error(`No window found with title, url, name or window handle matching "${matcher}"`);
-}
-
-// src/commands/browser/switchFrame.ts
-import logger14 from "@wdio/logger";
-import { ELEMENT_KEY as ELEMENT_KEY8 } from "webdriver";
-var log14 = logger14("webdriverio:switchFrame");
-async function switchFrame(context) {
-  function isPossiblyUnresolvedElement(input) {
-    return Boolean(input) && typeof input === "object" && typeof input.getElement === "function";
-  }
-  if (!this.isBidi) {
-    if (typeof context === "function") {
-      throw new Error("Cannot use a function to fetch a context in WebDriver Classic");
+  find(element) {
+    if (this.element === element) {
+      return this;
     }
-    if (typeof context === "string") {
-      throw new Error("Cannot use a string to fetch a context in WebDriver Classic");
+    for (const child of this.children) {
+      const elem = child.find(element);
+      if (elem) {
+        return elem;
+      }
     }
-    if (isPossiblyUnresolvedElement(context)) {
-      const element = await context.getElement();
-      await element.waitForExist({
-        timeoutMsg: `Can't switch to frame with selector ${element.selector} because it doesn't exist`
-      });
-      return switchToFrame(this, element);
+    return void 0;
+  }
+  findByShadowId(shadowRoot) {
+    if (this.shadowRoot === shadowRoot) {
+      return this;
     }
-    return switchToFrame(this, context);
+    for (const child of this.children) {
+      const elem = child.findByShadowId(shadowRoot);
+      if (elem) {
+        return elem;
+      }
+    }
+    return void 0;
   }
-  if (context === null) {
-    const handle = await this.getWindowHandle();
-    switchToFrameHelper(this, handle);
-    await switchToFrame(this, context);
-    return handle;
+  getAllLookupScopes() {
+    return [
+      this.shadowRoot ?? this.element,
+      ...Array.from(this.children).map((tree) => tree.getAllLookupScopes())
+    ].flat();
   }
-  if (typeof context === "string") {
-    const tree = await this.browsingContextGetTree({});
-    let newContextId;
-    const urlContext = findContext(context, tree.contexts, byUrl) || /**
-     * In case the user provides an url without `/` at the end, e.g. `https://example.com`,
-     * the `browsingContextGetTree` command may return a context with the url `https://example.com/`.
-     */
-    findContext(`${context}/`, tree.contexts, byUrl);
+  flat() {
+    return [this, ...Array.from(this.children).map((tree) => tree.flat())].flat();
+  }
+  remove(element) {
+    const childArray = Array.from(this.children);
+    for (let i = childArray.length - 1; i >= 0; i--) {
+      if (childArray[i].element === element) {
+        return this.children.delete(childArray[i]);
+      }
+      const wasFound = childArray[i].remove(element);
+      if (wasFound) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/session/networkManager.ts
+function getNetworkManager(browser) {
+  return SessionManager.getSessionManager(browser, NetworkManager);
+}
+var UNKNOWN_NAVIGATION_ID = "UNKNOWN_NAVIGATION_ID";
+var SUPPORTED_NAVIGATION_PROTOCOLS = ["http", "https", "data", "file"];
+var NetworkManager = class _NetworkManager extends SessionManager {
+  #browser;
+  #initialize;
+  #requests = /* @__PURE__ */ new Map();
+  #lastNetworkId;
+  constructor(browser) {
+    super(browser, _NetworkManager.name);
+    this.#browser = browser;
+    if (!this.isEnabled()) {
+      this.#initialize = Promise.resolve(true);
+      return;
+    }
+    this.#initialize = this.#browser.sessionSubscribe({
+      events: [
+        "browsingContext.navigationStarted",
+        "network.responseCompleted",
+        "network.beforeRequestSent",
+        "network.fetchError"
+      ]
+    }).then(() => true, () => false);
+    this.#browser.on("browsingContext.navigationStarted", this.#navigationStarted.bind(this));
+    this.#browser.on("network.responseCompleted", this.#responseCompleted.bind(this));
+    this.#browser.on("network.beforeRequestSent", this.#beforeRequestSent.bind(this));
+    this.#browser.on("network.fetchError", this.#fetchError.bind(this));
+  }
+  removeListeners() {
+    super.removeListeners();
+    this.#browser.off("browsingContext.navigationStarted", this.#navigationStarted.bind(this));
+    this.#browser.off("network.responseCompleted", this.#responseCompleted.bind(this));
+    this.#browser.off("network.beforeRequestSent", this.#beforeRequestSent.bind(this));
+    this.#browser.off("network.fetchError", this.#fetchError.bind(this));
+  }
+  async initialize() {
+    return this.#initialize;
+  }
+  #beforeRequestSent(log25) {
+    if (log25.navigation) {
+      return;
+    }
+    const request = this.#findRootRequest(log25.navigation);
+    if (!request) {
+      return;
+    }
+    const { request: id, headers, cookies, url: url6 } = log25.request;
+    request.children?.push({
+      id,
+      url: url6,
+      headers: headerListToObject(headers),
+      cookies: cookies.map((cookie) => ({
+        name: cookie.name,
+        value: cookie.value.type === "string" ? cookie.value.value : atob(cookie.value.value),
+        domain: cookie.domain,
+        path: cookie.path,
+        size: cookie.size,
+        httpOnly: cookie.httpOnly,
+        secure: cookie.secure,
+        sameSite: cookie.sameSite,
+        expiry: cookie.expiry
+      })),
+      timestamp: log25.timestamp
+    });
+  }
+  #navigationStarted(log25) {
+    if (
+      /**
+       * we need a navigation id to identify the request
+       */
+      !log25.navigation || /**
+       * ignore urls that users wouldn't navigate to
+       */
+      !SUPPORTED_NAVIGATION_PROTOCOLS.some((protocol) => log25.url.startsWith(protocol))
+    ) {
+      if (log25.navigation === null && log25.url === "") {
+        this.#lastNetworkId = UNKNOWN_NAVIGATION_ID;
+        return this.#requests.set(UNKNOWN_NAVIGATION_ID, {
+          url: "",
+          headers: {},
+          timestamp: log25.timestamp,
+          redirectChain: [],
+          children: []
+        });
+      }
+      return;
+    }
+    this.#lastNetworkId = log25.navigation;
+    this.#requests.set(log25.navigation, {
+      url: log25.url,
+      headers: {},
+      timestamp: log25.timestamp,
+      navigation: log25.navigation,
+      redirectChain: [],
+      children: []
+    });
+  }
+  #fetchError(log25) {
+    const response = this.#findRootRequest(log25.navigation);
+    if (!response) {
+      return;
+    }
+    const request = response.children?.find((child) => child.id === log25.request.request);
+    if (!request) {
+      return;
+    }
+    request.error = log25.errorText;
+  }
+  #findRootRequest(navigationId) {
+    const response = this.#requests.get(navigationId || UNKNOWN_NAVIGATION_ID);
+    if (response) {
+      return response;
+    }
+    const firstRequest = this.#requests.values().next().value;
+    return this.#lastNetworkId ? this.#requests.get(this.#lastNetworkId) || firstRequest : firstRequest;
+  }
+  #responseCompleted(log25) {
+    const response = this.#findRootRequest(log25.navigation);
+    if (!response) {
+      return;
+    }
+    if (!response.navigation && response.url === "") {
+      response.url = log25.request.url;
+      response.navigation = log25.navigation;
+    }
+    if (log25.navigation === response.navigation) {
+      if (response.url !== log25.response.url) {
+        response.redirectChain?.push(response.url);
+      }
+      response.url = log25.response.url;
+      const { headers: requestHeaders } = log25.request;
+      const { fromCache, headers: responseHeaders, mimeType, status } = log25.response;
+      response.headers = headerListToObject(requestHeaders), response.response = {
+        fromCache,
+        headers: headerListToObject(responseHeaders),
+        mimeType,
+        status
+      };
+      return;
+    }
+    const request = response.children?.find((child) => child.id === log25.request.request);
+    if (!request) {
+      return;
+    }
+    request.response = {
+      fromCache: log25.response.fromCache,
+      headers: headerListToObject(log25.response.headers),
+      mimeType: log25.response.mimeType,
+      status: log25.response.status
+    };
+    response.children?.push(request);
+  }
+  getRequestResponseData(navigationId) {
+    return this.#requests.get(navigationId);
+  }
+  /**
+   * Returns the number of requests that are currently pending.
+   * @param context browsing context id
+   * @returns the number of requests that are currently pending
+   */
+  getPendingRequests(navigationId) {
+    const request = this.#requests.get(navigationId);
+    if (!request) {
+      throw new Error(`Couldn't find request for navigation with id ${navigationId}`);
+    }
+    const subRequests = request.children || [];
+    return subRequests.filter((child) => (
+      /**
+       * either the request has no response yet
+       */
+      !child.response && /**
+       * and there was no request error
+       */
+      !child.error
+    ));
+  }
+};
+function headerListToObject(headers) {
+  return headers.reduce((acc, { name, value }) => {
+    acc[name] = value.value;
+    return acc;
+  }, {});
+}
+
+// src/session/dialog.ts
+function getDialogManager(browser) {
+  return SessionManager.getSessionManager(browser, DialogManager);
+}
+var DialogManager = class _DialogManager extends SessionManager {
+  #browser;
+  #initialize;
+  #autoHandleDialog = true;
+  constructor(browser) {
+    super(browser, _DialogManager.name);
+    this.#browser = browser;
+    if (!this.isEnabled()) {
+      this.#initialize = Promise.resolve(true);
+      return;
+    }
+    this.#initialize = this.#browser.sessionSubscribe({
+      events: ["browsingContext.userPromptOpened"]
+    }).then(() => true, () => false);
+    this.#browser.on("_dialogListenerRegistered", () => this.#switchListenerFlag(false));
+    this.#browser.on("_dialogListenerRemoved", () => this.#switchListenerFlag(true));
+    this.#browser.on("browsingContext.userPromptOpened", this.#handleUserPrompt.bind(this));
+  }
+  removeListeners() {
+    super.removeListeners();
+    this.#browser.off("browsingContext.userPromptOpened", this.#handleUserPrompt.bind(this));
+    this.#browser.removeAllListeners("_dialogListenerRegistered");
+    this.#browser.removeAllListeners("_dialogListenerRemoved");
+  }
+  async initialize() {
+    return this.#initialize;
+  }
+  /**
+   * capture shadow root elements propagated through console.debug
+   */
+  async #handleUserPrompt(log25) {
+    if (this.#autoHandleDialog) {
+      return this.#browser.browsingContextHandleUserPrompt({
+        accept: false,
+        context: log25.context
+      });
+    }
+    const dialog = new Dialog(log25, this.#browser);
+    this.#browser.emit("dialog", dialog);
+  }
+  /**
+   * Is called when a new dialog listener is registered with the `dialog` name.
+   * In these cases we set a flag to the `#listener` map to indicate that we
+   * are listening to dialog events for this page in this context.
+   */
+  #switchListenerFlag(value) {
+    this.#autoHandleDialog = value;
+  }
+};
+var Dialog = class {
+  #browser;
+  #context;
+  #message;
+  #defaultValue;
+  #type;
+  constructor(event, browser) {
+    this.#message = event.message;
+    this.#defaultValue = event.defaultValue;
+    this.#type = event.type;
+    this.#context = event.context;
+    this.#browser = browser;
+  }
+  message() {
+    return this.#message;
+  }
+  defaultValue() {
+    return this.#defaultValue;
+  }
+  type() {
+    return this.#type;
+  }
+  /**
+   * Returns when the dialog has been accepted.
+   *
+   * @alias dialog.accept
+   * @param {string=} promptText  A text to enter into prompt. Does not cause any effects if the dialog's type is not prompt.
+   * @returns {Promise<void>}
+   */
+  async accept(userText) {
+    await this.#browser.browsingContextHandleUserPrompt({
+      accept: true,
+      context: this.#context,
+      userText
+    });
+  }
+  async dismiss() {
+    await this.#browser.browsingContextHandleUserPrompt({
+      accept: false,
+      context: this.#context
+    });
+  }
+};
+
+// src/session/index.ts
+function registerSessionManager(instance) {
+  return Promise.all([
+    getPolyfillManager(instance).initialize(),
+    getShadowRootManager(instance).initialize(),
+    getNetworkManager(instance).initialize(),
+    getDialogManager(instance).initialize(),
+    getContextManager(instance).initialize()
+  ]);
+}
+
+// src/commands/browser/reloadSession.ts
+var log13 = logger13("webdriverio");
+async function reloadSession(newCapabilities) {
+  const oldSessionId = this.sessionId;
+  const shutdownDriver = Boolean(newCapabilities?.browserName);
+  try {
+    await this.deleteSession({ shutdownDriver });
+  } catch (err) {
+    log13.warn(`Suppressing error closing the session: ${err.stack}`);
+  }
+  if (this.puppeteer?.connected) {
+    this.puppeteer.disconnect();
+    log13.debug("Disconnected puppeteer session");
+  }
+  const ProtocolDriver = (await import(
+    /* @vite-ignore */
+    this.options.automationProtocol
+  )).default;
+  await ProtocolDriver.reloadSession(this, newCapabilities);
+  await registerSessionManager(this);
+  const options = this.options;
+  if (Array.isArray(options.onReload) && options.onReload.length) {
+    await Promise.all(options.onReload.map((hook) => hook(oldSessionId, this.sessionId)));
+  }
+  return this.sessionId;
+}
+
+// src/commands/browser/restore.ts
+async function restore(scopes2) {
+  const scopeArray = !scopes2 || Array.isArray(scopes2) ? scopes2 : [scopes2];
+  const instanceRestoreFunctions = restoreFunctions.get(this);
+  if (!instanceRestoreFunctions) {
+    return;
+  }
+  await Promise.all(Array.from(instanceRestoreFunctions.entries()).map(async ([scope, restoreFunctionsList]) => {
+    if (!scopeArray || scopeArray.includes(scope)) {
+      await Promise.all(restoreFunctionsList.map((fn) => fn()));
+      instanceRestoreFunctions.set(scope, []);
+    }
+  }));
+}
+
+// src/commands/browser/savePDF.ts
+import fs4 from "node:fs";
+async function savePDF(filepath, options) {
+  if (typeof filepath !== "string" || !filepath.endsWith(".pdf")) {
+    throw new Error('savePDF expects a filepath of type string and ".pdf" file ending');
+  }
+  const absoluteFilepath = getAbsoluteFilepath(filepath);
+  await assertDirectoryExists(absoluteFilepath);
+  const pdf = await this.printPage(
+    options?.orientation,
+    options?.scale,
+    options?.background,
+    options?.width,
+    options?.height,
+    options?.top,
+    options?.bottom,
+    options?.left,
+    options?.right,
+    options?.shrinkToFit,
+    options?.pageRanges
+  );
+  const page = Buffer.from(pdf, "base64");
+  fs4.writeFileSync(absoluteFilepath, page);
+  return page;
+}
+
+// src/commands/browser/saveRecordingScreen.ts
+import fs5 from "node:fs";
+async function saveRecordingScreen(filepath) {
+  if (typeof filepath !== "string") {
+    throw new Error("saveRecordingScreen expects a filepath");
+  }
+  const absoluteFilepath = getAbsoluteFilepath(filepath);
+  await assertDirectoryExists(absoluteFilepath);
+  const videoBuffer = await this.stopRecordingScreen();
+  const video = Buffer.from(videoBuffer, "base64");
+  fs5.writeFileSync(absoluteFilepath, video);
+  return video;
+}
+
+// src/commands/browser/saveScreenshot.ts
+import fs6 from "node:fs";
+import { getBrowserObject as getBrowserObject7 } from "@wdio/utils";
+async function saveScreenshot(filepath) {
+  if (typeof filepath !== "string" || !filepath.endsWith(".png")) {
+    throw new Error('saveScreenshot expects a filepath of type string and ".png" file ending');
+  }
+  const absoluteFilepath = getAbsoluteFilepath(filepath);
+  await assertDirectoryExists(absoluteFilepath);
+  let screenBuffer;
+  if (this.isBidi) {
+    const browser = getBrowserObject7(this);
+    const contextManager = getContextManager(browser);
+    const context = await contextManager.getCurrentContext();
+    const { data } = await this.browsingContextCaptureScreenshot({ context });
+    screenBuffer = data;
+  } else {
+    screenBuffer = await this.takeScreenshot();
+  }
+  const screenshot = Buffer.from(screenBuffer, "base64");
+  fs6.writeFileSync(absoluteFilepath, screenshot);
+  return screenshot;
+}
+
+// src/commands/browser/scroll.ts
+import logger14 from "@wdio/logger";
+var log14 = logger14("webdriverio");
+function scroll(x = 0, y = 0) {
+  if (!x && !y) {
+    return log14.warn('"scroll" command was called with no parameters, skipping execution');
+  }
+  if (this.isMobile) {
+    return this.execute((x2, y2) => window.scrollBy(x2, y2), x, y);
+  }
+  return this.action("wheel").scroll({
+    deltaX: x,
+    deltaY: y,
+    duration: 0
+  }).perform();
+}
+
+// src/commands/browser/setCookies.ts
+async function setCookies(cookieObjs) {
+  const cookieObjsList = !Array.isArray(cookieObjs) ? [cookieObjs] : cookieObjs;
+  if (cookieObjsList.some((obj) => typeof obj !== "object")) {
+    throw new Error("Invalid input (see https://webdriver.io/docs/api/browser/setCookies for documentation)");
+  }
+  if (!this.isBidi) {
+    for (const cookieObj of cookieObjsList) {
+      await this.addCookie(cookieObj);
+    }
+    return;
+  }
+  let url6 = new URL("http://localhost");
+  if (cookieObjsList.some((cookie) => typeof cookie.domain !== "string")) {
+    url6 = new URL(await this.getUrl());
+  }
+  await Promise.all(cookieObjsList.map((cookie) => this.storageSetCookie({
+    cookie: {
+      ...cookie,
+      domain: cookie.domain || url6.hostname,
+      value: {
+        type: "string",
+        value: cookie.value
+      }
+    }
+  })));
+  return;
+}
+
+// src/commands/browser/setTimeout.ts
+async function setTimeout2(timeouts) {
+  if (typeof timeouts !== "object") {
+    throw new Error('Parameter for "setTimeout" command needs to be an object');
+  }
+  const timeoutValues = Object.values(timeouts);
+  if (timeoutValues.length && timeoutValues.every((timeout) => typeof timeout !== "number" || timeout < 0 || timeout > Number.MAX_SAFE_INTEGER)) {
+    throw new Error("Specified timeout values are not valid integer (see https://webdriver.io/docs/api/browser/setTimeout for documentation).");
+  }
+  const implicit = timeouts.implicit;
+  const pageLoad = timeouts["page load"] || timeouts.pageLoad;
+  const script = timeouts.script;
+  const setTimeouts = this.setTimeouts.bind(this);
+  return setTimeouts(implicit, pageLoad, script);
+}
+
+// src/commands/browser/setViewport.ts
+var minWindowSize = 0;
+var maxWindowSize = Number.MAX_SAFE_INTEGER;
+async function setViewport(options) {
+  if (typeof options.width !== "number" || typeof options.height !== "number") {
+    throw new Error("setViewport expects width and height of type number");
+  }
+  if (options.width < minWindowSize || options.width > maxWindowSize || options.height < minWindowSize || options.height > maxWindowSize) {
+    throw new Error("setViewport expects width and height to be a number in the 0 to 2^31 \u2212 1 range");
+  }
+  if (options.devicePixelRatio && (typeof options.devicePixelRatio !== "number" || options.devicePixelRatio < 0)) {
+    throw new Error("setViewport expects devicePixelRatio to be a number in the 0 to 2^31 \u2212 1 range");
+  }
+  const contextManager = getContextManager(this);
+  const context = await contextManager.getCurrentContext();
+  await this.browsingContextSetViewport({
+    context,
+    devicePixelRatio: options.devicePixelRatio || 1,
+    viewport: {
+      width: options.width,
+      height: options.height
+    }
+  });
+}
+
+// src/commands/browser/setWindowSize.ts
+import { getBrowserObject as getBrowserObject8 } from "@wdio/utils";
+var minWindowSize2 = 0;
+var maxWindowSize2 = Number.MAX_SAFE_INTEGER;
+async function setWindowSize(width, height) {
+  if (typeof width !== "number" || typeof height !== "number") {
+    throw new Error("setWindowSize expects width and height of type number");
+  }
+  if (width < minWindowSize2 || width > maxWindowSize2 || height < minWindowSize2 || height > maxWindowSize2) {
+    throw new Error("setWindowSize expects width and height to be a number in the 0 to 2^31 \u2212 1 range");
+  }
+  const browser = getBrowserObject8(this);
+  await browser.setWindowRect(null, null, width, height);
+}
+
+// src/commands/browser/switchWindow.ts
+async function switchWindow(matcher) {
+  if (typeof matcher !== "string" && !(matcher instanceof RegExp)) {
+    throw new Error('Unsupported parameter for switchWindow, required is "string" or a RegExp');
+  }
+  const currentWindow = await this.getWindowHandle();
+  if (typeof matcher === "string" && currentWindow === matcher) {
+    return currentWindow;
+  }
+  const contextManager = getContextManager(this);
+  const tabs = await this.getWindowHandles();
+  if (typeof matcher === "string" && tabs.includes(matcher)) {
+    await this.switchToWindow(matcher);
+    contextManager.setCurrentContext(matcher);
+    return matcher;
+  }
+  const matchesTarget = (target) => {
+    if (typeof matcher === "string") {
+      return target.includes(matcher);
+    }
+    return !!target.match(matcher);
+  };
+  for (const tab of tabs) {
+    await this.switchToWindow(tab);
+    contextManager.setCurrentContext(tab);
+    const url6 = await this.getUrl();
+    if (matchesTarget(url6)) {
+      return tab;
+    }
+    const title = await this.getTitle();
+    if (matchesTarget(title)) {
+      return tab;
+    }
+    const windowName = await this.execute(
+      /* istanbul ignore next */
+      () => window.name
+    );
+    if (windowName && matchesTarget(windowName)) {
+      return tab;
+    }
+  }
+  await this.switchToWindow(currentWindow);
+  throw new Error(`No window found with title, url, name or window handle matching "${matcher}"`);
+}
+
+// src/commands/browser/switchFrame.ts
+import logger15 from "@wdio/logger";
+import { ELEMENT_KEY as ELEMENT_KEY8 } from "webdriver";
+var log15 = logger15("webdriverio:switchFrame");
+async function switchFrame(context) {
+  function isPossiblyUnresolvedElement(input) {
+    return Boolean(input) && typeof input === "object" && typeof input.getElement === "function";
+  }
+  if (!this.isBidi) {
+    if (typeof context === "function") {
+      throw new Error("Cannot use a function to fetch a context in WebDriver Classic");
+    }
+    if (typeof context === "string") {
+      throw new Error("Cannot use a string to fetch a context in WebDriver Classic");
+    }
+    if (isPossiblyUnresolvedElement(context)) {
+      const element = await context.getElement();
+      await element.waitForExist({
+        timeoutMsg: `Can't switch to frame with selector ${element.selector} because it doesn't exist`
+      });
+      return switchToFrame(this, element);
+    }
+    return switchToFrame(this, context);
+  }
+  if (context === null) {
+    const handle = await this.getWindowHandle();
+    switchToFrameHelper(this, handle);
+    await switchToFrame(this, context);
+    return handle;
+  }
+  if (typeof context === "string") {
+    const tree = await this.browsingContextGetTree({});
+    let newContextId;
+    const urlContext = findContext(context, tree.contexts, byUrl) || /**
+     * In case the user provides an url without `/` at the end, e.g. `https://example.com`,
+     * the `browsingContextGetTree` command may return a context with the url `https://example.com/`.
+     */
+    findContext(`${context}/`, tree.contexts, byUrl);
     const urlContextContaining = findContext(context, tree.contexts, byUrlContaining);
     const contextIdContext = findContext(context, tree.contexts, byContextId);
     if (urlContext) {
-      log14.info(`Found context by url "${urlContext.url}" with context id "${urlContext.context}"`);
+      log15.info(`Found context by url "${urlContext.url}" with context id "${urlContext.context}"`);
       newContextId = urlContext.context;
     } else if (urlContextContaining) {
-      log14.info(`Found context by url containing "${urlContextContaining.url}" with context id "${urlContextContaining.context}"`);
+      log15.info(`Found context by url containing "${urlContextContaining.url}" with context id "${urlContextContaining.context}"`);
       newContextId = urlContextContaining.context;
     } else if (contextIdContext) {
-      log14.info(`Found context by id "${contextIdContext}" with url "${contextIdContext.url}"`);
+      log15.info(`Found context by id "${contextIdContext}" with url "${contextIdContext.url}"`);
       newContextId = contextIdContext.context;
     }
     if (!newContextId) {
@@ -4390,7 +5013,7 @@ async function switchFrame(context) {
           arguments: args.map((arg) => LocalValue.getArgument(arg)),
           target: { context: id }
         };
-        const result = await this.scriptCallFunction(params).catch((err) => log14.warn(`Failed to identify frame context id: ${err.message}`));
+        const result = await this.scriptCallFunction(params).catch((err) => log15.warn(`Failed to identify frame context id: ${err.message}`));
         if (!result) {
           return [];
         }
@@ -4420,13 +5043,13 @@ async function switchFrame(context) {
     let desiredFrame;
     let desiredContext = newContextId;
     const contextQueue = [];
-    log14.info(`Available frames to switch to: ${allFrames.length}, desired context to switch: ${desiredContext}`);
+    log15.info(`Available frames to switch to: ${allFrames.length}, desired context to switch: ${desiredContext}`);
     while (desiredContext !== currentContext) {
       desiredFrame = allFrames.find(({ context: context2 }) => context2 === desiredContext);
       if (!desiredFrame) {
         break;
       }
-      log14.info(
+      log15.info(
         contextQueue.length === 0 ? `Found desired frame with element id ${desiredFrame.frameElement[ELEMENT_KEY8]}` : `to switch to desired frame, we need to switch to ${desiredFrame.context} first`
       );
       contextQueue.unshift(desiredFrame);
@@ -4462,7 +5085,7 @@ async function switchFrame(context) {
         arguments: [],
         target: { context: contextId }
       };
-      const result = await this.scriptCallFunction(params).catch((err) => log14.warn(`switchFrame context callback threw error: ${err.message}`));
+      const result = await this.scriptCallFunction(params).catch((err) => log15.warn(`switchFrame context callback threw error: ${err.message}`));
       if (!result || result.type !== "success" || result.result.type !== "boolean" || !result.result.value) {
         continue;
       }
@@ -4472,7 +5095,7 @@ async function switchFrame(context) {
     throw new Error("Could not find the desired frame");
   }
   throw new Error(
-    `Invalid type for context parameter: ${typeof context}, expected one of number, string or null. Check out our docs: https://webdriver.io/docs/api/browser/switchToFrame.html`
+    `Invalid type for context parameter: ${typeof context}, expected one of number, string or null. Check out our docs: https://webdriver.io/docs/api/browser/switchFrame.html`
   );
 }
 function switchToFrameHelper(browser, context) {
@@ -4533,11 +5156,11 @@ function switchToFrame(browser, frame) {
 }
 
 // src/commands/browser/throttle.ts
-import logger15 from "@wdio/logger";
+import logger16 from "@wdio/logger";
 import { getBrowserObject as getBrowserObject9 } from "@wdio/utils";
-var log15 = logger15("webdriverio:throttle");
+var log16 = logger16("webdriverio:throttle");
 async function throttle(params) {
-  log15.warn('Command "throttle" is deprecated and will be removed with the next major version release! Use `throttleNetwork` instead.');
+  log16.warn('Command "throttle" is deprecated and will be removed with the next major version release! Use `throttleNetwork` instead.');
   const browser = getBrowserObject9(this);
   await browser.throttleNetwork(params);
 }
@@ -4667,205 +5290,19 @@ function touchAction2(actions2) {
 // src/commands/browser/uploadFile.ts
 import fs7 from "node:fs";
 import path2 from "node:path";
-import archiver from "archiver";
-async function uploadFile(localPath) {
-  if (typeof localPath !== "string") {
-    throw new Error("number or type of arguments don't agree with uploadFile command");
-  }
-  if (typeof this.file !== "function") {
-    throw new Error(`The uploadFile command is not available in ${this.capabilities.browserName}`);
-  }
-  const zipData = [];
-  const source = fs7.createReadStream(localPath);
-  return new Promise((resolve5, reject) => {
-    archiver("zip").on("error", (err) => reject(err)).on("data", (data) => zipData.push(data)).on("end", () => this.file(Buffer.concat(zipData).toString("base64")).then((localPath2) => resolve5(localPath2), reject)).append(source, { name: path2.basename(localPath) }).finalize();
-  });
-}
-
-// src/networkManager.ts
-var networkManager = /* @__PURE__ */ new Map();
-function getNetworkManager(browser) {
-  const existingNetworkManager = networkManager.get(browser);
-  if (existingNetworkManager) {
-    return existingNetworkManager;
-  }
-  const newContext = new NetworkManager(browser);
-  networkManager.set(browser, newContext);
-  return newContext;
-}
-var UNKNOWN_NAVIGATION_ID = "UNKNOWN_NAVIGATION_ID";
-var SUPPORTED_NAVIGATION_PROTOCOLS = ["http", "https", "data", "file"];
-var NetworkManager = class {
-  #browser;
-  #initialize;
-  #requests = /* @__PURE__ */ new Map();
-  #lastNetworkId;
-  constructor(browser) {
-    this.#browser = browser;
-    if (!browser.isBidi || process.env.WDIO_UNIT_TESTS || browser.options?.automationProtocol !== "webdriver") {
-      this.#initialize = Promise.resolve(true);
-      return;
-    }
-    this.#initialize = this.#browser.sessionSubscribe({
-      events: [
-        "browsingContext.navigationStarted",
-        "network.responseCompleted",
-        "network.beforeRequestSent",
-        "network.fetchError"
-      ]
-    }).then(() => true, () => false);
-    this.#browser.on("browsingContext.navigationStarted", this.#navigationStarted.bind(this));
-    this.#browser.on("network.responseCompleted", this.#responseCompleted.bind(this));
-    this.#browser.on("network.beforeRequestSent", this.#beforeRequestSent.bind(this));
-    this.#browser.on("network.fetchError", this.#fetchError.bind(this));
-  }
-  async initialize() {
-    return this.#initialize;
-  }
-  #beforeRequestSent(log25) {
-    if (log25.navigation) {
-      return;
-    }
-    const request = this.#findRootRequest(log25.navigation);
-    if (!request) {
-      return;
-    }
-    const { request: id, headers, cookies, url: url6 } = log25.request;
-    request.children?.push({
-      id,
-      url: url6,
-      headers: headerListToObject(headers),
-      cookies: cookies.map((cookie) => ({
-        name: cookie.name,
-        value: cookie.value.type === "string" ? cookie.value.value : atob(cookie.value.value),
-        domain: cookie.domain,
-        path: cookie.path,
-        size: cookie.size,
-        httpOnly: cookie.httpOnly,
-        secure: cookie.secure,
-        sameSite: cookie.sameSite,
-        expiry: cookie.expiry
-      })),
-      timestamp: log25.timestamp
-    });
-  }
-  #navigationStarted(log25) {
-    if (
-      /**
-       * we need a navigation id to identify the request
-       */
-      !log25.navigation || /**
-       * ignore urls that users wouldn't navigate to
-       */
-      !SUPPORTED_NAVIGATION_PROTOCOLS.some((protocol) => log25.url.startsWith(protocol))
-    ) {
-      if (log25.navigation === null && log25.url === "") {
-        this.#lastNetworkId = UNKNOWN_NAVIGATION_ID;
-        return this.#requests.set(UNKNOWN_NAVIGATION_ID, {
-          url: "",
-          headers: {},
-          timestamp: log25.timestamp,
-          redirectChain: [],
-          children: []
-        });
-      }
-      return;
-    }
-    this.#lastNetworkId = log25.navigation;
-    this.#requests.set(log25.navigation, {
-      url: log25.url,
-      headers: {},
-      timestamp: log25.timestamp,
-      navigation: log25.navigation,
-      redirectChain: [],
-      children: []
-    });
-  }
-  #fetchError(log25) {
-    const response = this.#findRootRequest(log25.navigation);
-    if (!response) {
-      return;
-    }
-    const request = response.children?.find((child) => child.id === log25.request.request);
-    if (!request) {
-      return;
-    }
-    request.error = log25.errorText;
-  }
-  #findRootRequest(navigationId) {
-    const response = this.#requests.get(navigationId || UNKNOWN_NAVIGATION_ID);
-    if (response) {
-      return response;
-    }
-    const firstRequest = this.#requests.values().next().value;
-    return this.#lastNetworkId ? this.#requests.get(this.#lastNetworkId) || firstRequest : firstRequest;
-  }
-  #responseCompleted(log25) {
-    const response = this.#findRootRequest(log25.navigation);
-    if (!response) {
-      return;
-    }
-    if (!response.navigation && response.url === "") {
-      response.url = log25.request.url;
-      response.navigation = log25.navigation;
-    }
-    if (log25.navigation === response.navigation) {
-      if (response.url !== log25.response.url) {
-        response.redirectChain?.push(response.url);
-      }
-      response.url = log25.response.url;
-      const { headers: requestHeaders } = log25.request;
-      const { fromCache, headers: responseHeaders, mimeType, status } = log25.response;
-      response.headers = headerListToObject(requestHeaders), response.response = {
-        fromCache,
-        headers: headerListToObject(responseHeaders),
-        mimeType,
-        status
-      };
-      return;
-    }
-    const request = response.children?.find((child) => child.id === log25.request.request);
-    if (!request) {
-      return;
-    }
-    request.response = {
-      fromCache: log25.response.fromCache,
-      headers: headerListToObject(log25.response.headers),
-      mimeType: log25.response.mimeType,
-      status: log25.response.status
-    };
-    response.children?.push(request);
-  }
-  getRequestResponseData(navigationId) {
-    return this.#requests.get(navigationId);
-  }
-  /**
-   * Returns the number of requests that are currently pending.
-   * @param context browsing context id
-   * @returns the number of requests that are currently pending
-   */
-  getPendingRequests(navigationId) {
-    const request = this.#requests.get(navigationId);
-    if (!request) {
-      throw new Error(`Couldn't find request for navigation with id ${navigationId}`);
-    }
-    const subRequests = request.children || [];
-    return subRequests.filter((child) => (
-      /**
-       * either the request has no response yet
-       */
-      !child.response && /**
-       * and there was no request error
-       */
-      !child.error
-    ));
+import archiver from "archiver";
+async function uploadFile(localPath) {
+  if (typeof localPath !== "string") {
+    throw new Error("number or type of arguments don't agree with uploadFile command");
   }
-};
-function headerListToObject(headers) {
-  return headers.reduce((acc, { name, value }) => {
-    acc[name] = value.value;
-    return acc;
-  }, {});
+  if (typeof this.file !== "function") {
+    throw new Error(`The uploadFile command is not available in ${this.capabilities.browserName}`);
+  }
+  const zipData = [];
+  const source = fs7.createReadStream(localPath);
+  return new Promise((resolve5, reject) => {
+    archiver("zip").on("error", (err) => reject(err)).on("data", (data) => zipData.push(data)).on("end", () => this.file(Buffer.concat(zipData).toString("base64")).then((localPath2) => resolve5(localPath2), reject)).append(source, { name: path2.basename(localPath) }).finalize();
+  });
 }
 
 // src/commands/browser/url.ts
@@ -4880,8 +5317,8 @@ async function url3(path4, options = {}) {
   }
   if (this.isBidi) {
     let resetPreloadScript;
-    const contextManager2 = getContextManager(this);
-    const context = await contextManager2.getCurrentContext();
+    const contextManager = getContextManager(this);
+    const context = await contextManager.getCurrentContext();
     if (options.onBeforeLoad) {
       if (typeof options.onBeforeLoad !== "function") {
         throw new Error(`Option "onBeforeLoad" must be a function, but received: ${typeof options.onBeforeLoad}`);
@@ -4928,7 +5365,8 @@ async function url3(path4, options = {}) {
        * set a short interval to immediately return once the first request payload comes in
        */
       {
-        interval: 1
+        interval: 1,
+        timeoutMsg: `Navigation to '${path4}' timed out as no request payload was received`
       }
     );
     return request;
@@ -4980,7 +5418,7 @@ function waitUntil(condition, {
 }
 
 // src/commands/mobile/swipe.ts
-import logger16 from "@wdio/logger";
+import logger17 from "@wdio/logger";
 
 // src/types.ts
 var MobileScrollDirection = /* @__PURE__ */ ((MobileScrollDirection2) => {
@@ -4992,7 +5430,7 @@ var MobileScrollDirection = /* @__PURE__ */ ((MobileScrollDirection2) => {
 })(MobileScrollDirection || {});
 
 // src/commands/mobile/swipe.ts
-var log16 = logger16("webdriverio");
+var log17 = logger17("webdriverio");
 var SWIPE_DEFAULTS = {
   DIRECTION: "up" /* Up */,
   DURATION: 1500,
@@ -5005,7 +5443,7 @@ async function swipe(options) {
   }
   let { scrollableElement, from, to } = options || {};
   if (scrollableElement && (from || to)) {
-    log16.warn("`scrollableElement` is provided, so `from` and `to` will be ignored.");
+    log17.warn("`scrollableElement` is provided, so `from` and `to` will be ignored.");
   }
   if (!from || !to) {
     scrollableElement = scrollableElement || await getScrollableElement(browser);
@@ -5027,9 +5465,9 @@ async function calculateFromTo({
   let swipePercentage = SWIPE_DEFAULTS.PERCENT;
   if (percentage !== void 0) {
     if (isNaN(percentage)) {
-      log16.warn("The percentage to swipe should be a number.");
+      log17.warn("The percentage to swipe should be a number.");
     } else if (percentage < 0 || percentage > 1) {
-      log16.warn("The percentage to swipe should be a number between 0 and 1.");
+      log17.warn("The percentage to swipe should be a number between 0 and 1.");
     } else {
       swipePercentage = percentage;
     }
@@ -5061,796 +5499,525 @@ async function calculateFromTo({
       to = scrollRectangles.top;
       break;
     default:
-      throw new Error(`Unknown direction: ${direction}`);
-  }
-  return { from, to };
-}
-async function getScrollableElement(browser) {
-  const defaultAndroidSelector = "//android.widget.ScrollView";
-  const defaultIosSelector = '-ios predicate string:type == "XCUIElementTypeApplication"';
-  const selector = browser.isIOS ? (
-    // For iOS, we need to find the application element, if we can't find it, we should throw an error
-    defaultIosSelector
-  ) : (
-    // There is always a scrollview for Android or, if this fails we should throw an error
-    defaultAndroidSelector
-  );
-  const scrollableElements = await browser.$$(
-    selector
-  );
-  if (scrollableElements.length > 0) {
-    return scrollableElements[0];
-  }
-  throw new Error(
-    `Default scrollable element '${browser.isIOS ? defaultIosSelector : defaultAndroidSelector}' was not found. Our advice is to provide a scrollable element like this:
-
-await browser.swipe({ scrollableElement: $('#scrollable') });
-
-        `
-  );
-}
-async function w3cSwipe({ browser, duration, from, to }) {
-  await browser.action("pointer", {
-    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
-  }).move(from.x, from.y).down().pause(10).move({ duration, x: to.x, y: to.y }).up().perform();
-  return browser.pause(500);
-}
-
-// src/commands/mobile/tap.ts
-import logger17 from "@wdio/logger";
-import { getBrowserObject as getBrowserObject11 } from "@wdio/utils";
-var log17 = logger17("webdriver");
-async function tap(options) {
-  const isElement2 = this.selector !== void 0;
-  const element = isElement2 ? this : null;
-  const browser = isElement2 ? getBrowserObject11(this) : this;
-  if (!browser.isMobile) {
-    throw new Error("The tap command is only available for mobile platforms.");
-  }
-  validateTapOptions(options);
-  if (element) {
-    return await elementTap(browser, element, options);
-  }
-  if (!options || options.x === void 0 || options.y === void 0) {
-    throw new Error("The tap command requires x and y coordinates to be set for screen taps.");
-  }
-  return await screenTap(browser, options);
-}
-function validateTapOptions(options) {
-  if (options) {
-    if (typeof options !== "object" || Array.isArray(options)) {
-      throw new TypeError("Options must be an object.");
-    }
-    const { x, y, ...otherArgs } = options;
-    if (x === void 0 !== (y === void 0)) {
-      throw new TypeError(`If ${x !== void 0 ? "x" : "y"} is set, then ${x !== void 0 ? "y" : "x"} must also be set.`);
-    }
-    if (x !== void 0 && y !== void 0 && Object.keys(otherArgs).length > 0) {
-      throw new TypeError(`If x and y are provided, no other arguments are allowed. Found: ${Object.keys(otherArgs).join(", ")}`);
-    }
-    const invalidCoordinates = [];
-    if (x !== void 0 && x < 0) {
-      invalidCoordinates.push("x");
-    }
-    if (y !== void 0 && y < 0) {
-      invalidCoordinates.push("y");
-    }
-    if (invalidCoordinates.length > 0) {
-      throw new TypeError(`The ${invalidCoordinates.join(" and ")} value${invalidCoordinates.length > 1 ? "s" : ""} must be positive.`);
-    }
-  }
-}
-async function elementTap(browser, element, options) {
-  if (browser.isNativeContext) {
-    return await nativeTap(element, browser, options);
-  }
-  if (options) {
-    log17.warn("The options object is not supported in Web environments and will be ignored.");
-  }
-  return await webTap(element);
-}
-async function webTap(element) {
-  return element.click();
-}
-async function executeNativeTap(browser, options) {
-  return await browser.execute(
-    `mobile: ${browser.isIOS ? "tap" : "clickGesture"}`,
-    { ...browser.isIOS ? { x: 0, y: 0 } : {}, ...options }
-  );
-}
-async function nativeTap(element, browser, options = {}) {
-  try {
-    if (!element.elementId) {
-      throw new Error("no such element");
-    }
-    return await executeNativeTap(browser, { elementId: element.elementId });
-  } catch (error) {
-    let err = error;
-    if (typeof error === "string") {
-      err = new Error(error);
-    }
-    if (!err.message.includes("no such element")) {
-      throw err;
-    }
-    const scrollIntoViewOptions = Object.fromEntries(
-      Object.entries({
-        direction: options?.direction,
-        maxScrolls: options?.maxScrolls,
-        scrollableElement: options?.scrollableElement
-      }).filter(([_, value]) => value !== void 0)
-    );
-    try {
-      await element.scrollIntoView(scrollIntoViewOptions);
-      return await executeNativeTap(browser, { elementId: element.elementId });
-    } catch (scrollError) {
-      let err2 = scrollError;
-      if (typeof scrollError === "string") {
-        err2 = new Error(scrollError);
-      }
-      if (err2.message.includes("Element not found within scroll limit of")) {
-        throw new Error(`Element not found within the automatic 'tap' scroll limit of ${scrollIntoViewOptions?.maxScrolls || "10"} scrolls by scrolling "${scrollIntoViewOptions?.direction || "down"}". The 'tap' methods will automatically scroll if it can't find the element. It might be that 'direction|maxScrolls|scrollableElement' are not correct. You can change change them like this:
-
-await elem.tap({
-    direction: 'left' // possible options are: 'up|down|left|right'
-    maxScrolls: 15,
-    scrollableElement: $('#scrollable'),
-});
-
-                `);
-      } else if (err2.message.includes("Default scrollable element")) {
-        const match = err2.message.match(/Default scrollable element '(.*?)' was not found/);
-        const scrollableElement = match?.[1] || "unknown-scrollable-element";
-        throw new Error(`The 'tap' method tried to automatically scroll to the element but couldn't find the default scrollable element. '${scrollableElement}' If needed you can provide a custom scrollable element, together with the 'direction' and the 'maxScrolls' like this:
-
-await elem.tap({
-    scrollableElement: $('#scrollable'),
-});
-
-                `);
-      }
-      throw err2;
-    }
-  }
-}
-async function screenTap(browser, options) {
-  const { x, y } = options;
-  if (browser.isNativeContext) {
-    return await executeNativeTap(browser, options);
-  }
-  return await browser.action(
-    "pointer",
-    {
-      parameters: { pointerType: "touch" }
-    }
-  ).move({ x, y }).down({ button: 0 }).pause(10).up({ button: 0 }).perform();
-}
-
-// src/commands/element.ts
-var element_exports = {};
-__export(element_exports, {
-  $: () => $2,
-  $$: () => $$2,
-  addValue: () => addValue,
-  clearValue: () => clearValue,
-  click: () => click,
-  custom$: () => custom$2,
-  custom$$: () => custom$$2,
-  doubleClick: () => doubleClick,
-  dragAndDrop: () => dragAndDrop,
-  execute: () => execute2,
-  executeAsync: () => executeAsync2,
-  getAttribute: () => getAttribute,
-  getCSSProperty: () => getCSSProperty,
-  getComputedLabel: () => getComputedLabel,
-  getComputedRole: () => getComputedRole,
-  getElement: () => getElement2,
-  getHTML: () => getHTML,
-  getLocation: () => getLocation,
-  getProperty: () => getProperty,
-  getSize: () => getSize,
-  getTagName: () => getTagName,
-  getText: () => getText,
-  getValue: () => getValue,
-  isClickable: () => isClickable,
-  isDisplayed: () => isDisplayed,
-  isEnabled: () => isEnabled,
-  isEqual: () => isEqual,
-  isExisting: () => isExisting,
-  isFocused: () => isFocused,
-  isSelected: () => isSelected,
-  isStable: () => isStable,
-  longPress: () => longPress,
-  moveTo: () => moveTo,
-  nextElement: () => nextElement,
-  parentElement: () => parentElement,
-  pinch: () => pinch,
-  previousElement: () => previousElement,
-  react$: () => react$2,
-  react$$: () => react$$2,
-  saveScreenshot: () => saveScreenshot2,
-  scrollIntoView: () => scrollIntoView,
-  selectByAttribute: () => selectByAttribute,
-  selectByIndex: () => selectByIndex,
-  selectByVisibleText: () => selectByVisibleText,
-  setValue: () => setValue,
-  shadow$: () => shadow$,
-  shadow$$: () => shadow$$,
-  tap: () => tap,
-  touchAction: () => touchAction3,
-  waitForClickable: () => waitForClickable,
-  waitForDisplayed: () => waitForDisplayed,
-  waitForEnabled: () => waitForEnabled,
-  waitForExist: () => waitForExist,
-  waitForStable: () => waitForStable,
-  waitUntil: () => waitUntil2,
-  zoom: () => zoom
-});
-
-// src/commands/element/$$.ts
-var $$2 = $$;
-
-// src/commands/element/$.ts
-var $2 = $;
-
-// src/commands/element/addValue.ts
-var VALID_TYPES = ["string", "number"];
-function addValue(value) {
-  if (!VALID_TYPES.includes(typeof value)) {
-    throw new Error(
-      'The setValue/addValue command only take string or number values. If you like to use special characters, use the "keys" command.'
-    );
+      throw new Error(`Unknown direction: ${direction}`);
   }
-  return this.elementSendKeys(this.elementId, value.toString());
+  return { from, to };
 }
+async function getScrollableElement(browser) {
+  const defaultAndroidSelector = "//android.widget.ScrollView";
+  const defaultIosSelector = '-ios predicate string:type == "XCUIElementTypeApplication"';
+  const selector = browser.isIOS ? (
+    // For iOS, we need to find the application element, if we can't find it, we should throw an error
+    defaultIosSelector
+  ) : (
+    // There is always a scrollview for Android or, if this fails we should throw an error
+    defaultAndroidSelector
+  );
+  const scrollableElements = await browser.$$(
+    selector
+  );
+  if (scrollableElements.length > 0) {
+    return scrollableElements[0];
+  }
+  throw new Error(
+    `Default scrollable element '${browser.isIOS ? defaultIosSelector : defaultAndroidSelector}' was not found. Our advice is to provide a scrollable element like this:
 
-// src/commands/element/clearValue.ts
-function clearValue() {
-  return this.elementClear(this.elementId);
+await browser.swipe({ scrollableElement: $('#scrollable') });
+
+        `
+  );
+}
+async function w3cSwipe({ browser, duration, from, to }) {
+  await browser.action("pointer", {
+    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+  }).move(from.x, from.y).down().pause(10).move({ duration, x: to.x, y: to.y }).up().perform();
+  return browser.pause(500);
 }
 
-// src/commands/element/click.ts
+// src/commands/mobile/tap.ts
 import logger18 from "@wdio/logger";
-import { getBrowserObject as getBrowserObject12 } from "@wdio/utils";
+import { getBrowserObject as getBrowserObject11 } from "@wdio/utils";
 var log18 = logger18("webdriver");
-function click(options) {
-  if (typeof options !== "undefined") {
-    if (typeof options !== "object" || Array.isArray(options)) {
-      throw new TypeError("Options must be an object");
-    }
-    return actionClick(this, options);
+async function tap(options) {
+  const isElement2 = this.selector !== void 0;
+  const element = isElement2 ? this : null;
+  const browser = isElement2 ? getBrowserObject11(this) : this;
+  if (!browser.isMobile) {
+    throw new Error("The tap command is only available for mobile platforms.");
   }
-  return elementClick(this);
-}
-async function workaround(element) {
-  await element.scrollIntoView({ block: "center", inline: "center" });
+  validateTapOptions(options);
+  if (element) {
+    return await elementTap(browser, element, options);
+  }
+  if (!options || options.x === void 0 || options.y === void 0) {
+    throw new Error("The tap command requires x and y coordinates to be set for screen taps.");
+  }
+  return await screenTap(browser, options);
 }
-async function elementClick(element) {
-  try {
-    return await element.elementClick(element.elementId);
-  } catch (error) {
-    let err = error;
-    if (typeof error === "string") {
-      err = new Error(error);
+function validateTapOptions(options) {
+  if (options) {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new TypeError("Options must be an object.");
     }
-    if (!err.message.includes("element click intercepted")) {
-      throw err;
+    const { x, y, ...otherArgs } = options;
+    if (x === void 0 !== (y === void 0)) {
+      throw new TypeError(`If ${x !== void 0 ? "x" : "y"} is set, then ${x !== void 0 ? "y" : "x"} must also be set.`);
     }
-    await workaround(element);
-    return element.elementClick(element.elementId);
-  }
-}
-async function actionClick(element, options) {
-  const defaultOptions = {
-    button: 0,
-    x: 0,
-    y: 0,
-    skipRelease: false,
-    duration: 0
-  };
-  const { button, x, y, skipRelease, duration } = { ...defaultOptions, ...options };
-  if (typeof x !== "number" || typeof y !== "number" || !Number.isInteger(x) || !Number.isInteger(y)) {
-    throw new TypeError("Coordinates must be integers");
-  }
-  if (!buttonValue.includes(button)) {
-    throw new Error("Button type not supported.");
-  }
-  const browser = getBrowserObject12(element);
-  if (x || y) {
-    const { width, height } = await browser.getElementRect(element.elementId);
-    if (x && x < -Math.floor(width / 2) || x && x > Math.floor(width / 2)) {
-      log18.warn("x would cause a out of bounds error as it goes outside of element");
+    if (x !== void 0 && y !== void 0 && Object.keys(otherArgs).length > 0) {
+      throw new TypeError(`If x and y are provided, no other arguments are allowed. Found: ${Object.keys(otherArgs).join(", ")}`);
     }
-    if (y && y < -Math.floor(height / 2) || y && y > Math.floor(height / 2)) {
-      log18.warn("y would cause a out of bounds error as it goes outside of element");
+    const invalidCoordinates = [];
+    if (x !== void 0 && x < 0) {
+      invalidCoordinates.push("x");
+    }
+    if (y !== void 0 && y < 0) {
+      invalidCoordinates.push("y");
+    }
+    if (invalidCoordinates.length > 0) {
+      throw new TypeError(`The ${invalidCoordinates.join(" and ")} value${invalidCoordinates.length > 1 ? "s" : ""} must be positive.`);
     }
   }
-  const clickNested = async () => {
-    await browser.action("pointer", {
-      parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
-    }).move({ origin: element, x, y }).down({ button }).pause(duration).up({ button }).perform(skipRelease);
-  };
-  try {
-    return await clickNested();
-  } catch {
-    await workaround(element);
-    return clickNested();
-  }
-}
-
-// src/commands/element/custom$$.ts
-import { ELEMENT_KEY as ELEMENT_KEY9 } from "webdriver";
-import { getBrowserObject as getBrowserObject13 } from "@wdio/utils";
-async function custom$$2(strategyName, ...strategyArguments) {
-  const browserObject = getBrowserObject13(this);
-  const strategy = browserObject.strategies.get(strategyName);
-  if (!strategy) {
-    throw Error("No strategy found for " + strategyName);
-  }
-  if (!this.elementId) {
-    throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
-  }
-  const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
-  let res = await browserObject.execute(strategy, ...strategyArguments, this);
-  if (!Array.isArray(res)) {
-    res = [res];
-  }
-  res = res.filter((el) => !!el && typeof el[ELEMENT_KEY9] === "string");
-  const elements = res.length ? await getElements.call(this, strategyRef, res) : [];
-  return enhanceElementsArray(elements, this, strategyName, "custom$$", strategyArguments);
 }
-
-// src/commands/element/custom$.ts
-import { ELEMENT_KEY as ELEMENT_KEY10 } from "webdriver";
-import { getBrowserObject as getBrowserObject14 } from "@wdio/utils";
-async function custom$2(strategyName, ...strategyArguments) {
-  const browserObject = getBrowserObject14(this);
-  const strategy = browserObject.strategies.get(strategyName);
-  if (!strategy) {
-    throw Error("No strategy found for " + strategyName);
-  }
-  if (!this.elementId) {
-    throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
-  }
-  const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
-  let res = await browserObject.execute(strategy, ...strategyArguments, this);
-  if (Array.isArray(res)) {
-    res = res[0];
+async function elementTap(browser, element, options) {
+  if (browser.isNativeContext) {
+    return await nativeTap(element, browser, options);
   }
-  if (res && typeof res[ELEMENT_KEY10] === "string") {
-    return await getElement.call(this, strategyRef, res);
+  if (options) {
+    log18.warn("The options object is not supported in Web environments and will be ignored.");
   }
-  return await getElement.call(this, strategyRef, new Error("no such element"));
+  return await webTap(element);
 }
-
-// src/commands/element/doubleClick.ts
-import { getBrowserObject as getBrowserObject15 } from "@wdio/utils";
-async function doubleClick() {
-  const browser = getBrowserObject15(this);
-  return browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this }).down().up().pause(10).down().up().perform();
+async function webTap(element) {
+  return element.click();
 }
-
-// src/commands/element/dragAndDrop.ts
-import { ELEMENT_KEY as ELEMENT_KEY11 } from "webdriver";
-import { getBrowserObject as getBrowserObject16 } from "@wdio/utils";
-async function dragAndDrop(target, options = {}) {
-  const moveToCoordinates = target;
-  const moveToElement = target;
-  if (
-    /**
-     * no target was specified
-     */
-    !target || /**
-     * target is not from type element
-     */
-    target.constructor.name !== "Element" && /**
-     * and is also not an object with x and y number parameters
-     */
-    (typeof moveToCoordinates.x !== "number" || typeof moveToCoordinates.y !== "number")
-  ) {
-    throw new Error('command dragAndDrop requires an WebdriverIO Element or and object with "x" and "y" variables as first parameter');
-  }
-  const ACTION_BUTTON = 0;
-  const browser = getBrowserObject16(this);
-  const defaultOptions = { duration: browser.isMobile ? 250 : 10 };
-  const { duration } = { ...defaultOptions, ...options };
-  const isMovingToElement = target.constructor.name === "Element";
-  const sourceRef = { [ELEMENT_KEY11]: this[ELEMENT_KEY11] };
-  const targetRef = { [ELEMENT_KEY11]: moveToElement[ELEMENT_KEY11] };
-  const origin = sourceRef;
-  const targetOrigin = isMovingToElement ? targetRef : "pointer";
-  const targetX = isMovingToElement ? 0 : moveToCoordinates.x;
-  const targetY = isMovingToElement ? 0 : moveToCoordinates.y;
-  return browser.action("pointer", {
-    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
-  }).move({ duration: 0, origin, x: 0, y: 0 }).down({ button: ACTION_BUTTON }).pause(10).move({ duration, origin: targetOrigin, x: targetX, y: targetY }).up({ button: ACTION_BUTTON }).perform();
+async function executeNativeTap(browser, options) {
+  return await browser.execute(
+    `mobile: ${browser.isIOS ? "tap" : "clickGesture"}`,
+    { ...browser.isIOS ? { x: 0, y: 0 } : {}, ...options }
+  );
 }
+async function nativeTap(element, browser, options = {}) {
+  try {
+    if (!element.elementId) {
+      throw new Error("no such element");
+    }
+    return await executeNativeTap(browser, { elementId: element.elementId });
+  } catch (error) {
+    let err = error;
+    if (typeof error === "string") {
+      err = new Error(error);
+    }
+    if (!err.message.includes("no such element")) {
+      throw err;
+    }
+    const scrollIntoViewOptions = Object.fromEntries(
+      Object.entries({
+        direction: options?.direction,
+        maxScrolls: options?.maxScrolls,
+        scrollableElement: options?.scrollableElement
+      }).filter(([_, value]) => value !== void 0)
+    );
+    try {
+      await element.scrollIntoView(scrollIntoViewOptions);
+      return await executeNativeTap(browser, { elementId: element.elementId });
+    } catch (scrollError) {
+      let err2 = scrollError;
+      if (typeof scrollError === "string") {
+        err2 = new Error(scrollError);
+      }
+      if (err2.message.includes("Element not found within scroll limit of")) {
+        throw new Error(`Element not found within the automatic 'tap' scroll limit of ${scrollIntoViewOptions?.maxScrolls || "10"} scrolls by scrolling "${scrollIntoViewOptions?.direction || "down"}". The 'tap' methods will automatically scroll if it can't find the element. It might be that 'direction|maxScrolls|scrollableElement' are not correct. You can change change them like this:
 
-// src/commands/element/execute.ts
-import { getBrowserObject as getBrowserObject17 } from "@wdio/utils";
-async function execute2(script, ...args) {
-  const browser = getBrowserObject17(this);
-  return browser.execute(script, this, ...args);
-}
+await elem.tap({
+    direction: 'left' // possible options are: 'up|down|left|right'
+    maxScrolls: 15,
+    scrollableElement: $('#scrollable'),
+});
 
-// src/commands/element/executeAsync.ts
-import { getBrowserObject as getBrowserObject18 } from "@wdio/utils";
-async function executeAsync2(script, ...args) {
-  const browser = getBrowserObject18(this);
-  return browser.executeAsync(script, this, ...args);
-}
+                `);
+      } else if (err2.message.includes("Default scrollable element")) {
+        const match = err2.message.match(/Default scrollable element '(.*?)' was not found/);
+        const scrollableElement = match?.[1] || "unknown-scrollable-element";
+        throw new Error(`The 'tap' method tried to automatically scroll to the element but couldn't find the default scrollable element. '${scrollableElement}' If needed you can provide a custom scrollable element, together with the 'direction' and the 'maxScrolls' like this:
 
-// src/commands/element/getAttribute.ts
-function getAttribute(attributeName) {
-  return this.getElementAttribute(this.elementId, attributeName);
-}
+await elem.tap({
+    scrollableElement: $('#scrollable'),
+});
 
-// src/commands/element/getCSSProperty.ts
-import cssShorthandProps from "css-shorthand-properties";
-import { getBrowserObject as getBrowserObject19 } from "@wdio/utils";
-async function getCSSProperty(cssProperty, pseudoElement) {
-  const getCSSProperty2 = cssShorthandProps.isShorthand(cssProperty) ? getShorthandPropertyCSSValue : getPropertyCSSValue;
-  const cssValue2 = await getCSSProperty2.call(
-    this,
-    {
-      cssProperty,
-      pseudoElement
+                `);
+      }
+      throw err2;
     }
-  );
-  return parseCSS(cssValue2, cssProperty);
-}
-async function getShorthandPropertyCSSValue(options) {
-  const { pseudoElement, cssProperty } = options;
-  const properties = getShorthandProperties(cssProperty);
-  if (pseudoElement) {
-    const cssValues2 = await Promise.all(
-      properties.map((prop) => getPseudoElementCSSValue(
-        this,
-        {
-          pseudoElement,
-          cssProperty: prop
-        }
-      ))
-    );
-    return mergeEqualSymmetricalValue(cssValues2);
   }
-  const cssValues = await Promise.all(
-    properties.map((prop) => this.getElementCSSValue(this.elementId, prop))
-  );
-  return mergeEqualSymmetricalValue(cssValues);
 }
-async function getPropertyCSSValue(options) {
-  const { pseudoElement, cssProperty } = options;
-  if (pseudoElement) {
-    return await getPseudoElementCSSValue(
-      this,
-      {
-        pseudoElement,
-        cssProperty
-      }
-    );
+async function screenTap(browser, options) {
+  const { x, y } = options;
+  if (browser.isNativeContext) {
+    return await executeNativeTap(browser, options);
   }
-  return await this.getElementCSSValue(this.elementId, cssProperty);
-}
-function getShorthandProperties(cssProperty) {
-  return cssShorthandProps.expand(cssProperty);
-}
-function mergeEqualSymmetricalValue(cssValues) {
-  let newCssValues = [...cssValues];
-  while (newCssValues.length % 2 === 0) {
-    const mergedValues = [
-      newCssValues.slice(0, newCssValues.length / 2).join(" "),
-      newCssValues.slice(newCssValues.length / 2).join(" ")
-    ];
-    const hasEqualProperties = mergedValues.every((v) => v === mergedValues[0]);
-    if (!hasEqualProperties) {
-      break;
+  return await browser.action(
+    "pointer",
+    {
+      parameters: { pointerType: "touch" }
     }
-    newCssValues = newCssValues.slice(0, newCssValues.length / 2);
-  }
-  return newCssValues.join(" ");
-}
-async function getPseudoElementCSSValue(elem, options) {
-  const browser = getBrowserObject19(elem);
-  const { cssProperty, pseudoElement } = options;
-  const cssValue2 = await browser.execute(
-    (elem2, pseudoElement2, cssProperty2) => window.getComputedStyle(elem2, pseudoElement2)[cssProperty2],
-    elem,
-    pseudoElement,
-    cssProperty
-  );
-  return cssValue2;
+  ).move({ x, y }).down({ button: 0 }).pause(10).up({ button: 0 }).perform();
 }
 
-// src/commands/element/getComputedRole.ts
-function getComputedRole() {
-  return this.getElementComputedRole(this.elementId);
-}
+// src/commands/element.ts
+var element_exports = {};
+__export(element_exports, {
+  $: () => $2,
+  $$: () => $$2,
+  addValue: () => addValue,
+  clearValue: () => clearValue,
+  click: () => click,
+  custom$: () => custom$2,
+  custom$$: () => custom$$2,
+  doubleClick: () => doubleClick,
+  dragAndDrop: () => dragAndDrop,
+  execute: () => execute2,
+  executeAsync: () => executeAsync2,
+  getAttribute: () => getAttribute,
+  getCSSProperty: () => getCSSProperty,
+  getComputedLabel: () => getComputedLabel,
+  getComputedRole: () => getComputedRole,
+  getElement: () => getElement2,
+  getHTML: () => getHTML,
+  getLocation: () => getLocation,
+  getProperty: () => getProperty,
+  getSize: () => getSize,
+  getTagName: () => getTagName,
+  getText: () => getText,
+  getValue: () => getValue,
+  isClickable: () => isClickable,
+  isDisplayed: () => isDisplayed,
+  isEnabled: () => isEnabled,
+  isEqual: () => isEqual,
+  isExisting: () => isExisting,
+  isFocused: () => isFocused,
+  isSelected: () => isSelected,
+  isStable: () => isStable,
+  longPress: () => longPress,
+  moveTo: () => moveTo,
+  nextElement: () => nextElement,
+  parentElement: () => parentElement,
+  pinch: () => pinch,
+  previousElement: () => previousElement,
+  react$: () => react$2,
+  react$$: () => react$$2,
+  saveScreenshot: () => saveScreenshot2,
+  scrollIntoView: () => scrollIntoView,
+  selectByAttribute: () => selectByAttribute,
+  selectByIndex: () => selectByIndex,
+  selectByVisibleText: () => selectByVisibleText,
+  setValue: () => setValue,
+  shadow$: () => shadow$,
+  shadow$$: () => shadow$$,
+  tap: () => tap,
+  touchAction: () => touchAction3,
+  waitForClickable: () => waitForClickable,
+  waitForDisplayed: () => waitForDisplayed,
+  waitForEnabled: () => waitForEnabled,
+  waitForExist: () => waitForExist,
+  waitForStable: () => waitForStable,
+  waitUntil: () => waitUntil2,
+  zoom: () => zoom
+});
 
-// src/commands/element/getComputedLabel.ts
-function getComputedLabel() {
-  return this.getElementComputedLabel(this.elementId);
-}
+// src/commands/element/$$.ts
+var $$2 = $$;
 
-// src/commands/element/getElement.ts
-async function getElement2() {
-  return this;
+// src/commands/element/$.ts
+var $2 = $;
+
+// src/commands/element/addValue.ts
+var VALID_TYPES = ["string", "number"];
+function addValue(value) {
+  if (!VALID_TYPES.includes(typeof value)) {
+    throw new Error(
+      'The setValue/addValue command only take string or number values. If you like to use special characters, use the "keys" command.'
+    );
+  }
+  return this.elementSendKeys(this.elementId, value.toString());
 }
 
-// src/commands/element/getHTML.ts
-import { ELEMENT_KEY as ELEMENT_KEY12 } from "webdriver";
-import { prettify as prettifyFn } from "htmlfy";
-import { getBrowserObject as getBrowserObject20 } from "@wdio/utils";
+// src/commands/element/clearValue.ts
+function clearValue() {
+  return this.elementClear(this.elementId);
+}
 
-// src/shadowRoot.ts
+// src/commands/element/click.ts
 import logger19 from "@wdio/logger";
-import customElementWrapper from "./scripts/customElement.js";
-var shadowRootManager = /* @__PURE__ */ new Map();
-var log19 = logger19("webdriverio:ShadowRootManager");
-function getShadowRootManager(browser) {
-  const existingShadowRootManager = shadowRootManager.get(browser);
-  if (existingShadowRootManager) {
-    return existingShadowRootManager;
-  }
-  const newContext = new ShadowRootManager(browser);
-  shadowRootManager.set(browser, newContext);
-  return newContext;
-}
-var ShadowRootManager = class {
-  #browser;
-  #initialize;
-  #shadowRoots = /* @__PURE__ */ new Map();
-  #documentElement;
-  #frameDepth = 0;
-  constructor(browser) {
-    this.#browser = browser;
-    if (!browser.isBidi || process.env.WDIO_UNIT_TESTS || browser.options?.automationProtocol !== "webdriver") {
-      this.#initialize = Promise.resolve(true);
-      return;
-    }
-    this.#initialize = this.#browser.sessionSubscribe({
-      events: ["log.entryAdded", "browsingContext.navigationStarted"]
-    }).then(() => true, () => false);
-    this.#browser.on("log.entryAdded", this.handleLogEntry.bind(this));
-    this.#browser.on("result", this.#commandResultHandler.bind(this));
-    this.#browser.on("bidiCommand", this.#handleBidiCommand.bind(this));
-    browser.scriptAddPreloadScript({
-      functionDeclaration: customElementWrapper.toString()
-    });
-  }
-  async initialize() {
-    return this.#initialize;
-  }
-  /**
-   * keep track of navigation events and remove shadow roots when they are no longer needed
-   */
-  #handleBidiCommand(command) {
-    if (command.method !== "browsingContext.navigate") {
-      return;
+import { getBrowserObject as getBrowserObject12 } from "@wdio/utils";
+var log19 = logger19("webdriver");
+function click(options) {
+  if (typeof options !== "undefined") {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new TypeError("Options must be an object");
     }
-    const params = command.params;
-    this.#shadowRoots.delete(params.context);
+    return actionClick(this, options);
   }
-  /**
-   * keep track of frame depth
-   */
-  #commandResultHandler(result) {
-    const noResultError = typeof result.result === "object" && result.result && "error" in result.result && !result.result.error;
-    if (result.command === "switchToFrame" && noResultError) {
-      this.#frameDepth++;
+  return elementClick(this);
+}
+async function workaround(element) {
+  await element.scrollIntoView({ block: "center", inline: "center" });
+}
+async function elementClick(element) {
+  try {
+    return await element.elementClick(element.elementId);
+  } catch (error) {
+    let err = error;
+    if (typeof error === "string") {
+      err = new Error(error);
     }
-    if (result.command === "switchToParentFrame" && noResultError) {
-      this.#frameDepth = Math.max(0, this.#frameDepth - 1);
+    if (!err.message.includes("element click intercepted")) {
+      throw err;
     }
+    await workaround(element);
+    return element.elementClick(element.elementId);
   }
-  /**
-   * check if we are within a frame
-   * @returns {boolean} true if we are within a frame
-   */
-  isWithinFrame() {
-    return this.#frameDepth > 0;
+}
+async function actionClick(element, options) {
+  const defaultOptions = {
+    button: 0,
+    x: 0,
+    y: 0,
+    skipRelease: false,
+    duration: 0
+  };
+  const { button, x, y, skipRelease, duration } = { ...defaultOptions, ...options };
+  if (typeof x !== "number" || typeof y !== "number" || !Number.isInteger(x) || !Number.isInteger(y)) {
+    throw new TypeError("Coordinates must be integers");
   }
-  /**
-   * capture shadow root elements propagated through console.debug
-   */
-  handleLogEntry(logEntry) {
-    const args = "args" in logEntry && logEntry.level === "debug" ? logEntry.args : void 0;
-    if (!args || args[0].type !== "string" || args[0].value !== "[WDIO]" || args[1].type !== "string") {
-      return;
-    }
-    if (!logEntry.source.context) {
-      return;
-    }
-    const eventType = args[1].value;
-    if (eventType === "newShadowRoot" && args[2].type === "node" && args[3].type === "node") {
-      const [
-        /* [WDIO] */
-        ,
-        /* newShadowRoot */
-        ,
-        shadowElem,
-        rootElem,
-        isDocument,
-        documentElement
-      ] = args;
-      if (!this.#shadowRoots.has(logEntry.source.context)) {
-        if (!rootElem.sharedId) {
-          throw new Error(`Expected "sharedId" parameter from object ${rootElem}`);
-        }
-        this.#shadowRoots.set(logEntry.source.context, new ShadowRootTree(rootElem.sharedId));
-      } else if (isDocument.type === "boolean" && isDocument.value) {
-        if (!rootElem.sharedId) {
-          throw new Error(`Expected "sharedId" parameter from object ${rootElem}`);
-        }
-        const tree2 = this.#shadowRoots.get(logEntry.source.context);
-        if (tree2?.element !== rootElem.sharedId) {
-          this.#shadowRoots.set(logEntry.source.context, new ShadowRootTree(rootElem.sharedId));
-        }
-      }
-      this.#documentElement = documentElement;
-      const tree = this.#shadowRoots.get(logEntry.source.context);
-      if (!tree) {
-        throw new Error(`Couldn't find tree for context id ${logEntry.source.context}`);
-      }
-      if (
-        // we expect an element id
-        !shadowElem.sharedId || // we expect the element to have a shadow root
-        !shadowElem.value?.shadowRoot?.sharedId || // we expect the shadow root to have a proper type
-        shadowElem.value.shadowRoot.value?.nodeType !== 11
-      ) {
-        return log19.warn(`Expected element with shadow root but found <${shadowElem.value?.localName} />`);
-      }
-      log19.info(`Registered new shadow root for element <${shadowElem.value.localName} /> with id ${shadowElem.value.shadowRoot.sharedId}`);
-      const newTree = new ShadowRootTree(
-        shadowElem.sharedId,
-        shadowElem.value.shadowRoot.sharedId,
-        shadowElem.value.shadowRoot.value.mode
-      );
-      if (rootElem.sharedId) {
-        tree.addShadowElement(rootElem.sharedId, newTree);
-      } else {
-        tree.addShadowElement(newTree);
-      }
-      return;
-    }
-    if (eventType === "removeShadowRoot" && args[2].type === "node" && args[2].sharedId) {
-      const tree = this.#shadowRoots.get(logEntry.source.context);
-      if (!tree) {
-        return;
-      }
-      return tree.remove(args[2].sharedId);
-    }
-    throw new Error(`Invalid parameters for "${eventType}" event: ${args.join(", ")}`);
+  if (!buttonValue.includes(button)) {
+    throw new Error("Button type not supported.");
   }
-  getShadowElementsByContextId(contextId, scope) {
-    let tree = this.#shadowRoots.get(contextId);
-    if (!tree) {
-      return [];
+  const browser = getBrowserObject12(element);
+  if (x || y) {
+    const { width, height } = await browser.getElementRect(element.elementId);
+    if (x && x < -Math.floor(width / 2) || x && x > Math.floor(width / 2)) {
+      log19.warn("x would cause a out of bounds error as it goes outside of element");
     }
-    let documentElement;
-    if (scope) {
-      const subTree = tree.find(scope);
-      if (subTree) {
-        tree = subTree;
-      }
-    } else {
-      documentElement = this.#documentElement?.sharedId;
+    if (y && y < -Math.floor(height / 2) || y && y > Math.floor(height / 2)) {
+      log19.warn("y would cause a out of bounds error as it goes outside of element");
     }
-    const elements = tree.getAllLookupScopes();
-    return [
-      ...documentElement ? [documentElement] : [],
-      ...new Set(elements).values()
-    ];
   }
-  getShadowElementPairsByContextId(contextId, scope) {
-    let tree = this.#shadowRoots.get(contextId);
-    if (!tree) {
-      return [];
-    }
-    if (scope) {
-      const subTree = tree.find(scope);
-      if (subTree) {
-        tree = subTree;
-      }
-    }
-    return tree.flat().map((tree2) => [tree2.element, tree2.shadowRoot]);
+  const clickNested = async () => {
+    await browser.action("pointer", {
+      parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+    }).move({ origin: element, x, y }).down({ button }).pause(duration).up({ button }).perform(skipRelease);
+  };
+  try {
+    return await clickNested();
+  } catch {
+    await workaround(element);
+    return clickNested();
   }
-  getShadowRootModeById(contextId, element) {
-    const tree = this.#shadowRoots.get(contextId);
-    if (!tree) {
-      return;
-    }
-    const shadowTree = tree.find(element);
-    if (!shadowTree) {
-      return;
-    }
-    return shadowTree.mode;
+}
+
+// src/commands/element/custom$$.ts
+import { ELEMENT_KEY as ELEMENT_KEY9 } from "webdriver";
+import { getBrowserObject as getBrowserObject13 } from "@wdio/utils";
+async function custom$$2(strategyName, ...strategyArguments) {
+  const browserObject = getBrowserObject13(this);
+  const strategy = browserObject.strategies.get(strategyName);
+  if (!strategy) {
+    throw Error("No strategy found for " + strategyName);
   }
-  deleteShadowRoot(element, contextId) {
-    const tree = this.#shadowRoots.get(contextId);
-    if (!tree) {
-      return;
-    }
-    return tree.remove(element);
+  if (!this.elementId) {
+    throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
   }
-};
-var ShadowRootTree = class _ShadowRootTree {
-  element;
-  shadowRoot;
-  mode;
-  children = /* @__PURE__ */ new Set();
-  constructor(element, shadowRoot, mode) {
-    this.element = element;
-    this.shadowRoot = shadowRoot;
-    this.mode = mode;
+  const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
+  let res = await browserObject.execute(strategy, ...strategyArguments, this);
+  if (!Array.isArray(res)) {
+    res = [res];
   }
-  addShadowElement(...args) {
-    const [scope, treeArg] = args;
-    if (!scope && !treeArg) {
-      throw new Error('Method "addShadowElement" expects at least 2 arguments');
-    }
-    if (scope instanceof _ShadowRootTree) {
-      this.children.add(scope);
-      return;
-    }
-    if (typeof scope === "string" && treeArg instanceof _ShadowRootTree) {
-      const tree = this.find(scope) || this.findByShadowId(scope);
-      if (!tree) {
-        throw new Error(`Couldn't find element with id ${scope}`);
-      }
-      tree.addShadowElement(treeArg);
-      return;
-    }
-    throw new Error('Invalid arguments for "addShadowElement" method');
+  res = res.filter((el) => !!el && typeof el[ELEMENT_KEY9] === "string");
+  const elements = res.length ? await getElements.call(this, strategyRef, res) : [];
+  return enhanceElementsArray(elements, this, strategyName, "custom$$", strategyArguments);
+}
+
+// src/commands/element/custom$.ts
+import { ELEMENT_KEY as ELEMENT_KEY10 } from "webdriver";
+import { getBrowserObject as getBrowserObject14 } from "@wdio/utils";
+async function custom$2(strategyName, ...strategyArguments) {
+  const browserObject = getBrowserObject14(this);
+  const strategy = browserObject.strategies.get(strategyName);
+  if (!strategy) {
+    throw Error("No strategy found for " + strategyName);
   }
-  find(element) {
-    if (this.element === element) {
-      return this;
-    }
-    for (const child of this.children) {
-      const elem = child.find(element);
-      if (elem) {
-        return elem;
-      }
-    }
-    return void 0;
+  if (!this.elementId) {
+    throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
+  }
+  const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
+  let res = await browserObject.execute(strategy, ...strategyArguments, this);
+  if (Array.isArray(res)) {
+    res = res[0];
+  }
+  if (res && typeof res[ELEMENT_KEY10] === "string") {
+    return await getElement.call(this, strategyRef, res);
+  }
+  return await getElement.call(this, strategyRef, new Error("no such element"));
+}
+
+// src/commands/element/doubleClick.ts
+import { getBrowserObject as getBrowserObject15 } from "@wdio/utils";
+async function doubleClick() {
+  const browser = getBrowserObject15(this);
+  return browser.action("pointer", { parameters: { pointerType: "mouse" } }).move({ origin: this }).down().up().pause(10).down().up().perform();
+}
+
+// src/commands/element/dragAndDrop.ts
+import { ELEMENT_KEY as ELEMENT_KEY11 } from "webdriver";
+import { getBrowserObject as getBrowserObject16 } from "@wdio/utils";
+async function dragAndDrop(target, options = {}) {
+  const moveToCoordinates = target;
+  const moveToElement = target;
+  if (
+    /**
+     * no target was specified
+     */
+    !target || /**
+     * target is not from type element
+     */
+    target.constructor.name !== "Element" && /**
+     * and is also not an object with x and y number parameters
+     */
+    (typeof moveToCoordinates.x !== "number" || typeof moveToCoordinates.y !== "number")
+  ) {
+    throw new Error('command dragAndDrop requires an WebdriverIO Element or and object with "x" and "y" variables as first parameter');
   }
-  findByShadowId(shadowRoot) {
-    if (this.shadowRoot === shadowRoot) {
-      return this;
-    }
-    for (const child of this.children) {
-      const elem = child.findByShadowId(shadowRoot);
-      if (elem) {
-        return elem;
-      }
+  const ACTION_BUTTON = 0;
+  const browser = getBrowserObject16(this);
+  const defaultOptions = { duration: browser.isMobile ? 250 : 10 };
+  const { duration } = { ...defaultOptions, ...options };
+  const isMovingToElement = target.constructor.name === "Element";
+  const sourceRef = { [ELEMENT_KEY11]: this[ELEMENT_KEY11] };
+  const targetRef = { [ELEMENT_KEY11]: moveToElement[ELEMENT_KEY11] };
+  const origin = sourceRef;
+  const targetOrigin = isMovingToElement ? targetRef : "pointer";
+  const targetX = isMovingToElement ? 0 : moveToCoordinates.x;
+  const targetY = isMovingToElement ? 0 : moveToCoordinates.y;
+  return browser.action("pointer", {
+    parameters: { pointerType: browser.isMobile ? "touch" : "mouse" }
+  }).move({ duration: 0, origin, x: 0, y: 0 }).down({ button: ACTION_BUTTON }).pause(10).move({ duration, origin: targetOrigin, x: targetX, y: targetY }).up({ button: ACTION_BUTTON }).perform();
+}
+
+// src/commands/element/execute.ts
+import { getBrowserObject as getBrowserObject17 } from "@wdio/utils";
+async function execute2(script, ...args) {
+  const browser = getBrowserObject17(this);
+  return browser.execute(script, this, ...args);
+}
+
+// src/commands/element/executeAsync.ts
+import { getBrowserObject as getBrowserObject18 } from "@wdio/utils";
+async function executeAsync2(script, ...args) {
+  const browser = getBrowserObject18(this);
+  return browser.executeAsync(script, this, ...args);
+}
+
+// src/commands/element/getAttribute.ts
+function getAttribute(attributeName) {
+  return this.getElementAttribute(this.elementId, attributeName);
+}
+
+// src/commands/element/getCSSProperty.ts
+import cssShorthandProps from "css-shorthand-properties";
+import { getBrowserObject as getBrowserObject19 } from "@wdio/utils";
+async function getCSSProperty(cssProperty, pseudoElement) {
+  const getCSSProperty2 = cssShorthandProps.isShorthand(cssProperty) ? getShorthandPropertyCSSValue : getPropertyCSSValue;
+  const cssValue2 = await getCSSProperty2.call(
+    this,
+    {
+      cssProperty,
+      pseudoElement
     }
-    return void 0;
-  }
-  getAllLookupScopes() {
-    return [
-      this.shadowRoot ?? this.element,
-      ...Array.from(this.children).map((tree) => tree.getAllLookupScopes())
-    ].flat();
-  }
-  flat() {
-    return [this, ...Array.from(this.children).map((tree) => tree.flat())].flat();
+  );
+  return parseCSS(cssValue2, cssProperty);
+}
+async function getShorthandPropertyCSSValue(options) {
+  const { pseudoElement, cssProperty } = options;
+  const properties = getShorthandProperties(cssProperty);
+  if (pseudoElement) {
+    const cssValues2 = await Promise.all(
+      properties.map((prop) => getPseudoElementCSSValue(
+        this,
+        {
+          pseudoElement,
+          cssProperty: prop
+        }
+      ))
+    );
+    return mergeEqualSymmetricalValue(cssValues2);
   }
-  remove(element) {
-    const childArray = Array.from(this.children);
-    for (let i = childArray.length - 1; i >= 0; i--) {
-      if (childArray[i].element === element) {
-        return this.children.delete(childArray[i]);
-      }
-      const wasFound = childArray[i].remove(element);
-      if (wasFound) {
-        return true;
+  const cssValues = await Promise.all(
+    properties.map((prop) => this.getElementCSSValue(this.elementId, prop))
+  );
+  return mergeEqualSymmetricalValue(cssValues);
+}
+async function getPropertyCSSValue(options) {
+  const { pseudoElement, cssProperty } = options;
+  if (pseudoElement) {
+    return await getPseudoElementCSSValue(
+      this,
+      {
+        pseudoElement,
+        cssProperty
       }
+    );
+  }
+  return await this.getElementCSSValue(this.elementId, cssProperty);
+}
+function getShorthandProperties(cssProperty) {
+  return cssShorthandProps.expand(cssProperty);
+}
+function mergeEqualSymmetricalValue(cssValues) {
+  let newCssValues = [...cssValues];
+  while (newCssValues.length % 2 === 0) {
+    const mergedValues = [
+      newCssValues.slice(0, newCssValues.length / 2).join(" "),
+      newCssValues.slice(newCssValues.length / 2).join(" ")
+    ];
+    const hasEqualProperties = mergedValues.every((v) => v === mergedValues[0]);
+    if (!hasEqualProperties) {
+      break;
     }
-    return false;
+    newCssValues = newCssValues.slice(0, newCssValues.length / 2);
   }
-};
+  return newCssValues.join(" ");
+}
+async function getPseudoElementCSSValue(elem, options) {
+  const browser = getBrowserObject19(elem);
+  const { cssProperty, pseudoElement } = options;
+  const cssValue2 = await browser.execute(
+    (elem2, pseudoElement2, cssProperty2) => window.getComputedStyle(elem2, pseudoElement2)[cssProperty2],
+    elem,
+    pseudoElement,
+    cssProperty
+  );
+  return cssValue2;
+}
+
+// src/commands/element/getComputedRole.ts
+function getComputedRole() {
+  return this.getElementComputedRole(this.elementId);
+}
+
+// src/commands/element/getComputedLabel.ts
+function getComputedLabel() {
+  return this.getElementComputedLabel(this.elementId);
+}
+
+// src/commands/element/getElement.ts
+async function getElement2() {
+  return this;
+}
 
 // src/commands/element/getHTML.ts
+import { ELEMENT_KEY as ELEMENT_KEY12 } from "webdriver";
+import { prettify as prettifyFn } from "htmlfy";
+import { getBrowserObject as getBrowserObject20 } from "@wdio/utils";
 import getHTMLScript from "./scripts/getHTML.js";
 import getHTMLShadowScript from "./scripts/getHTMLShadow.js";
 var SHADOW_ID_ATTR_NAME = "data-wdio-shadow-id";
@@ -5886,10 +6053,10 @@ async function getHTML(options = {}) {
       );
     }
     const { load } = await import("cheerio");
-    const shadowRootManager2 = getShadowRootManager(browser);
-    const contextManager2 = getContextManager(browser);
-    const context = await contextManager2.getCurrentContext();
-    const shadowRootElementPairs = shadowRootManager2.getShadowElementPairsByContextId(context, this.elementId);
+    const shadowRootManager = getShadowRootManager(browser);
+    const contextManager = getContextManager(browser);
+    const context = await contextManager.getCurrentContext();
+    const shadowRootElementPairs = shadowRootManager.getShadowElementPairsByContextId(context, this.elementId);
     const elementsWithShadowRootAndIdVerified = (await Promise.all(
       shadowRootElementPairs.map(([elemId, elem]) => browser.execute((elem2) => elem2.tagName, { [ELEMENT_KEY12]: elemId }).then(
         () => [elemId, elem],
@@ -5910,7 +6077,7 @@ async function getHTML(options = {}) {
     populateHTML($3, shadowElementHTML.map(({ id, ...props }) => ({
       ...props,
       id,
-      mode: shadowRootManager2.getShadowRootModeById(context, id) || "open"
+      mode: shadowRootManager.getShadowRootModeById(context, id) || "open"
     })));
     return sanitizeHTML($3, { removeCommentNodes, prettify, excludeElements });
   }
@@ -7313,10 +7480,10 @@ function transformClassicToBidiSelector(using, value) {
 }
 async function findDeepElement(selector) {
   const browser = getBrowserObject35(this);
-  const shadowRootManager2 = getShadowRootManager(browser);
-  const contextManager2 = getContextManager(browser);
-  const context = await contextManager2.getCurrentContext();
-  const shadowRoots = shadowRootManager2.getShadowElementsByContextId(
+  const shadowRootManager = getShadowRootManager(browser);
+  const contextManager = getContextManager(browser);
+  const context = await contextManager.getCurrentContext();
+  const shadowRoots = shadowRootManager.getShadowElementsByContextId(
     context,
     this.elementId
   );
@@ -7351,10 +7518,10 @@ async function findDeepElement(selector) {
 }
 async function findDeepElements(selector) {
   const browser = getBrowserObject35(this);
-  const shadowRootManager2 = getShadowRootManager(browser);
-  const contextManager2 = getContextManager(browser);
-  const context = await contextManager2.getCurrentContext();
-  const shadowRoots = shadowRootManager2.getShadowElementsByContextId(
+  const shadowRootManager = getShadowRootManager(browser);
+  const contextManager = getContextManager(browser);
+  const context = await contextManager.getCurrentContext();
+  const shadowRoots = shadowRootManager.getShadowElementsByContextId(
     context,
     this.elementId
   );
@@ -7386,8 +7553,8 @@ async function findDeepElements(selector) {
 }
 async function findElement(selector) {
   const browserObject = getBrowserObject35(this);
-  const shadowRootManager2 = getShadowRootManager(browserObject);
-  if (this.isBidi && typeof selector === "string" && !selector.startsWith(DEEP_SELECTOR) && !shadowRootManager2.isWithinFrame()) {
+  const shadowRootManager = getShadowRootManager(browserObject);
+  if (this.isBidi && typeof selector === "string" && !selector.startsWith(DEEP_SELECTOR) && !shadowRootManager.isWithinFrame()) {
     return findDeepElement.call(this, selector);
   }
   if (typeof selector === "string" && selector.startsWith(DEEP_SELECTOR)) {
@@ -7945,103 +8112,6 @@ async function getProtocolDriver(options) {
   return { Driver, options };
 }
 
-// src/dialog.ts
-var dialogManager = /* @__PURE__ */ new Map();
-function getDialogManager(browser) {
-  const existingDialogManager = dialogManager.get(browser);
-  if (existingDialogManager) {
-    return existingDialogManager;
-  }
-  const newContext = new DialogManager(browser);
-  dialogManager.set(browser, newContext);
-  return newContext;
-}
-var DialogManager = class {
-  #browser;
-  #initialize;
-  #autoHandleDialog = true;
-  constructor(browser) {
-    this.#browser = browser;
-    if (!browser.isBidi || process.env.WDIO_UNIT_TESTS || browser.options?.automationProtocol !== "webdriver") {
-      this.#initialize = Promise.resolve(true);
-      return;
-    }
-    this.#initialize = this.#browser.sessionSubscribe({
-      events: ["browsingContext.userPromptOpened"]
-    }).then(() => true, () => false);
-    this.#browser.on("_dialogListenerRegistered", () => this.#switchListenerFlag(false));
-    this.#browser.on("_dialogListenerRemoved", () => this.#switchListenerFlag(true));
-    this.#browser.on("browsingContext.userPromptOpened", this.#handleUserPrompt.bind(this));
-  }
-  async initialize() {
-    return this.#initialize;
-  }
-  /**
-   * capture shadow root elements propagated through console.debug
-   */
-  async #handleUserPrompt(log25) {
-    if (this.#autoHandleDialog) {
-      return this.#browser.browsingContextHandleUserPrompt({
-        accept: false,
-        context: log25.context
-      });
-    }
-    const dialog = new Dialog(log25, this.#browser);
-    this.#browser.emit("dialog", dialog);
-  }
-  /**
-   * Is called when a new dialog listener is registered with the `dialog` name.
-   * In these cases we set a flag to the `#listener` map to indicate that we
-   * are listening to dialog events for this page in this context.
-   */
-  #switchListenerFlag(value) {
-    this.#autoHandleDialog = value;
-  }
-};
-var Dialog = class {
-  #browser;
-  #context;
-  #message;
-  #defaultValue;
-  #type;
-  constructor(event, browser) {
-    this.#message = event.message;
-    this.#defaultValue = event.defaultValue;
-    this.#type = event.type;
-    this.#context = event.context;
-    this.#browser = browser;
-  }
-  message() {
-    return this.#message;
-  }
-  defaultValue() {
-    return this.#defaultValue;
-  }
-  type() {
-    return this.#type;
-  }
-  /**
-   * Returns when the dialog has been accepted.
-   *
-   * @alias dialog.accept
-   * @param {string=} promptText  A text to enter into prompt. Does not cause any effects if the dialog's type is not prompt.
-   * @returns {Promise<void>}
-   */
-  async accept(userText) {
-    await this.#browser.browsingContextHandleUserPrompt({
-      accept: true,
-      context: this.#context,
-      userText
-    });
-  }
-  async dismiss() {
-    await this.#browser.browsingContextHandleUserPrompt({
-      accept: false,
-      context: this.#context
-    });
-  }
-};
-
 // src/index.ts
 var Key2 = Key;
 var SevereServiceError2 = SevereServiceError;
@@ -8067,13 +8137,7 @@ var remote = async function(params, remoteModifier) {
     instance.overwriteCommand = (name, fn, attachToElement) => origOverwriteCommand(name, fn, attachToElement);
   }
   instance.addLocatorStrategy = addLocatorStrategyHandler(instance);
-  await Promise.all([
-    getPolyfillManager(instance).initialize(),
-    getShadowRootManager(instance).initialize(),
-    getNetworkManager(instance).initialize(),
-    getDialogManager(instance).initialize(),
-    getContextManager(instance).initialize()
-  ]);
+  await registerSessionManager(instance);
   return instance;
 };
 var attach = async function(attachOptions) {
@@ -8093,13 +8157,7 @@ var attach = async function(attachOptions) {
     wrapCommand3
   );
   driver.addLocatorStrategy = addLocatorStrategyHandler(driver);
-  await driver._bidiHandler?.connect().then(() => Promise.all([
-    getPolyfillManager(driver).initialize(),
-    getShadowRootManager(driver).initialize(),
-    getNetworkManager(driver).initialize(),
-    getDialogManager(driver).initialize(),
-    getContextManager(driver).initialize()
-  ]));
+  await registerSessionManager(driver);
   return driver;
 };
 var multiremote = async function(params, { automationProtocol } = {}) {