codeceptjs 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/helper/WebDriver.js

@@ -1,48 +1,46 @@
-import assert from 'assert';
-import path from 'path';
-import Helper from '@codeceptjs/helper';
-import promiseRetry from 'promise-retry';
-import { includes as stringIncludes } from '../assert/include.js';
-import { urlEquals, equals } from '../assert/equal.js';
-import { debug } from '../output.js';
-import { empty } from '../assert/empty.js';
-import { truth } from '../assert/truth';
-
-import {
-  xpathLocator,
-  fileExists,
-  decodeUrl,
-  chunkArray,
-  convertCssPropertiesToCamelCase,
-  screenshotOutputFolder,
-  getNormalizedKeyAttributeValue,
-  modifierKeys,
-
-} from '../utils.js';
-
-import { isColorProperty, convertColorToRGBA } from '../colorUtils';
-import ElementNotFound from './errors/ElementNotFound.js';
-import ConnectionRefused from './errors/ConnectionRefused.js';
-import Locator from '../locator.js';
-import { highlightElement } from './scripts/highlightElement';
-import { focusElement } from './scripts/focusElement';
-import { blurElement } from './scripts/blurElement';
-
-import {
-  dontSeeElementError,
-  seeElementError,
-  seeElementInDOMError,
-  dontSeeElementInDOMError,
-} from './errors/ElementAssertion';
-
-import {
-  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
-} from './network/actions';
-
-let webdriverio;
-
-const SHADOW = 'shadow';
-const webRoot = 'body';
+let webdriverio
+
+import assert from 'assert'
+import path from 'path'
+import crypto from 'crypto'
+
+import Helper from '@codeceptjs/helper'
+import promiseRetry from 'promise-retry'
+import { includes as stringIncludes } from '../assert/include.js'
+import { urlEquals, equals } from '../assert/equal.js'
+import store from '../store.js'
+import output from '../output.js'
+const { debug } = output
+import { empty } from '../assert/empty.js'
+import { truth } from '../assert/truth.js'
+import { xpathLocator, fileExists, decodeUrl, chunkArray, convertCssPropertiesToCamelCase, screenshotOutputFolder, getNormalizedKeyAttributeValue, modifierKeys } from '../utils.js'
+import { isColorProperty, convertColorToRGBA } from '../colorUtils.js'
+import ElementNotFound from './errors/ElementNotFound.js'
+import ConnectionRefused from './errors/ConnectionRefused.js'
+import Locator from '../locator.js'
+import { highlightElement } from './scripts/highlightElement.js'
+import { focusElement } from './scripts/focusElement.js'
+import { blurElement } from './scripts/blurElement.js'
+import { dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError } from './errors/ElementAssertion.js'
+import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
+import WebElement from '../element/WebElement.js'
+
+const SHADOW = 'shadow'
+const webRoot = 'body'
+let browserLogs = []
+
+/**
+ * Wraps error objects that don't have a proper message property
+ * This is needed for ESM compatibility with WebdriverIO error handling
+ */
+function wrapError(e) {
+  if (e && typeof e === 'object' && !e.message) {
+    const err = new Error(e.error || e.timeoutMsg || String(e))
+    err.stack = e.stack
+    return err
+  }
+  return e
+}
 
 /**
  * ## Configuration
@@ -53,6 +51,7 @@ const webRoot = 'body';
  * @type {object}
  * @prop {string} url - base url of website to be tested.
  * @prop {string} browser - Browser in which to perform testing.
+ * @prop {boolean} [bidiProtocol=false] - WebDriver Bidi Protocol. Default: false. More info: https://webdriver.io/docs/api/webdriverBidi/
  * @prop {string} [basicAuth] - (optional) the basic authentication to pass to base url. Example: {username: 'username', password: 'password'}
  * @prop {string} [host=localhost] - WebDriver host to connect.
  * @prop {number} [port=4444] - WebDriver port to connect.
@@ -72,9 +71,8 @@ const webRoot = 'body';
  * @prop {object} [timeouts] [WebDriver timeouts](http://webdriver.io/docs/timeouts.html) defined as hash.
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
  * @prop {string} [logLevel=silent] - level of logging verbosity. Default: silent. Options: trace | debug | info | warn | error | silent. More info: https://webdriver.io/docs/configuration/#loglevel
- * @prop {boolean} [devtoolsProtocol=false] - enable devtools protocol. Default: false. More info: https://webdriver.io/docs/automationProtocols/#devtools-protocol.
  */
-const config = {};
+const config = {}
 
 /**
  * WebDriver helper which wraps [webdriverio](http://webdriver.io/) library to
@@ -180,7 +178,6 @@ const config = {};
  *      WebDriver : {
  *        url: "http://localhost",
  *        browser: "chrome",
- *        devtoolsProtocol: true,
  *        desiredCapabilities: {
  *          chromeOptions: {
  *            args: [ "--headless", "--disable-gpu", "--no-sandbox" ]
@@ -445,34 +442,34 @@ const config = {};
  */
 class WebDriver extends Helper {
   constructor(config) {
-    super(config);
-    webdriverio = require('webdriverio');
+    super(config)
+    // webdriverio will be loaded dynamically in _init method
 
     // set defaults
-    this.root = webRoot;
-    this.isWeb = true;
-    this.isRunning = false;
-    this.sessionWindows = {};
-    this.activeSessionName = '';
-    this.customLocatorStrategies = config.customLocatorStrategies;
+    this.root = webRoot
+    this.isWeb = true
+    this.isRunning = false
+    this.sessionWindows = {}
+    this.activeSessionName = ''
+    this.customLocatorStrategies = config.customLocatorStrategies
 
     // for network stuff
-    this.requests = [];
-    this.recording = false;
-    this.recordedAtLeastOnce = false;
+    this.requests = []
+    this.recording = false
+    this.recordedAtLeastOnce = false
 
-    this._setConfig(config);
+    this._setConfig(config)
 
     Locator.addFilter((locator, result) => {
       if (typeof locator === 'string' && locator.indexOf('~') === 0) {
         // accessibility locator
         if (this.isWeb) {
-          result.value = `[aria-label="${locator.slice(1)}"]`;
-          result.type = 'css';
-          result.output = `aria-label=${locator.slice(1)}`;
+          result.value = `[aria-label="${locator.slice(1)}"]`
+          result.type = 'css'
+          result.output = `aria-label=${locator.slice(1)}`
         }
       }
-    });
+    })
   }
 
   _validateConfig(config) {
@@ -492,41 +489,45 @@ class WebDriver extends Helper {
       keepBrowserState: false,
       deprecationWarnings: false,
       highlightElement: false,
-    };
+    }
 
     // override defaults with config
-    config = Object.assign(defaults, config);
+    config = Object.assign(defaults, config)
 
     if (config.host) {
       // webdriverio spec
-      config.hostname = config.host;
-      config.path = config.path ? config.path : '/wd/hub';
+      config.hostname = config.host
+      config.path = config.path ? config.path : '/wd/hub'
     }
 
-    config.baseUrl = config.url || config.baseUrl;
+    config.baseUrl = config.url || config.baseUrl
     if (config.desiredCapabilities && Object.keys(config.desiredCapabilities).length) {
-      config.capabilities = config.desiredCapabilities;
+      config.capabilities = config.desiredCapabilities
     }
-    config.capabilities.browserName = config.browser || config.capabilities.browserName;
-    config.capabilities.browserVersion = config.browserVersion || config.capabilities.browserVersion;
+    config.capabilities.browserName = config.browser || config.capabilities.browserName
+
+    // WebDriver Bidi Protocol. Default: true
+    config.capabilities.webSocketUrl = config.bidiProtocol ?? config.capabilities.webSocketUrl ?? true
+
+    config.capabilities.browserVersion = config.browserVersion || config.capabilities.browserVersion
     if (config.capabilities.chromeOptions) {
-      config.capabilities['goog:chromeOptions'] = config.capabilities.chromeOptions;
-      delete config.capabilities.chromeOptions;
+      config.capabilities['goog:chromeOptions'] = config.capabilities.chromeOptions
+      delete config.capabilities.chromeOptions
     }
     if (config.capabilities.firefoxOptions) {
-      config.capabilities['moz:firefoxOptions'] = config.capabilities.firefoxOptions;
-      delete config.capabilities.firefoxOptions;
+      config.capabilities['moz:firefoxOptions'] = config.capabilities.firefoxOptions
+      delete config.capabilities.firefoxOptions
     }
     if (config.capabilities.ieOptions) {
-      config.capabilities['se:ieOptions'] = config.capabilities.ieOptions;
-      delete config.capabilities.ieOptions;
+      config.capabilities['se:ieOptions'] = config.capabilities.ieOptions
+      delete config.capabilities.ieOptions
     }
     if (config.capabilities.selenoidOptions) {
-      config.capabilities['selenoid:options'] = config.capabilities.selenoidOptions;
-      delete config.capabilities.selenoidOptions;
+      config.capabilities['selenoid:options'] = config.capabilities.selenoidOptions
+      delete config.capabilities.selenoidOptions
     }
 
-    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000; // convert to seconds
+    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000 // convert to seconds
 
     if (!config.capabilities.platformName && (!config.url || !config.browser)) {
       throw new Error(`
@@ -540,196 +541,212 @@ class WebDriver extends Helper {
               }
             }
           }
-      `);
+      `)
     }
 
-    return config;
+    return config
   }
 
   static _checkRequirements() {
     try {
-      require('webdriverio');
+      // In ESM, webdriverio will be checked via dynamic import in _init
+      // The import will fail at module load time if webdriverio is missing
+      return null
     } catch (e) {
-      return ['webdriverio@^6.12.1'];
+      return ['webdriverio@^6.12.1']
+    }
+  }
+
+  async _init() {
+    // Load webdriverio dynamically
+    if (!webdriverio) {
+      try {
+        webdriverio = await import('webdriverio')
+        webdriverio = webdriverio.default || webdriverio
+      } catch (e) {
+        throw new Error('webdriverio could not be loaded. Please install webdriverio.')
+      }
     }
   }
 
   static _config() {
-    return [{
-      name: 'url',
-      message: 'Base url of site to be tested',
-      default: 'http://localhost',
-    }, {
-      name: 'browser',
-      message: 'Browser in which testing will be performed',
-      default: 'chrome',
-    }];
+    return [
+      {
+        name: 'url',
+        message: 'Base url of site to be tested',
+        default: 'http://localhost',
+      },
+      {
+        name: 'browser',
+        message: 'Browser in which testing will be performed',
+        default: 'chrome',
+      },
+    ]
   }
 
   _beforeSuite() {
     if (!this.options.restart && !this.options.manualStart && !this.isRunning) {
-      this.debugSection('Session', 'Starting singleton browser session');
-      return this._startBrowser();
+      this.debugSection('Session', 'Starting singleton browser session')
+      return this._startBrowser()
     }
   }
 
   _lookupCustomLocator(customStrategy) {
-    if (typeof (this.customLocatorStrategies) !== 'object') {
-      return null;
+    if (typeof this.customLocatorStrategies !== 'object') {
+      return null
     }
-    const strategy = this.customLocatorStrategies[customStrategy];
-    return typeof (strategy) === 'function' ? strategy : null;
+    const strategy = this.customLocatorStrategies[customStrategy]
+    return typeof strategy === 'function' ? strategy : null
   }
 
   _isCustomLocator(locator) {
-    const locatorObj = new Locator(locator);
+    const locatorObj = new Locator(locator)
     if (locatorObj.isCustom()) {
-      const customLocator = this._lookupCustomLocator(locatorObj.type);
+      const customLocator = this._lookupCustomLocator(locatorObj.type)
       if (customLocator) {
-        return true;
+        return true
       }
-      throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".');
+      throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".')
     }
-    return false;
+    return false
   }
 
   async _res(locator) {
-    const res = (this._isShadowLocator(locator) || this._isCustomLocator(locator))
-      ? await this._locate(locator)
-      : await this.$$(withStrictLocator(locator));
-    return res;
+    const res = this._isShadowLocator(locator) || this._isCustomLocator(locator) ? await this._locate(locator) : await this.$$(withStrictLocator(locator))
+    return res
   }
 
   async _startBrowser() {
     try {
       if (this.options.multiremote) {
-        this.browser = await webdriverio.multiremote(this.options.multiremote);
+        this.browser = await webdriverio.multiremote(this.options.multiremote)
       } else {
         // remove non w3c capabilities
-        delete this.options.capabilities.protocol;
-        delete this.options.capabilities.hostname;
-        delete this.options.capabilities.port;
-        delete this.options.capabilities.path;
-        if (this.options.devtoolsProtocol) {
-          if (!['chrome', 'chromium'].includes(this.options.browser.toLowerCase())) throw Error('The devtools protocol is only working with Chrome or Chromium');
-          this.options.automationProtocol = 'devtools';
-        }
-        this.browser = await webdriverio.remote(this.options);
+        delete this.options.capabilities.protocol
+        delete this.options.capabilities.hostname
+        delete this.options.capabilities.port
+        delete this.options.capabilities.path
+        this.browser = await webdriverio.remote(this.options)
       }
     } catch (err) {
       if (err.toString().indexOf('ECONNREFUSED')) {
-        throw new ConnectionRefused(err);
+        throw new ConnectionRefused(err)
       }
-      throw err;
+      throw err
     }
 
-    this.isRunning = true;
+    this.isRunning = true
     if (this.options.timeouts && this.isWeb) {
-      await this.defineTimeout(this.options.timeouts);
+      await this.defineTimeout(this.options.timeouts)
     }
 
-    await this._resizeWindowIfNeeded(this.browser, this.options.windowSize);
+    await this._resizeWindowIfNeeded(this.browser, this.options.windowSize)
 
-    this.$$ = this.browser.$$.bind(this.browser);
+    this.$$ = this.browser.$$.bind(this.browser)
 
     if (this._isCustomLocatorStrategyDefined()) {
-      Object.keys(this.customLocatorStrategies).forEach(async (customLocator) => {
-        this.debugSection('Weddriver', `adding custom locator strategy: ${customLocator}`);
-        const locatorFunction = this._lookupCustomLocator(customLocator);
-        this.browser.addLocatorStrategy(customLocator, locatorFunction);
-      });
+      Object.keys(this.customLocatorStrategies).forEach(async customLocator => {
+        this.debugSection('Weddriver', `adding custom locator strategy: ${customLocator}`)
+        const locatorFunction = this._lookupCustomLocator(customLocator)
+        this.browser.addLocatorStrategy(customLocator, locatorFunction)
+      })
     }
 
     if (this.browser.capabilities && this.browser.capabilities.platformName) {
-      this.browser.capabilities.platformName = this.browser.capabilities.platformName.toLowerCase();
+      this.browser.capabilities.platformName = this.browser.capabilities.platformName.toLowerCase()
     }
 
-    if (this.options.automationProtocol) {
-      this.puppeteerBrowser = await this.browser.getPuppeteer();
+    this.browser.on('dialog', () => {})
+
+    // Check for Bidi, because "sessionSubscribe" is an exclusive Bidi protocol feature. Otherwise, error will be thrown.
+    if (this.browser.capabilities && this.browser.capabilities.webSocketUrl) {
+      await this.browser.sessionSubscribe({ events: ['log.entryAdded'] })
+      this.browser.on('log.entryAdded', logEvents)
     }
 
-    return this.browser;
+    return this.browser
   }
 
   _isCustomLocatorStrategyDefined() {
-    return this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length;
+    return this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length
   }
 
   async _stopBrowser() {
-    if (this.browser && this.isRunning) await this.browser.deleteSession();
+    if (this.browser && this.isRunning) await this.browser.deleteSession()
   }
 
   async _before() {
-    this.context = this.root;
-    if (this.options.restart && !this.options.manualStart) return this._startBrowser();
-    if (!this.isRunning && !this.options.manualStart) return this._startBrowser();
-    if (this.browser) this.$$ = this.browser.$$.bind(this.browser);
-    return this.browser;
+    if (!webdriverio) await this._init()
+    this.context = this.root
+    if (this.options.restart && !this.options.manualStart) return this._startBrowser()
+    if (!this.isRunning && !this.options.manualStart) return this._startBrowser()
+    if (this.browser) this.$$ = this.browser.$$.bind(this.browser)
+    return this.browser
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
     if (this.options.restart) {
-      this.isRunning = false;
-      return this.browser.deleteSession();
+      this.isRunning = false
+      return this.browser.deleteSession()
     }
-    if (this.browser.isInsideFrame) await this.browser.switchToFrame(null);
+    if (this.browser.isInsideFrame) await this.browser.switchFrame(null)
 
-    if (this.options.keepBrowserState) return;
+    if (this.options.keepBrowserState) return
 
     if (!this.options.keepCookies && this.options.capabilities.browserName) {
-      this.debugSection('Session', 'cleaning cookies and localStorage');
-      await this.browser.deleteCookies();
+      this.debugSection('Session', 'cleaning cookies and localStorage')
+      await this.browser.deleteCookies()
     }
-    await this.browser.execute('localStorage.clear();').catch((err) => {
-      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-    });
-    await this.closeOtherTabs();
-    return this.browser;
+    await this.browser.execute('localStorage.clear();').catch(err => {
+      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+    })
+    await this.closeOtherTabs()
+    browserLogs = []
+    return this.browser
   }
 
-  _afterSuite() {
-  }
+  _afterSuite() {}
 
   _finishTest() {
-    if (!this.options.restart && this.isRunning) return this._stopBrowser();
+    if (!this.options.restart && this.isRunning) return this._stopBrowser()
   }
 
   _session() {
-    const defaultSession = this.browser;
+    const defaultSession = this.browser
     return {
       start: async (sessionName, opts) => {
         // opts.disableScreenshots = true; // screenshots cant be saved as session will be already closed
-        opts = this._validateConfig(Object.assign(this.options, opts));
-        this.debugSection('New Browser', JSON.stringify(opts));
-        const browser = await webdriverio.remote(opts);
-        this.activeSessionName = sessionName;
+        opts = this._validateConfig(Object.assign(this.options, opts))
+        this.debugSection('New Browser', JSON.stringify(opts))
+        const browser = await webdriverio.remote(opts)
+        this.activeSessionName = sessionName
         if (opts.timeouts && this.isWeb) {
-          await this._defineBrowserTimeout(browser, opts.timeouts);
+          await this._defineBrowserTimeout(browser, opts.timeouts)
         }
 
-        await this._resizeWindowIfNeeded(browser, opts.windowSize);
+        await this._resizeWindowIfNeeded(browser, opts.windowSize)
 
-        return browser;
+        return browser
       },
-      stop: async (browser) => {
-        if (!browser) return;
-        return browser.deleteSession();
+      stop: async browser => {
+        if (!browser) return
+        return browser.deleteSession()
       },
-      loadVars: async (browser) => {
-        if (this.context !== this.root) throw new Error('Can\'t start session inside within block');
-        this.browser = browser;
-        this.$$ = this.browser.$$.bind(this.browser);
-        this.sessionWindows[this.activeSessionName] = browser;
+      loadVars: async browser => {
+        if (this.context !== this.root) throw new Error("Can't start session inside within block")
+        this.browser = browser
+        this.$$ = this.browser.$$.bind(this.browser)
+        this.sessionWindows[this.activeSessionName] = browser
       },
-      restoreVars: async (session) => {
+      restoreVars: async session => {
         if (!session) {
-          this.activeSessionName = '';
+          this.activeSessionName = ''
         }
-        this.browser = defaultSession;
-        this.$$ = this.browser.$$.bind(this.browser);
+        this.browser = defaultSession
+        this.$$ = this.browser.$$.bind(this.browser)
       },
-    };
+    }
   }
 
   /**
@@ -751,41 +768,41 @@ class WebDriver extends Helper {
    * @param {function} fn async functuion that executed with WebDriver helper as argument
    */
   useWebDriverTo(description, fn) {
-    return this._useTo(...arguments);
+    return this._useTo(...arguments)
   }
 
   async _failed() {
-    if (this.context !== this.root) await this._withinEnd();
+    if (this.context !== this.root) await this._withinEnd()
   }
 
   async _withinBegin(locator) {
-    const frame = isFrameLocator(locator);
+    const frame = isFrameLocator(locator)
     if (frame) {
-      this.browser.isInsideFrame = true;
+      this.browser.isInsideFrame = true
       if (Array.isArray(frame)) {
         // this.switchTo(null);
-        await forEachAsync(frame, async f => this.switchTo(f));
-        return;
+        await forEachAsync(frame, async f => this.switchTo(f))
+        return
       }
-      await this.switchTo(frame);
-      return;
+      await this.switchTo(frame)
+      return
     }
-    this.context = locator;
+    this.context = locator
 
-    let res = await this.browser.$$(withStrictLocator(locator));
-    assertElementExists(res, locator);
-    res = usingFirstElement(res);
-    this.context = res.selector;
-    this.$$ = res.$$.bind(res);
+    let res = await this.browser.$$(withStrictLocator(locator))
+    assertElementExists(res, locator)
+    res = usingFirstElement(res)
+    this.context = res.selector
+    this.$$ = res.$$.bind(res)
   }
 
   async _withinEnd() {
     if (this.browser.isInsideFrame) {
-      this.browser.isInsideFrame = false;
-      return this.switchTo(null);
+      this.browser.isInsideFrame = false
+      return this.switchTo(null)
     }
-    this.context = this.root;
-    this.$$ = this.browser.$$.bind(this.browser);
+    this.context = this.root
+    this.$$ = this.browser.$$.bind(this.browser)
   }
 
   /**
@@ -794,7 +811,7 @@ class WebDriver extends Helper {
    * @param {object} locator
    */
   _isShadowLocator(locator) {
-    return locator.type === SHADOW || locator[SHADOW];
+    return locator.type === SHADOW || locator[SHADOW]
   }
 
   /**
@@ -803,35 +820,37 @@ class WebDriver extends Helper {
    * @param {object} locator
    */
   async _locateShadow(locator) {
-    const shadow = locator.value ? locator.value : locator[SHADOW];
-    const shadowSequence = [];
-    let elements;
+    const shadow = locator.value ? locator.value : locator[SHADOW]
+    const shadowSequence = []
+    let elements
 
     if (!Array.isArray(shadow)) {
-      throw new Error(`Shadow '${shadow}' should be defined as an Array of elements.`);
+      throw new Error(`Shadow '${shadow}' should be defined as an Array of elements.`)
     }
 
     // traverse through the Shadow locators in sequence
     for (let index = 0; index < shadow.length; index++) {
-      const shadowElement = shadow[index];
-      shadowSequence.push(shadowElement);
+      const shadowElement = shadow[index]
+      shadowSequence.push(shadowElement)
 
       if (!elements) {
-        elements = await (this.browser.$$(shadowElement));
+        elements = await this.browser.$$(shadowElement)
       } else if (Array.isArray(elements)) {
-        elements = await elements[0].shadow$$(shadowElement);
+        elements = await elements[0].shadow$$(shadowElement)
       } else if (elements) {
-        elements = await elements.shadow$$(shadowElement);
+        elements = await elements.shadow$$(shadowElement)
       }
 
       if (!elements || !elements[0]) {
-        throw new Error(`Shadow Element '${shadowElement}' is not found. It is possible the element is incorrect or elements sequence is incorrect. Please verify the sequence '${shadowSequence.join('>')}' is correctly chained.`);
+        throw new Error(
+          `Shadow Element '${shadowElement}' is not found. It is possible the element is incorrect or elements sequence is incorrect. Please verify the sequence '${shadowSequence.join('>')}' is correctly chained.`,
+        )
       }
     }
 
-    this.debugSection('Elements', `Found ${elements.length} '${SHADOW}' elements`);
+    this.debugSection('Elements', `Found ${elements.length} '${SHADOW}' elements`)
 
-    return elements;
+    return elements
   }
 
   /**
@@ -840,8 +859,8 @@ class WebDriver extends Helper {
    * @param {object} locator
    */
   async _smartWait(locator) {
-    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${JSON.stringify(locator)} in ${this.options.smartWait}`);
-    await this.defineTimeout({ implicit: this.options.smartWait });
+    this.debugSection(`SmartWait (${this.options.smartWait}ms)`, `Locating ${JSON.stringify(locator)} in ${this.options.smartWait}`)
+    await this.defineTimeout({ implicit: this.options.smartWait })
   }
 
   /**
@@ -856,53 +875,64 @@ class WebDriver extends Helper {
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
   async _locate(locator, smartWait = false) {
-    if (require('../store.js').debugMode) smartWait = false;
+    if (store.debugMode) smartWait = false
 
     // special locator type for Shadow DOM
     if (this._isShadowLocator(locator)) {
       if (!this.options.smartWait || !smartWait) {
-        const els = await this._locateShadow(locator);
-        return els;
+        const els = await this._locateShadow(locator)
+        return els
       }
 
-      const els = await this._locateShadow(locator);
-      return els;
+      const els = await this._locateShadow(locator)
+      return els
     }
 
     // special locator type for React
     if (locator.react) {
-      const els = await this.browser.react$$(locator.react, locator.props || undefined, locator.state || undefined);
-      this.debugSection('Elements', `Found ${els.length} react components`);
-      return els;
+      const els = await this.browser.react$$(locator.react, locator.props || undefined, locator.state || undefined)
+      this.debugSection('Elements', `Found ${els.length} react components`)
+      return els
+    }
+
+    // special locator type for ARIA roles
+    if (locator.role) {
+      return this._locateByRole(locator)
+    }
+
+    // Handle role locators passed as Locator instances
+    const matchedLocator = new Locator(locator)
+    if (matchedLocator.isRole()) {
+      return this._locateByRole(matchedLocator.locator)
     }
 
     if (!this.options.smartWait || !smartWait) {
       if (this._isCustomLocator(locator)) {
-        const locatorObj = new Locator(locator);
-        return this.browser.custom$$(locatorObj.type, locatorObj.value);
+        const locatorObj = new Locator(locator)
+        return this.browser.custom$$(locatorObj.type, locatorObj.value)
       }
 
-      const els = await this.$$(withStrictLocator(locator));
-      return els;
+      const els = await this.$$(withStrictLocator(locator))
+      return els
     }
 
-    await this._smartWait(locator);
+    await this._smartWait(locator)
 
     if (this._isCustomLocator(locator)) {
-      const locatorObj = new Locator(locator);
-      return this.browser.custom$$(locatorObj.type, locatorObj.value);
+      const locatorObj = new Locator(locator)
+      return this.browser.custom$$(locatorObj.type, locatorObj.value)
     }
 
-    const els = await this.$$(withStrictLocator(locator));
-    await this.defineTimeout({ implicit: 0 });
-    return els;
+    const els = await this.$$(withStrictLocator(locator))
+    await this.defineTimeout({ implicit: 0 })
+    return els
   }
 
   _grabCustomLocator(locator) {
     if (typeof locator === 'string') {
-      locator = new Locator(locator);
+      locator = new Locator(locator)
     }
-    return locator.value ? locator.value : locator.custom;
+    return locator.value ? locator.value : locator.custom
   }
 
   /**
@@ -915,7 +945,7 @@ class WebDriver extends Helper {
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
   async _locateCheckable(locator) {
-    return findCheckable.call(this, locator, this.$$.bind(this)).then(res => res);
+    return findCheckable.call(this, locator, this.$$.bind(this)).then(res => res)
   }
 
   /**
@@ -929,8 +959,8 @@ class WebDriver extends Helper {
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
   async _locateClickable(locator, context) {
-    const locateFn = prepareLocateFn.call(this, context);
-    return findClickable.call(this, locator, locateFn);
+    const locateFn = prepareLocateFn.call(this, context)
+    return findClickable.call(this, locator, locateFn)
   }
 
   /**
@@ -943,7 +973,35 @@ class WebDriver extends Helper {
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
   async _locateFields(locator) {
-    return findFields.call(this, locator).then(res => res);
+    return findFields.call(this, locator).then(res => res)
+  }
+
+  /**
+   * Locate elements by ARIA role using WebdriverIO accessibility selectors
+   *
+   * @param {object} locator - role locator object { role: string, text?: string, exact?: boolean }
+   */
+  async _locateByRole(locator) {
+    const role = locator.role
+
+    if (!locator.text) {
+      return this.browser.$$(`[role="${role}"]`)
+    }
+
+    const elements = await this.browser.$$(`[role="${role}"]`)
+    const filteredElements = []
+    const matchFn = locator.exact === true
+      ? t => t === locator.text
+      : t => t && t.includes(locator.text)
+
+    for (const element of elements) {
+      const texts = await getElementTextAttributes.call(this, element)
+      if (texts.some(matchFn)) {
+        filteredElements.push(element)
+      }
+    }
+
+    return filteredElements
   }
 
   /**
@@ -951,7 +1009,20 @@ class WebDriver extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator);
+    const elements = await this._locate(locator)
+    return elements.map(element => new WebElement(element, this))
+  }
+
+  /**
+   * {{> grabWebElement }}
+   *
+   */
+  async grabWebElement(locator) {
+    const elements = await this._locate(locator)
+    if (elements.length === 0) {
+      throw new ElementNotFound(locator, 'Element')
+    }
+    return new WebElement(elements[0], this)
   }
 
   /**
@@ -967,11 +1038,11 @@ class WebDriver extends Helper {
    * @param {*} timeouts WebDriver timeouts object.
    */
   defineTimeout(timeouts) {
-    return this._defineBrowserTimeout(this.browser, timeouts);
+    return this._defineBrowserTimeout(this.browser, timeouts)
   }
 
   _defineBrowserTimeout(browser, timeouts) {
-    return browser.setTimeout(timeouts);
+    return browser.setTimeout(timeouts)
   }
 
   /**
@@ -979,15 +1050,15 @@ class WebDriver extends Helper {
    *
    */
   amOnPage(url) {
-    let split_url;
+    let split_url
     if (this.options.basicAuth) {
       if (url.startsWith('/')) {
-        url = this.options.url + url;
+        url = this.options.url + url
       }
-      split_url = url.split('//');
-      url = `${split_url[0]}//${this.options.basicAuth.username}:${this.options.basicAuth.password}@${split_url[1]}`;
+      split_url = url.split('//')
+      url = `${split_url[0]}//${this.options.basicAuth.username}:${this.options.basicAuth.password}@${split_url[1]}`
     }
-    return this.browser.url(url);
+    return this.browser.url(url)
   }
 
   /**
@@ -996,18 +1067,18 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async click(locator, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick';
-    const locateFn = prepareLocateFn.call(this, context);
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findClickable.call(this, locator, locateFn);
+    const res = await findClickable.call(this, locator, locateFn)
     if (context) {
-      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`)
     } else {
-      assertElementExists(res, locator, 'Clickable element');
+      assertElementExists(res, locator, 'Clickable element')
     }
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
-    return this.browser[clickMethod](getElementId(elem));
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
+    return this.browser[clickMethod](getElementId(elem))
   }
 
   /**
@@ -1016,25 +1087,25 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async forceClick(locator, context = null) {
-    const locateFn = prepareLocateFn.call(this, context);
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findClickable.call(this, locator, locateFn);
+    const res = await findClickable.call(this, locator, locateFn)
     if (context) {
-      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`)
     } else {
-      assertElementExists(res, locator, 'Clickable element');
+      assertElementExists(res, locator, 'Clickable element')
     }
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
 
-    return this.executeScript((el) => {
+    return this.executeScript(el => {
       if (document.activeElement instanceof HTMLElement) {
-        document.activeElement.blur();
+        document.activeElement.blur()
       }
-      const event = document.createEvent('MouseEvent');
-      event.initEvent('click', true, true);
-      return el.dispatchEvent(event);
-    }, elem);
+      const event = document.createEvent('MouseEvent')
+      event.initEvent('click', true, true)
+      return el.dispatchEvent(event)
+    }, elem)
   }
 
   /**
@@ -1043,18 +1114,18 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async doubleClick(locator, context = null) {
-    const locateFn = prepareLocateFn.call(this, context);
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findClickable.call(this, locator, locateFn);
+    const res = await findClickable.call(this, locator, locateFn)
     if (context) {
-      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`)
     } else {
-      assertElementExists(res, locator, 'Clickable element');
+      assertElementExists(res, locator, 'Clickable element')
     }
 
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
-    return elem.doubleClick();
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
+    return elem.doubleClick()
   }
 
   /**
@@ -1063,24 +1134,93 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async rightClick(locator, context) {
-    const locateFn = prepareLocateFn.call(this, context);
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findClickable.call(this, locator, locateFn);
+    const res = await findClickable.call(this, locator, locateFn)
     if (context) {
-      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`)
     } else {
-      assertElementExists(res, locator, 'Clickable element');
+      assertElementExists(res, locator, 'Clickable element')
     }
 
-    const el = usingFirstElement(res);
+    const el = usingFirstElement(res)
 
-    await el.moveTo();
+    await el.moveTo()
 
     if (this.browser.isW3C) {
-      return el.click({ button: 'right' });
+      return el.click({ button: 'right' })
     }
     // JSON Wire version
-    await this.browser.buttonDown(2);
+    await this.browser.buttonDown(2)
+  }
+
+  /**
+   * Performs click at specific coordinates.
+   * If locator is provided, the coordinates are relative to the element's top-left corner.
+   * If locator is not provided, the coordinates are relative to the body element.
+   *
+   * ```js
+   * // Click at coordinates (100, 200) relative to body
+   * I.clickXY(100, 200);
+   *
+   * // Click at coordinates (50, 30) relative to element's top-left corner
+   * I.clickXY('#someElement', 50, 30);
+   * ```
+   *
+   * @param {CodeceptJS.LocatorOrString|number} locator Element to click on or X coordinate if no element.
+   * @param {number} [x] X coordinate relative to element's top-left, or Y coordinate if locator is a number.
+   * @param {number} [y] Y coordinate relative to element's top-left.
+   * @returns {Promise<void>}
+   */
+  async clickXY(locator, x, y) {
+    // If locator is a number, treat it as X coordinate and use body as base
+    if (typeof locator === 'number') {
+      const globalX = locator
+      const globalY = x
+      locator = '//body'
+      x = globalX
+      y = globalY
+    }
+
+    // Locate the base element
+    const res = await this._locate(withStrictLocator(locator), true)
+    assertElementExists(res, locator, 'Element to click')
+    const el = usingFirstElement(res)
+
+    // Get element position and size to calculate top-left corner
+    const location = await el.getLocation()
+    const size = await el.getSize()
+
+    // WebDriver clicks at center by default, so we need to offset from center to top-left
+    // then add our desired x, y coordinates
+    const offsetX = -(size.width / 2) + x
+    const offsetY = -(size.height / 2) + y
+
+    if (this.browser.isW3C) {
+      // Use performActions for W3C WebDriver
+      return this.browser.performActions([
+        {
+          type: 'pointer',
+          id: 'pointer1',
+          parameters: { pointerType: 'mouse' },
+          actions: [
+            {
+              type: 'pointerMove',
+              origin: el,
+              duration: 0,
+              x: Math.round(offsetX),
+              y: Math.round(offsetY),
+            },
+            { type: 'pointerDown', button: 0 },
+            { type: 'pointerUp', button: 0 },
+          ],
+        },
+      ])
+    }
+
+    // Fallback for non-W3C browsers
+    await el.moveTo({ xOffset: Math.round(offsetX), yOffset: Math.round(offsetY) })
+    return el.click()
   }
 
   /**
@@ -1089,24 +1229,24 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async forceRightClick(locator, context = null) {
-    const locateFn = prepareLocateFn.call(this, context);
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findClickable.call(this, locator, locateFn);
+    const res = await findClickable.call(this, locator, locateFn)
     if (context) {
-      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`);
+      assertElementExists(res, locator, 'Clickable element', `was not found inside element ${new Locator(context)}`)
     } else {
-      assertElementExists(res, locator, 'Clickable element');
+      assertElementExists(res, locator, 'Clickable element')
     }
-    const elem = usingFirstElement(res);
+    const elem = usingFirstElement(res)
 
-    return this.executeScript((el) => {
+    return this.executeScript(el => {
       if (document.activeElement instanceof HTMLElement) {
-        document.activeElement.blur();
+        document.activeElement.blur()
       }
-      const event = document.createEvent('MouseEvent');
-      event.initEvent('contextmenu', true, true);
-      return el.dispatchEvent(event);
-    }, elem);
+      const event = document.createEvent('MouseEvent')
+      event.initEvent('contextmenu', true, true)
+      return el.dispatchEvent(event)
+    }, elem)
   }
 
   /**
@@ -1116,12 +1256,22 @@ class WebDriver extends Helper {
    *
    */
   async fillField(field, value) {
-    const res = await findFields.call(this, field);
-    assertElementExists(res, field, 'Field');
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
-    await elem.clearValue();
-    await elem.setValue(value.toString());
+    const res = await findFields.call(this, field)
+    assertElementExists(res, field, 'Field')
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
+    try {
+      await elem.clearValue()
+    } catch (err) {
+      if (err.message && err.message.includes('invalid element state')) {
+        await this.executeScript(el => {
+          el.value = ''
+        }, elem)
+      } else {
+        throw err
+      }
+    }
+    await elem.setValue(value.toString())
   }
 
   /**
@@ -1129,15 +1279,11 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async appendField(field, value) {
-    const res = await findFields.call(this, field);
-    assertElementExists(res, field, 'Field');
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
-    if (this.options.automationProtocol) {
-      const curentValue = await elem.getValue();
-      return elem.setValue(curentValue + value.toString());
-    }
-    return elem.addValue(value.toString());
+    const res = await findFields.call(this, field)
+    assertElementExists(res, field, 'Field')
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
+    return elem.addValue(value.toString())
   }
 
   /**
@@ -1145,47 +1291,44 @@ class WebDriver extends Helper {
    *
    */
   async clearField(field) {
-    const res = await findFields.call(this, field);
-    assertElementExists(res, field, 'Field');
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
-    if (this.options.automationProtocol) {
-      return elem.setValue('');
-    }
-    return elem.clearValue(getElementId(elem));
+    const res = await findFields.call(this, field)
+    assertElementExists(res, field, 'Field')
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
+    return elem.clearValue(getElementId(elem))
   }
 
   /**
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const res = await findFields.call(this, select);
-    assertElementExists(res, select, 'Selectable field');
-    const elem = usingFirstElement(res);
-    highlightActiveElement.call(this, elem);
+    const res = await findFields.call(this, select)
+    assertElementExists(res, select, 'Selectable field')
+    const elem = usingFirstElement(res)
+    highlightActiveElement.call(this, elem)
 
     if (!Array.isArray(option)) {
-      option = [option];
+      option = [option]
     }
 
     // select options by visible text
-    let els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byVisibleText(xpathLocator.literal(opt))));
+    let els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byVisibleText(xpathLocator.literal(opt))))
 
-    const clickOptionFn = async (el) => {
-      if (el[0]) el = el[0];
-      const elementId = getElementId(el);
-      if (elementId) return this.browser.elementClick(elementId);
-    };
+    const clickOptionFn = async el => {
+      if (el[0]) el = el[0]
+      const elementId = getElementId(el)
+      if (elementId) return this.browser.elementClick(elementId)
+    }
 
     if (Array.isArray(els) && els.length) {
-      return forEachAsync(els, clickOptionFn);
+      return forEachAsync(els, clickOptionFn)
     }
     // select options by value
-    els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byValue(xpathLocator.literal(opt))));
+    els = await forEachAsync(option, async opt => this.browser.findElementsFromElement(getElementId(elem), 'xpath', Locator.select.byValue(xpathLocator.literal(opt))))
     if (els.length === 0) {
-      throw new ElementNotFound(select, `Option "${option}" in`, 'was not found neither by a visible text nor by a value');
+      throw new ElementNotFound(select, `Option "${option}" in`, 'was not found neither by a visible text nor by a value')
     }
-    return forEachAsync(els, clickOptionFn);
+    return forEachAsync(els, clickOptionFn)
   }
 
   /**
@@ -1194,27 +1337,27 @@ class WebDriver extends Helper {
    * {{> attachFile }}
    */
   async attachFile(locator, pathToFile) {
-    let file = path.join(global.codecept_dir, pathToFile);
+    let file = path.join(global.codecept_dir, pathToFile)
     if (!fileExists(file)) {
-      throw new Error(`File at ${file} can not be found on local system`);
+      throw new Error(`File at ${file} can not be found on local system`)
     }
 
-    const res = await findFields.call(this, locator);
-    this.debug(`Uploading ${file}`);
-    assertElementExists(res, locator, 'File field');
-    const el = usingFirstElement(res);
+    const res = await findFields.call(this, locator)
+    this.debug(`Uploading ${file}`)
+    assertElementExists(res, locator, 'File field')
+    const el = usingFirstElement(res)
 
     // Remote Upload (when running Selenium Server)
-    if (this.options.remoteFileUpload && !this.options.automationProtocol) {
+    if (this.options.remoteFileUpload) {
       try {
-        this.debugSection('File', 'Uploading file to remote server');
-        file = await this.browser.uploadFile(file);
+        this.debugSection('File', 'Uploading file to remote server')
+        file = await this.browser.uploadFile(file)
       } catch (err) {
-        throw new Error(`File can't be transferred to remote server. Set \`remoteFileUpload: false\` in config to upload file locally.\n${err.message}`);
+        throw new Error(`File can't be transferred to remote server. Set \`remoteFileUpload: false\` in config to upload file locally.\n${err.message}`)
       }
     }
 
-    return el.addValue(file);
+    return el.addValue(file)
   }
 
   /**
@@ -1222,19 +1365,20 @@ class WebDriver extends Helper {
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick';
-    const locateFn = prepareLocateFn.call(this, context);
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
+    const locateFn = prepareLocateFn.call(this, context)
+
+    const res = await findCheckable.call(this, field, locateFn)
 
-    const res = await findCheckable.call(this, field, locateFn);
+    assertElementExists(res, field, 'Checkable')
+    const elem = usingFirstElement(res)
+    const elementId = getElementId(elem)
+    highlightActiveElement.call(this, elem)
 
-    assertElementExists(res, field, 'Checkable');
-    const elem = usingFirstElement(res);
-    const elementId = getElementId(elem);
-    highlightActiveElement.call(this, elem);
+    const isSelected = await isElementChecked(this.browser, elementId)
 
-    const isSelected = await this.browser.isElementSelected(elementId);
-    if (isSelected) return Promise.resolve(true);
-    return this.browser[clickMethod](elementId);
+    if (isSelected) return Promise.resolve(true)
+    return this.browser[clickMethod](elementId)
   }
 
   /**
@@ -1242,19 +1386,20 @@ class WebDriver extends Helper {
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const clickMethod = this.browser.isMobile && !this.browser.isW3C ? 'touchClick' : 'elementClick';
-    const locateFn = prepareLocateFn.call(this, context);
+    const clickMethod = this.browser.isMobile && this.browser.capabilities.platformName !== 'android' ? 'touchClick' : 'elementClick'
+    const locateFn = prepareLocateFn.call(this, context)
 
-    const res = await findCheckable.call(this, field, locateFn);
+    const res = await findCheckable.call(this, field, locateFn)
 
-    assertElementExists(res, field, 'Checkable');
-    const elem = usingFirstElement(res);
-    const elementId = getElementId(elem);
-    highlightActiveElement.call(this, elem);
+    assertElementExists(res, field, 'Checkable')
+    const elem = usingFirstElement(res)
+    const elementId = getElementId(elem)
+    highlightActiveElement.call(this, elem)
 
-    const isSelected = await this.browser.isElementSelected(elementId);
-    if (!isSelected) return Promise.resolve(true);
-    return this.browser[clickMethod](elementId);
+    const isSelected = await isElementChecked(this.browser, elementId)
+
+    if (!isSelected) return Promise.resolve(true)
+    return this.browser[clickMethod](elementId)
   }
 
   /**
@@ -1262,10 +1407,14 @@ class WebDriver extends Helper {
    *
    */
   async grabTextFromAll(locator) {
-    const res = await this._locate(locator, true);
-    const val = await forEachAsync(res, el => this.browser.getElementText(getElementId(el)));
-    this.debugSection('GrabText', String(val));
-    return val;
+    const res = await this._locate(locator, true)
+    let val = []
+    await forEachAsync(res, async el => {
+      const text = await this.browser.getElementText(getElementId(el))
+      val.push(text)
+    })
+    this.debugSection('GrabText', String(val))
+    return val
   }
 
   /**
@@ -1273,13 +1422,13 @@ class WebDriver extends Helper {
    *
    */
   async grabTextFrom(locator) {
-    const texts = await this.grabTextFromAll(locator);
-    assertElementExists(texts, locator);
+    const texts = await this.grabTextFromAll(locator)
+    assertElementExists(texts, locator)
     if (texts.length > 1) {
-      this.debugSection('GrabText', `Using first element out of ${texts.length}`);
+      this.debugSection('GrabText', `Using first element out of ${texts.length}`)
     }
 
-    return texts[0];
+    return texts[0]
   }
 
   /**
@@ -1287,10 +1436,10 @@ class WebDriver extends Helper {
    *
    */
   async grabHTMLFromAll(locator) {
-    const elems = await this._locate(locator, true);
-    const html = await forEachAsync(elems, elem => elem.getHTML(false));
-    this.debugSection('GrabHTML', String(html));
-    return html;
+    const elems = await this._locate(locator, true)
+    const html = await forEachAsync(elems, elem => elem.getHTML(false))
+    this.debugSection('GrabHTML', String(html))
+    return html
   }
 
   /**
@@ -1298,13 +1447,13 @@ class WebDriver extends Helper {
    *
    */
   async grabHTMLFrom(locator) {
-    const html = await this.grabHTMLFromAll(locator);
-    assertElementExists(html, locator);
+    const html = await this.grabHTMLFromAll(locator)
+    assertElementExists(html, locator)
     if (html.length > 1) {
-      this.debugSection('GrabHTML', `Using first element out of ${html.length}`);
+      this.debugSection('GrabHTML', `Using first element out of ${html.length}`)
     }
 
-    return html[0];
+    return html[0]
   }
 
   /**
@@ -1312,11 +1461,11 @@ class WebDriver extends Helper {
    *
    */
   async grabValueFromAll(locator) {
-    const res = await this._locate(locator, true);
-    const val = await forEachAsync(res, el => el.getValue());
-    this.debugSection('GrabValue', String(val));
+    const res = await this._locate(locator, true)
+    const val = await forEachAsync(res, el => el.getValue())
+    this.debugSection('GrabValue', String(val))
 
-    return val;
+    return val
   }
 
   /**
@@ -1324,92 +1473,92 @@ class WebDriver extends Helper {
    *
    */
   async grabValueFrom(locator) {
-    const values = await this.grabValueFromAll(locator);
-    assertElementExists(values, locator);
+    const values = await this.grabValueFromAll(locator)
+    assertElementExists(values, locator)
     if (values.length > 1) {
-      this.debugSection('GrabValue', `Using first element out of ${values.length}`);
+      this.debugSection('GrabValue', `Using first element out of ${values.length}`)
     }
 
-    return values[0];
+    return values[0]
   }
 
   /**
    * {{> grabCssPropertyFromAll }}
    */
   async grabCssPropertyFromAll(locator, cssProperty) {
-    const res = await this._locate(locator, true);
-    const val = await forEachAsync(res, async el => this.browser.getElementCSSValue(getElementId(el), cssProperty));
-    this.debugSection('Grab', String(val));
-    return val;
+    const res = await this._locate(locator, true)
+    const val = await forEachAsync(res, async el => this.browser.getElementCSSValue(getElementId(el), cssProperty))
+    this.debugSection('Grab', String(val))
+    return val
   }
 
   /**
    * {{> grabCssPropertyFrom }}
    */
   async grabCssPropertyFrom(locator, cssProperty) {
-    const cssValues = await this.grabCssPropertyFromAll(locator, cssProperty);
-    assertElementExists(cssValues, locator);
+    const cssValues = await this.grabCssPropertyFromAll(locator, cssProperty)
+    assertElementExists(cssValues, locator)
 
     if (cssValues.length > 1) {
-      this.debugSection('GrabCSS', `Using first element out of ${cssValues.length}`);
+      this.debugSection('GrabCSS', `Using first element out of ${cssValues.length}`)
     }
 
-    return cssValues[0];
+    return cssValues[0]
   }
 
   /**
    * {{> grabAttributeFromAll }}
    */
   async grabAttributeFromAll(locator, attr) {
-    const res = await this._locate(locator, true);
-    const val = await forEachAsync(res, async el => el.getAttribute(attr));
-    this.debugSection('GrabAttribute', String(val));
-    return val;
+    const res = await this._locate(locator, true)
+    const val = await forEachAsync(res, async el => el.getAttribute(attr))
+    this.debugSection('GrabAttribute', String(val))
+    return val
   }
 
   /**
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFrom(locator, attr) {
-    const attrs = await this.grabAttributeFromAll(locator, attr);
-    assertElementExists(attrs, locator);
+    const attrs = await this.grabAttributeFromAll(locator, attr)
+    assertElementExists(attrs, locator)
     if (attrs.length > 1) {
-      this.debugSection('GrabAttribute', `Using first element out of ${attrs.length}`);
+      this.debugSection('GrabAttribute', `Using first element out of ${attrs.length}`)
     }
-    return attrs[0];
+    return attrs[0]
   }
 
   /**
    * {{> seeInTitle }}
    */
   async seeInTitle(text) {
-    const title = await this.browser.getTitle();
-    return stringIncludes('web page title').assert(text, title);
+    const title = await this.browser.getTitle()
+    return stringIncludes('web page title').assert(text, title)
   }
 
   /**
    * {{> seeTitleEquals }}
    */
   async seeTitleEquals(text) {
-    const title = await this.browser.getTitle();
-    return assert.equal(title, text, `expected web page title to be ${text}, but found ${title}`);
+    const title = await this.browser.getTitle()
+    return assert.equal(title, text, `expected web page title to be ${text}, but found ${title}`)
   }
 
   /**
    * {{> dontSeeInTitle }}
    */
   async dontSeeInTitle(text) {
-    const title = await this.browser.getTitle();
-    return stringIncludes('web page title').negate(text, title);
+    const title = await this.browser.getTitle()
+    return stringIncludes('web page title').negate(text, title)
   }
 
   /**
    * {{> grabTitle }}
    */
   async grabTitle() {
-    const title = await this.browser.getTitle();
-    this.debugSection('Title', title);
-    return title;
+    const title = await this.browser.getTitle()
+    this.debugSection('Title', title)
+    return title
   }
 
   /**
@@ -1418,14 +1567,14 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async see(text, context = null) {
-    return proceedSee.call(this, 'assert', text, context);
+    return proceedSee.call(this, 'assert', text, context)
   }
 
   /**
    * {{> seeTextEquals }}
    */
   async seeTextEquals(text, context = null) {
-    return proceedSee.call(this, 'assert', text, context, true);
+    return proceedSee.call(this, 'assert', text, context, true)
   }
 
   /**
@@ -1434,7 +1583,7 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async dontSee(text, context = null) {
-    return proceedSee.call(this, 'negate', text, context);
+    return proceedSee.call(this, 'negate', text, context)
   }
 
   /**
@@ -1442,8 +1591,8 @@ class WebDriver extends Helper {
    *
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeField.call(this, 'assert', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeField.call(this, 'assert', field, _value)
   }
 
   /**
@@ -1451,8 +1600,8 @@ class WebDriver extends Helper {
    *
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeField.call(this, 'negate', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeField.call(this, 'negate', field, _value)
   }
 
   /**
@@ -1460,7 +1609,7 @@ class WebDriver extends Helper {
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedSeeCheckbox.call(this, 'assert', field);
+    return proceedSeeCheckbox.call(this, 'assert', field)
   }
 
   /**
@@ -1468,7 +1617,7 @@ class WebDriver extends Helper {
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedSeeCheckbox.call(this, 'negate', field);
+    return proceedSeeCheckbox.call(this, 'negate', field)
   }
 
   /**
@@ -1477,13 +1626,13 @@ class WebDriver extends Helper {
    *
    */
   async seeElement(locator) {
-    const res = await this._locate(locator, true);
-    assertElementExists(res, locator);
-    const selected = await forEachAsync(res, async el => el.isDisplayed());
+    const res = await this._locate(locator, true)
+    assertElementExists(res, locator)
+    const selected = await forEachAsync(res, async el => el.isDisplayed())
     try {
-      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(selected);
+      return truth(`elements of ${new Locator(locator)}`, 'to be seen').assert(selected)
     } catch (e) {
-      dontSeeElementError(locator);
+      dontSeeElementError(locator)
     }
   }
 
@@ -1492,15 +1641,15 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async dontSeeElement(locator) {
-    const res = await this._locate(locator, false);
+    const res = await this._locate(locator, false)
     if (!res || res.length === 0) {
-      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(false);
+      return truth(`elements of ${new Locator(locator)}`, 'to be seen').negate(false)
     }
-    const selected = await forEachAsync(res, async el => el.isDisplayed());
+    const selected = await forEachAsync(res, async el => el.isDisplayed())
     try {
-      return truth(`elements of ${(new Locator(locator))}`, 'to be seen').negate(selected);
+      return truth(`elements of ${new Locator(locator)}`, 'to be seen').negate(selected)
     } catch (e) {
-      seeElementError(locator);
+      seeElementError(locator)
     }
   }
 
@@ -1509,11 +1658,11 @@ class WebDriver extends Helper {
    *
    */
   async seeElementInDOM(locator) {
-    const res = await this._res(locator);
+    const res = await this._res(locator)
     try {
-      return empty('elements').negate(res);
+      return empty('elements').negate(res)
     } catch (e) {
-      dontSeeElementInDOMError(locator);
+      dontSeeElementInDOMError(locator)
     }
   }
 
@@ -1522,11 +1671,11 @@ class WebDriver extends Helper {
    *
    */
   async dontSeeElementInDOM(locator) {
-    const res = await this._res(locator);
+    const res = await this._res(locator)
     try {
-      return empty('elements').assert(res);
+      return empty('elements').assert(res)
     } catch (e) {
-      seeElementInDOMError(locator);
+      seeElementInDOMError(locator)
     }
   }
 
@@ -1535,8 +1684,8 @@ class WebDriver extends Helper {
    *
    */
   async seeInSource(text) {
-    const source = await this.browser.getPageSource();
-    return stringIncludes('HTML source of a page').assert(text, source);
+    const source = await this.browser.getPageSource()
+    return stringIncludes('HTML source of a page').assert(text, source)
   }
 
   /**
@@ -1544,35 +1693,31 @@ class WebDriver extends Helper {
    *
    */
   async grabSource() {
-    return this.browser.getPageSource();
+    return this.browser.getPageSource()
   }
 
   /**
    * {{> grabBrowserLogs }}
    */
   async grabBrowserLogs() {
-    if (this.browser.isW3C) {
-      this.debug('Logs not available in W3C specification');
-      return;
-    }
-    return this.browser.getLogs('browser');
+    return browserLogs
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    const res = await this.browser.getUrl();
-    this.debugSection('Url', res);
-    return res;
+    const res = await this.browser.getUrl()
+    this.debugSection('Url', res)
+    return res
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    const source = await this.browser.getPageSource();
-    return stringIncludes('HTML source of a page').negate(text, source);
+    const source = await this.browser.getPageSource()
+    return stringIncludes('HTML source of a page').negate(text, source)
   }
 
   /**
@@ -1580,8 +1725,8 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async seeNumberOfElements(locator, num) {
-    const res = await this._locate(locator);
-    return assert.equal(res.length, num, `expected number of elements (${(new Locator(locator))}) is ${num}, but found ${res.length}`);
+    const res = await this._locate(locator)
+    return assert.equal(res.length, num, `expected number of elements (${new Locator(locator)}) is ${num}, but found ${res.length}`)
   }
 
   /**
@@ -1589,86 +1734,82 @@ class WebDriver extends Helper {
    * {{ react }}
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const res = await this.grabNumberOfVisibleElements(locator);
-    return assert.equal(res, num, `expected number of visible elements (${(new Locator(locator))}) is ${num}, but found ${res}`);
+    const res = await this.grabNumberOfVisibleElements(locator)
+    return assert.equal(res, num, `expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`)
   }
 
   /**
    * {{> seeCssPropertiesOnElements }}
    */
   async seeCssPropertiesOnElements(locator, cssProperties) {
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
+    const res = await this._locate(locator)
+    assertElementExists(res, locator)
 
-    const cssPropertiesCamelCase = convertCssPropertiesToCamelCase(cssProperties);
-    const elemAmount = res.length;
-    let props = [];
+    const cssPropertiesCamelCase = convertCssPropertiesToCamelCase(cssProperties)
+    const elemAmount = res.length
+    let props = []
 
     for (const element of res) {
       for (const prop of Object.keys(cssProperties)) {
-        const cssProp = await this.grabCssPropertyFrom(locator, prop);
+        const cssProp = await this.grabCssPropertyFrom(locator, prop)
         if (isColorProperty(prop)) {
-          props.push(convertColorToRGBA(cssProp));
+          props.push(convertColorToRGBA(cssProp))
         } else {
-          props.push(cssProp);
+          props.push(cssProp)
         }
       }
     }
 
-    const values = Object.keys(cssPropertiesCamelCase).map(key => cssPropertiesCamelCase[key]);
-    if (!Array.isArray(props)) props = [props];
-    let chunked = chunkArray(props, values.length);
-    chunked = chunked.filter((val) => {
+    const values = Object.keys(cssPropertiesCamelCase).map(key => cssPropertiesCamelCase[key])
+    if (!Array.isArray(props)) props = [props]
+    let chunked = chunkArray(props, values.length)
+    chunked = chunked.filter(val => {
       for (let i = 0; i < val.length; ++i) {
-        // eslint-disable-next-line eqeqeq
-        if (val[i] != values[i]) return false;
+        if (val[i] != values[i]) return false
       }
-      return true;
-    });
-    return equals(`all elements (${(new Locator(locator))}) to have CSS property ${JSON.stringify(cssProperties)}`).assert(chunked.length, elemAmount);
+      return true
+    })
+    return equals(`all elements (${new Locator(locator)}) to have CSS property ${JSON.stringify(cssProperties)}`).assert(chunked.length, elemAmount)
   }
 
   /**
    * {{> seeAttributesOnElements }}
    */
   async seeAttributesOnElements(locator, attributes) {
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
-    const elemAmount = res.length;
-
-    let attrs = await forEachAsync(res, async (el) => {
-      return forEachAsync(Object.keys(attributes), async attr => el.getAttribute(attr));
-    });
-
-    const values = Object.keys(attributes).map(key => attributes[key]);
-    if (!Array.isArray(attrs)) attrs = [attrs];
-    let chunked = chunkArray(attrs, values.length);
-    chunked = chunked.filter((val) => {
+    const res = await this._locate(locator)
+    assertElementExists(res, locator)
+    const elemAmount = res.length
+
+    let attrs = await forEachAsync(res, async el => {
+      return forEachAsync(Object.keys(attributes), async attr => el.getAttribute(attr))
+    })
+
+    const values = Object.keys(attributes).map(key => attributes[key])
+    if (!Array.isArray(attrs)) attrs = [attrs]
+    let chunked = chunkArray(attrs, values.length)
+    chunked = chunked.filter(val => {
       for (let i = 0; i < val.length; ++i) {
-        const _actual = Number.isNaN(val[i]) || (typeof values[i]) === 'string' ? val[i] : Number.parseInt(val[i], 10);
-        const _expected = Number.isNaN(values[i]) || (typeof values[i]) === 'string' ? values[i] : Number.parseInt(values[i], 10);
+        const _actual = Number.isNaN(val[i]) || typeof values[i] === 'string' ? val[i] : Number.parseInt(val[i], 10)
+        const _expected = Number.isNaN(values[i]) || typeof values[i] === 'string' ? values[i] : Number.parseInt(values[i], 10)
         // the attribute could be a boolean
-        if (typeof _actual === 'boolean') return _actual === _expected;
-        if (_actual !== _expected) return false;
+        if (typeof _actual === 'boolean') return _actual === _expected
+        if (_actual !== _expected) return false
       }
-      return true;
-    });
-    return assert.ok(
-      chunked.length === elemAmount,
-      `expected all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`,
-    );
+      return true
+    })
+    return assert.ok(chunked.length === elemAmount, `expected all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`)
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    const res = await this._locate(locator);
+    const res = await this._locate(locator)
 
-    let selected = await forEachAsync(res, async el => el.isDisplayed());
-    if (!Array.isArray(selected)) selected = [selected];
-    selected = selected.filter(val => val === true);
-    return selected.length;
+    let selected = await forEachAsync(res, async el => el.isDisplayed())
+    if (!Array.isArray(selected)) selected = [selected]
+    selected = selected.filter(val => val === true)
+    return selected.length
   }
 
   /**
@@ -1676,8 +1817,8 @@ class WebDriver extends Helper {
    *
    */
   async seeInCurrentUrl(url) {
-    const res = await this.browser.getUrl();
-    return stringIncludes('url').assert(url, decodeUrl(res));
+    const res = await this.browser.getUrl()
+    return stringIncludes('url').assert(url, decodeUrl(res))
   }
 
   /**
@@ -1685,8 +1826,8 @@ class WebDriver extends Helper {
    *
    */
   async dontSeeInCurrentUrl(url) {
-    const res = await this.browser.getUrl();
-    return stringIncludes('url').negate(url, decodeUrl(res));
+    const res = await this.browser.getUrl()
+    return stringIncludes('url').negate(url, decodeUrl(res))
   }
 
   /**
@@ -1694,8 +1835,8 @@ class WebDriver extends Helper {
    *
    */
   async seeCurrentUrlEquals(url) {
-    const res = await this.browser.getUrl();
-    return urlEquals(this.options.url).assert(url, decodeUrl(res));
+    const res = await this.browser.getUrl()
+    return urlEquals(this.options.url).assert(url, decodeUrl(res))
   }
 
   /**
@@ -1703,8 +1844,8 @@ class WebDriver extends Helper {
    *
    */
   async dontSeeCurrentUrlEquals(url) {
-    const res = await this.browser.getUrl();
-    return urlEquals(this.options.url).negate(url, decodeUrl(res));
+    const res = await this.browser.getUrl()
+    return urlEquals(this.options.url).negate(url, decodeUrl(res))
   }
 
   /**
@@ -1713,7 +1854,7 @@ class WebDriver extends Helper {
    * {{> executeScript }}
    */
   executeScript(...args) {
-    return this.browser.execute.apply(this.browser, args);
+    return this.browser.execute.apply(this.browser, args)
   }
 
   /**
@@ -1721,7 +1862,7 @@ class WebDriver extends Helper {
    *
    */
   executeAsyncScript(...args) {
-    return this.browser.executeAsync.apply(this.browser, args);
+    return this.browser.executeAsync.apply(this.browser, args)
   }
 
   /**
@@ -1729,10 +1870,10 @@ class WebDriver extends Helper {
    *
    */
   async scrollIntoView(locator, scrollIntoViewOptions) {
-    const res = await this._locate(withStrictLocator(locator), true);
-    assertElementExists(res, locator);
-    const elem = usingFirstElement(res);
-    return elem.scrollIntoView(scrollIntoViewOptions);
+    const res = await this._locate(withStrictLocator(locator), true)
+    assertElementExists(res, locator)
+    const elem = usingFirstElement(res)
+    return elem.scrollIntoView(scrollIntoViewOptions)
   }
 
   /**
@@ -1741,42 +1882,51 @@ class WebDriver extends Helper {
    */
   async scrollTo(locator, offsetX = 0, offsetY = 0) {
     if (typeof locator === 'number' && typeof offsetX === 'number') {
-      offsetY = offsetX;
-      offsetX = locator;
-      locator = null;
+      offsetY = offsetX
+      offsetX = locator
+      locator = null
     }
 
     if (locator) {
-      const res = await this._locate(withStrictLocator(locator), true);
-      assertElementExists(res, locator);
-      const elem = usingFirstElement(res);
-      const elementId = getElementId(elem);
-      if (this.browser.isMobile && !this.browser.isW3C) return this.browser.touchScroll(offsetX, offsetY, elementId);
-      const location = await elem.getLocation();
-      assertElementExists(location, locator, 'Failed to receive', 'location');
-      /* eslint-disable prefer-arrow-callback */
-      return this.browser.execute(function (x, y) { return window.scrollTo(x, y); }, location.x + offsetX, location.y + offsetY);
-      /* eslint-enable */
-    }
-
-    if (this.browser.isMobile && !this.browser.isW3C) return this.browser.touchScroll(locator, offsetX, offsetY);
-
-    /* eslint-disable prefer-arrow-callback, comma-dangle */
-    return this.browser.execute(function (x, y) { return window.scrollTo(x, y); }, offsetX, offsetY);
-    /* eslint-enable */
+      const res = await this._locate(withStrictLocator(locator), true)
+      assertElementExists(res, locator)
+      const elem = usingFirstElement(res)
+      const elementId = getElementId(elem)
+      if (this.browser.isMobile && !this.browser.isW3C) return this.browser.touchScroll(offsetX, offsetY, elementId)
+      const location = await elem.getLocation()
+      assertElementExists(location, locator, 'Failed to receive', 'location')
+
+      return this.browser.execute(
+        function (x, y) {
+          return window.scrollTo(x, y)
+        },
+        location.x + offsetX,
+        location.y + offsetY,
+      )
+    }
+
+    if (this.browser.isMobile && !this.browser.isW3C) return this.browser.touchScroll(locator, offsetX, offsetY)
+
+    return this.browser.execute(
+      function (x, y) {
+        return window.scrollTo(x, y)
+      },
+      offsetX,
+      offsetY,
+    )
   }
 
   /**
    * {{> moveCursorTo }}
    */
   async moveCursorTo(locator, xOffset, yOffset) {
-    const res = await this._locate(withStrictLocator(locator), true);
-    assertElementExists(res, locator);
-    const elem = usingFirstElement(res);
+    const res = await this._locate(withStrictLocator(locator), true)
+    assertElementExists(res, locator)
+    const elem = usingFirstElement(res)
     try {
-      await elem.moveTo({ xOffset, yOffset });
+      await elem.moveTo({ xOffset, yOffset })
     } catch (e) {
-      debug(e.message);
+      output.debug(e.message)
     }
   }
 
@@ -1785,54 +1935,68 @@ class WebDriver extends Helper {
    *
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
-    const res = await this._locate(withStrictLocator(locator), true);
-    assertElementExists(res, locator);
-    const elem = usingFirstElement(res);
+    const res = await this._locate(withStrictLocator(locator), true)
+    assertElementExists(res, locator)
+    const elem = usingFirstElement(res)
 
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
-    return elem.saveScreenshot(outputFile);
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+    return elem.saveScreenshot(outputFile)
   }
 
   /**
    * {{> saveScreenshot }}
    */
   async saveScreenshot(fileName, fullPage = false) {
-    const outputFile = screenshotOutputFolder(fileName);
+    let outputFile = screenshotOutputFolder(fileName)
 
     if (this.activeSessionName) {
-      const browser = this.sessionWindows[this.activeSessionName];
+      const browser = this.sessionWindows[this.activeSessionName]
+
+      for (const sessionName in this.sessionWindows) {
+        const activeSessionPage = this.sessionWindows[sessionName]
+        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`)
+
+        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`)
 
-      if (browser) {
-        this.debug(`Screenshot of ${this.activeSessionName} session has been saved to ${outputFile}`);
-        return browser.saveScreenshot(outputFile);
+        if (browser) {
+          this.debug(`Screenshot of ${sessionName} session has been saved to ${outputFile}`)
+          await browser.saveScreenshot(outputFile)
+        }
       }
     }
 
     if (!fullPage) {
-      this.debug(`Screenshot has been saved to ${outputFile}`);
-      return this.browser.saveScreenshot(outputFile);
+      this.debug(`Screenshot has been saved to ${outputFile}`)
+      await this.browser.saveScreenshot(outputFile)
     }
 
-    /* eslint-disable prefer-arrow-callback, comma-dangle, prefer-const */
-    const originalWindowSize = await this.browser.getWindowSize();
+    const originalWindowSize = await this.browser.getWindowSize()
 
-    let { width, height } = await this.browser.execute(function () {
-      return {
-        height: document.body.scrollHeight,
-        width: document.body.scrollWidth
-      };
-    }).then(res => res);
+    // this case running on device, so we could not set the windowSize
+    if (this.browser.isMobile) {
+      this.debug(`Screenshot has been saved to ${outputFile}, size: ${originalWindowSize.width}x${originalWindowSize.height}`)
+      const buffer = await this.browser.saveScreenshot(outputFile)
+      return buffer
+    }
+
+    let { width, height } = await this.browser
+      .execute(function () {
+        return {
+          height: document.body.scrollHeight,
+          width: document.body.scrollWidth,
+        }
+      })
+      .then(res => res)
 
-    if (height < 100) height = 500; // errors for very small height
-    /* eslint-enable */
+    if (height < 100) height = 500 // errors for very small height
 
-    await this.browser.setWindowSize(width, height);
-    this.debug(`Screenshot has been saved to ${outputFile}, size: ${width}x${height}`);
-    const buffer = await this.browser.saveScreenshot(outputFile);
-    await this.browser.setWindowSize(originalWindowSize.width, originalWindowSize.height);
-    return buffer;
+    await this.browser.setWindowSize(width, height)
+    this.debug(`Screenshot has been saved to ${outputFile}, size: ${width}x${height}`)
+    const buffer = await this.browser.saveScreenshot(outputFile)
+    await this.browser.setWindowSize(originalWindowSize.width, originalWindowSize.height)
+    return buffer
   }
 
   /**
@@ -1840,40 +2004,40 @@ class WebDriver extends Helper {
    * {{> setCookie }}
    */
   async setCookie(cookie) {
-    return this.browser.setCookies(cookie);
+    return this.browser.setCookies(cookie)
   }
 
   /**
    * {{> clearCookie }}
    */
   async clearCookie(cookie) {
-    return this.browser.deleteCookies(cookie);
+    return this.browser.deleteCookies(cookie)
   }
 
   /**
    * {{> seeCookie }}
    */
   async seeCookie(name) {
-    const cookie = await this.browser.getCookies([name]);
-    return truth(`cookie ${name}`, 'to be set').assert(cookie);
+    const cookie = await this.browser.getCookies([name])
+    return truth(`cookie ${name}`, 'to be set').assert(cookie)
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    const cookie = await this.browser.getCookies([name]);
-    return truth(`cookie ${name}`, 'to be set').negate(cookie);
+    const cookie = await this.browser.getCookies([name])
+    return truth(`cookie ${name}`, 'to be set').negate(cookie)
   }
 
   /**
    * {{> grabCookie }}
    */
   async grabCookie(name) {
-    if (!name) return this.browser.getCookies();
-    const cookie = await this.browser.getCookies([name]);
-    this.debugSection('Cookie', JSON.stringify(cookie));
-    return cookie[0];
+    if (!name) return this.browser.getCookies()
+    const cookie = await this.browser.getCookies([name])
+    this.debugSection('Cookie', JSON.stringify(cookie))
+    return cookie[0]
   }
 
   /**
@@ -1881,30 +2045,33 @@ class WebDriver extends Helper {
    */
   async waitForCookie(name, sec) {
     // by default, we will retry 3 times
-    let retries = 3;
-    const waitTimeout = sec || this.options.waitForTimeoutInSeconds;
+    let retries = 3
+    const waitTimeout = sec || this.options.waitForTimeoutInSeconds
 
     if (sec) {
-      retries = sec;
+      retries = sec
     } else {
-      retries = waitTimeout - 1;
+      retries = waitTimeout - 1
     }
 
-    return promiseRetry(async (retry, number) => {
-      const _grabCookie = async (name) => {
-        const cookie = await this.browser.getCookies([name]);
-        if (cookie.length === 0) throw Error(`Cookie ${name} is not found after ${retries}s`);
-      };
+    return promiseRetry(
+      async (retry, number) => {
+        const _grabCookie = async name => {
+          const cookie = await this.browser.getCookies([name])
+          if (cookie.length === 0) throw Error(`Cookie ${name} is not found after ${retries}s`)
+        }
 
-      this.debugSection('Wait for cookie: ', name);
-      if (number > 1) this.debugSection('Retrying... Attempt #', number);
+        this.debugSection('Wait for cookie: ', name)
+        if (number > 1) this.debugSection('Retrying... Attempt #', number)
 
-      try {
-        await _grabCookie(name);
-      } catch (e) {
-        retry(e);
-      }
-    }, { retries, maxTimeout: 1000 });
+        try {
+          await _grabCookie(name)
+        } catch (e) {
+          retry(e)
+        }
+      },
+      { retries, maxTimeout: 1000 },
+    )
   }
 
   /**
@@ -1913,11 +2080,10 @@ class WebDriver extends Helper {
    * libraries](http://jster.net/category/windows-modals-popups).
    */
   async acceptPopup() {
-    return this.browser.getAlertText().then((res) => {
-      if (res !== null) {
-        return this.browser.acceptAlert();
-      }
-    });
+    const text = await this.browser.getAlertText()
+    if (text) {
+      return await this.browser.acceptAlert()
+    }
   }
 
   /**
@@ -1925,11 +2091,10 @@ class WebDriver extends Helper {
    *
    */
   async cancelPopup() {
-    return this.browser.getAlertText().then((res) => {
-      if (res !== null) {
-        return this.browser.dismissAlert();
-      }
-    });
+    const text = await this.browser.getAlertText()
+    if (text) {
+      return await this.browser.dismissAlert()
+    }
   }
 
   /**
@@ -1939,12 +2104,12 @@ class WebDriver extends Helper {
    * @param {string} text value to check.
    */
   async seeInPopup(text) {
-    return this.browser.getAlertText().then((res) => {
+    return await this.browser.getAlertText().then(res => {
       if (res === null) {
-        throw new Error('Popup is not opened');
+        throw new Error('Popup is not opened')
       }
-      stringIncludes('text in popup').assert(text, res);
-    });
+      stringIncludes('text in popup').assert(text, res)
+    })
   }
 
   /**
@@ -1952,9 +2117,9 @@ class WebDriver extends Helper {
    */
   async grabPopupText() {
     try {
-      return await this.browser.getAlertText();
+      return await this.browser.getAlertText()
     } catch (err) {
-      this.debugSection('Popup', 'Error getting text from popup');
+      this.debugSection('Popup', 'Error getting text from popup')
     }
   }
 
@@ -1962,36 +2127,44 @@ class WebDriver extends Helper {
    * {{> pressKeyDown }}
    */
   async pressKeyDown(key) {
-    key = getNormalizedKey.call(this, key);
+    key = getNormalizedKey.call(this, key)
     if (!this.browser.isW3C) {
-      return this.browser.sendKeys([key]);
+      return this.browser.sendKeys([key])
     }
-    return this.browser.performActions([{
-      type: 'key',
-      id: 'keyboard',
-      actions: [{
-        type: 'keyDown',
-        value: key,
-      }],
-    }]);
+    return this.browser.performActions([
+      {
+        type: 'key',
+        id: 'keyboard',
+        actions: [
+          {
+            type: 'keyDown',
+            value: key,
+          },
+        ],
+      },
+    ])
   }
 
   /**
    * {{> pressKeyUp }}
    */
   async pressKeyUp(key) {
-    key = getNormalizedKey.call(this, key);
+    key = getNormalizedKey.call(this, key)
     if (!this.browser.isW3C) {
-      return this.browser.sendKeys([key]);
+      return this.browser.sendKeys([key])
     }
-    return this.browser.performActions([{
-      type: 'key',
-      id: 'keyboard',
-      actions: [{
-        type: 'keyUp',
-        value: key,
-      }],
-    }]);
+    return this.browser.performActions([
+      {
+        type: 'key',
+        id: 'keyboard',
+        actions: [
+          {
+            type: 'keyUp',
+            value: key,
+          },
+        ],
+      },
+    ])
   }
 
   /**
@@ -2000,40 +2173,45 @@ class WebDriver extends Helper {
    * {{> pressKeyWithKeyNormalization }}
    */
   async pressKey(key) {
-    const modifiers = [];
+    const modifiers = []
     if (Array.isArray(key)) {
       for (let k of key) {
-        k = getNormalizedKey.call(this, k);
+        k = getNormalizedKey.call(this, k)
         if (isModifierKey(k)) {
-          modifiers.push(k);
+          modifiers.push(k)
         } else {
-          key = k;
-          break;
+          key = k
+          break
         }
       }
     } else {
-      key = getNormalizedKey.call(this, key);
+      key = getNormalizedKey.call(this, key)
     }
     for (const modifier of modifiers) {
-      await this.pressKeyDown(modifier);
+      await this.pressKeyDown(modifier)
     }
     if (!this.browser.isW3C) {
-      await this.browser.sendKeys([key]);
+      await this.browser.sendKeys([key])
     } else {
-      await this.browser.performActions([{
-        type: 'key',
-        id: 'keyboard',
-        actions: [{
-          type: 'keyDown',
-          value: key,
-        }, {
-          type: 'keyUp',
-          value: key,
-        }],
-      }]);
+      await this.browser.performActions([
+        {
+          type: 'key',
+          id: 'keyboard',
+          actions: [
+            {
+              type: 'keyDown',
+              value: key,
+            },
+            {
+              type: 'keyUp',
+              value: key,
+            },
+          ],
+        },
+      ])
     }
     for (const modifier of modifiers) {
-      await this.pressKeyUp(modifier);
+      await this.pressKeyUp(modifier)
     }
   }
 
@@ -2042,17 +2220,17 @@ class WebDriver extends Helper {
    */
   async type(keys, delay = null) {
     if (!Array.isArray(keys)) {
-      keys = keys.toString();
-      keys = keys.split('');
+      keys = keys.toString()
+      keys = keys.split('')
     }
     if (delay) {
       for (const key of keys) {
-        await this.browser.keys(key);
-        await this.wait(delay / 1000);
+        await this.browser.keys(key)
+        await this.wait(delay / 1000)
       }
-      return;
+      return
     }
-    await this.browser.keys(keys);
+    await this.browser.keys(keys)
   }
 
   /**
@@ -2061,27 +2239,27 @@ class WebDriver extends Helper {
    * {{> resizeWindow }}
    */
   async resizeWindow(width, height) {
-    return this.browser.setWindowSize(width, height);
+    return this.browser.setWindowSize(width, height)
   }
 
   async _resizeBrowserWindow(browser, width, height) {
     if (width === 'maximize') {
-      const size = await browser.maximizeWindow();
-      this.debugSection('Window Size', size);
-      return;
+      const size = await browser.maximizeWindow()
+      this.debugSection('Window Size', size)
+      return
     }
     if (browser.isW3C) {
-      return browser.setWindowRect(null, null, parseInt(width, 10), parseInt(height, 10));
+      return browser.setWindowRect(null, null, parseInt(width, 10), parseInt(height, 10))
     }
-    return browser.setWindowSize(parseInt(width, 10), parseInt(height, 10));
+    return browser.setWindowSize(parseInt(width, 10), parseInt(height, 10))
   }
 
   async _resizeWindowIfNeeded(browser, windowSize) {
     if (this.isWeb && windowSize === 'maximize') {
-      await this._resizeBrowserWindow(browser, 'maximize');
+      await this._resizeBrowserWindow(browser, 'maximize')
     } else if (this.isWeb && windowSize && windowSize.indexOf('x') > 0) {
-      const dimensions = windowSize.split('x');
-      await this._resizeBrowserWindow(browser, dimensions[0], dimensions[1]);
+      const dimensions = windowSize.split('x')
+      await this._resizeBrowserWindow(browser, dimensions[0], dimensions[1])
     }
   }
 
@@ -2090,11 +2268,11 @@ class WebDriver extends Helper {
    *
    */
   async focus(locator) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator, 'Element to focus');
-    const el = usingFirstElement(els);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator, 'Element to focus')
+    const el = usingFirstElement(els)
 
-    await focusElement(el, this.browser);
+    await focusElement(el, this.browser)
   }
 
   /**
@@ -2102,11 +2280,11 @@ class WebDriver extends Helper {
    *
    */
   async blur(locator) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator, 'Element to blur');
-    const el = usingFirstElement(els);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator, 'Element to blur')
+    const el = usingFirstElement(els)
 
-    await blurElement(el, this.browser);
+    await blurElement(el, this.browser)
   }
 
   /**
@@ -2114,64 +2292,73 @@ class WebDriver extends Helper {
    * {{> dragAndDrop }}
    */
   async dragAndDrop(srcElement, destElement) {
-    let sourceEl = await this._locate(srcElement);
-    assertElementExists(sourceEl, srcElement);
-    sourceEl = usingFirstElement(sourceEl);
+    let sourceEl = await this._locate(srcElement)
+    assertElementExists(sourceEl, srcElement)
+    sourceEl = usingFirstElement(sourceEl)
 
-    let destEl = await this._locate(destElement);
-    assertElementExists(destEl, destElement);
-    destEl = usingFirstElement(destEl);
+    let destEl = await this._locate(destElement)
+    assertElementExists(destEl, destElement)
+    destEl = usingFirstElement(destEl)
 
-    return sourceEl.dragAndDrop(destEl);
+    return sourceEl.dragAndDrop(destEl)
   }
 
   /**
    * {{> dragSlider }}
    */
   async dragSlider(locator, offsetX = 0) {
-    const browser = this.browser;
-    await this.moveCursorTo(locator);
+    const browser = this.browser
+    await this.moveCursorTo(locator)
 
     // for chrome
     if (browser.isW3C) {
-      const xOffset = await this.grabElementBoundingRect(locator, 'x');
-      const yOffset = await this.grabElementBoundingRect(locator, 'y');
-
-      return browser.performActions([{
-        type: 'pointer',
-        id: 'pointer1',
-        parameters: { pointerType: 'mouse' },
-        actions: [
-          {
-            type: 'pointerMove', origin: 'pointer', duration: 1000, x: xOffset, y: yOffset,
-          },
-          { type: 'pointerDown', button: 0 },
-          {
-            type: 'pointerMove', origin: 'pointer', duration: 1000, x: offsetX, y: 0,
-          },
-          { type: 'pointerUp', button: 0 },
-        ],
-      },
-      ]);
-    }
-
-    await browser.buttonDown(0);
-    await browser.moveToElement(null, offsetX, 0);
-    await browser.buttonUp(0);
+      const xOffset = await this.grabElementBoundingRect(locator, 'x')
+      const yOffset = await this.grabElementBoundingRect(locator, 'y')
+
+      return browser.performActions([
+        {
+          type: 'pointer',
+          id: 'pointer1',
+          parameters: { pointerType: 'mouse' },
+          actions: [
+            {
+              type: 'pointerMove',
+              origin: 'pointer',
+              duration: 1000,
+              x: xOffset,
+              y: yOffset,
+            },
+            { type: 'pointerDown', button: 0 },
+            {
+              type: 'pointerMove',
+              origin: 'pointer',
+              duration: 1000,
+              x: offsetX,
+              y: 0,
+            },
+            { type: 'pointerUp', button: 0 },
+          ],
+        },
+      ])
+    }
+
+    await browser.buttonDown(0)
+    await browser.moveToElement(null, offsetX, 0)
+    await browser.buttonUp(0)
   }
 
   /**
    * {{> grabAllWindowHandles }}
    */
   async grabAllWindowHandles() {
-    return this.browser.getWindowHandles();
+    return this.browser.getWindowHandles()
   }
 
   /**
    * {{> grabCurrentWindowHandle }}
    */
   async grabCurrentWindowHandle() {
-    return this.browser.getWindowHandle();
+    return this.browser.getWindowHandle()
   }
 
   /**
@@ -2189,22 +2376,22 @@ class WebDriver extends Helper {
    * @param {string} window name of window handle.
    */
   async switchToWindow(window) {
-    await this.browser.switchToWindow(window);
+    await this.browser.switchToWindow(window)
   }
 
   /**
    * {{> closeOtherTabs }}
    */
   async closeOtherTabs() {
-    const handles = await this.browser.getWindowHandles();
-    const currentHandle = await this.browser.getWindowHandle();
-    const otherHandles = handles.filter(handle => handle !== currentHandle);
+    const handles = await this.browser.getWindowHandles()
+    const currentHandle = await this.browser.getWindowHandle()
+    const otherHandles = handles.filter(handle => handle !== currentHandle)
 
-    await forEachAsync(otherHandles, async (handle) => {
-      await this.browser.switchToWindow(handle);
-      await this.browser.closeWindow();
-    });
-    await this.browser.switchToWindow(currentHandle);
+    await forEachAsync(otherHandles, async handle => {
+      await this.browser.switchToWindow(handle)
+      await this.browser.closeWindow()
+    })
+    await this.browser.switchToWindow(currentHandle)
   }
 
   /**
@@ -2212,102 +2399,123 @@ class WebDriver extends Helper {
    */
   async wait(sec) {
     return new Promise(resolve => {
-      setTimeout(resolve, sec * 1000);
-    });
+      setTimeout(resolve, sec * 1000)
+    })
   }
 
   /**
    * {{> waitForEnabled }}
    */
   async waitForEnabled(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
 
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      if (!res || res.length === 0) {
-        return false;
-      }
-      const selected = await forEachAsync(res, async el => this.browser.isElementEnabled(getElementId(el)));
-      if (Array.isArray(selected)) {
-        return selected.filter(val => val === true).length > 0;
-      }
-      return selected;
-    }, {
-      timeout: aSec * 1000,
-      timeoutMsg: `element (${new Locator(locator)}) still not enabled after ${aSec} sec`,
-    });
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(locator)
+        if (!res || res.length === 0) {
+          return false
+        }
+        const selected = await forEachAsync(res, async el => this.browser.isElementEnabled(getElementId(el)))
+        if (Array.isArray(selected)) {
+          return selected.filter(val => val === true).length > 0
+        }
+        return selected
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${new Locator(locator)}) still not enabled after ${aSec} sec`,
+      },
+    )
   }
 
   /**
    * {{> waitForElement }}
    */
   async waitForElement(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
 
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      return res && res.length;
-    }, { timeout: aSec * 1000, timeoutMsg: `element (${(new Locator(locator))}) still not present on page after ${aSec} sec` });
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(locator)
+        return res && res.length
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${new Locator(locator)}) still not present on page after ${aSec} sec`,
+      },
+    )
   }
 
   /**
    * {{> waitForClickable }}
    */
   async waitForClickable(locator, waitTimeout) {
-    waitTimeout = waitTimeout || this.options.waitForTimeoutInSeconds;
-    let res = await this._locate(locator);
-    res = usingFirstElement(res);
-    assertElementExists(res, locator);
+    waitTimeout = waitTimeout || this.options.waitForTimeoutInSeconds
+    let res = await this._locate(locator)
+    res = usingFirstElement(res)
+    assertElementExists(res, locator)
 
-    return res.waitForClickable({
-      timeout: waitTimeout * 1000,
-      timeoutMsg: `element ${res.selector} still not clickable after ${waitTimeout} sec`,
-    });
+    return res
+      .waitForClickable({
+        timeout: waitTimeout * 1000,
+        timeoutMsg: `element ${res.selector} still not clickable after ${waitTimeout} sec`,
+      })
+      .catch(e => {
+        throw wrapError(e)
+      })
   }
 
   /**
    * {{> waitInUrl }}
    */
   async waitInUrl(urlPart, sec = null) {
-    const client = this.browser;
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    let currUrl = '';
+    const client = this.browser
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    let currUrl = ''
 
     return client
-      .waitUntil(function () {
-        return this.getUrl().then((res) => {
-          currUrl = decodeUrl(res);
-          return currUrl.indexOf(urlPart) > -1;
-        });
-      }, { timeout: aSec * 1000 }).catch((e) => {
+      .waitUntil(
+        function () {
+          return this.getUrl().then(res => {
+            currUrl = decodeUrl(res)
+            return currUrl.indexOf(urlPart) > -1
+          })
+        },
+        { timeout: aSec * 1000 },
+      )
+      .catch(e => {
+        e = wrapError(e)
         if (e.message.indexOf('timeout')) {
-          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
+          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
         }
-        throw e;
-      });
+        throw e
+      })
   }
 
   /**
    * {{> waitUrlEquals }}
    */
   async waitUrlEquals(urlPart, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const baseUrl = this.options.url;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const baseUrl = this.options.url
     if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart;
-    }
-    let currUrl = '';
-    return this.browser.waitUntil(function () {
-      return this.getUrl().then((res) => {
-        currUrl = decodeUrl(res);
-        return currUrl === urlPart;
-      });
-    }, aSec * 1000).catch((e) => {
-      if (e.message.indexOf('timeout')) {
-        throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`);
-      }
-      throw e;
-    });
+      urlPart = baseUrl + urlPart
+    }
+    let currUrl = ''
+    return this.browser
+      .waitUntil(function () {
+        return this.getUrl().then(res => {
+          currUrl = decodeUrl(res)
+          return currUrl === urlPart
+        })
+      }, aSec * 1000)
+      .catch(e => {
+        e = wrapError(e)
+        if (e.message.indexOf('timeout')) {
+          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+        }
+        throw e
+      })
   }
 
   /**
@@ -2315,42 +2523,48 @@ class WebDriver extends Helper {
    *
    */
   async waitForText(text, sec = null, context = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const _context = context || this.root;
-
-    return this.browser.waitUntil(async () => {
-      const res = await this.$$(withStrictLocator.call(this, _context));
-      if (!res || res.length === 0) return false;
-      const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)));
-      if (Array.isArray(selected)) {
-        return selected.filter(part => part.indexOf(text) >= 0).length > 0;
-      }
-      return selected.indexOf(text) >= 0;
-    }, {
-      timeout: aSec * 1000,
-      timeoutMsg: `element (${_context}) is not in DOM or there is no element(${_context}) with text "${text}" after ${aSec} sec`,
-    });
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const _context = context || this.root
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this.$$(withStrictLocator.call(this, _context))
+        if (!res || res.length === 0) return false
+        const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)))
+        if (Array.isArray(selected)) {
+          return selected.filter(part => part.indexOf(text) >= 0).length > 0
+        }
+        return selected.indexOf(text) >= 0
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${_context}) is not in DOM or there is no element(${_context}) with text "${text}" after ${aSec} sec`,
+      },
+    )
   }
 
   /**
    * {{> waitForValue }}
    */
   async waitForValue(field, value, sec = null) {
-    const client = this.browser;
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-
-    return client.waitUntil(async () => {
-      const res = await findFields.call(this, field);
-      if (!res || res.length === 0) return false;
-      const selected = await forEachAsync(res, async el => el.getValue());
-      if (Array.isArray(selected)) {
-        return selected.filter(part => part.indexOf(value) >= 0).length > 0;
-      }
-      return selected.indexOf(value) >= 0;
-    }, {
-      timeout: aSec * 1000,
-      timeoutMsg: `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`,
-    });
+    const client = this.browser
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return client.waitUntil(
+      async () => {
+        const res = await findFields.call(this, field)
+        if (!res || res.length === 0) return false
+        const selected = await forEachAsync(res, async el => el.getValue())
+        if (Array.isArray(selected)) {
+          return selected.filter(part => part.indexOf(value) >= 0).length > 0
+        }
+        return selected.indexOf(value) >= 0
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`,
+      },
+    )
   }
 
   /**
@@ -2358,304 +2572,281 @@ class WebDriver extends Helper {
    *
    */
   async waitForVisible(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      if (!res || res.length === 0) return false;
-      const selected = await forEachAsync(res, async el => el.isDisplayed());
-      if (Array.isArray(selected)) {
-        return selected.filter(val => val === true).length > 0;
-      }
-      return selected;
-    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still not visible after ${aSec} sec` });
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(locator)
+        if (!res || res.length === 0) return false
+        const selected = await forEachAsync(res, async el => el.isDisplayed())
+        if (Array.isArray(selected)) {
+          return selected.filter(val => val === true).length > 0
+        }
+        return selected
+      },
+      {
+        timeout: aSec * 1000,
+        timeoutMsg: `element (${new Locator(locator)}) still not visible after ${aSec} sec`,
+      },
+    )
   }
 
   /**
    * {{> waitNumberOfVisibleElements }}
    */
   async waitNumberOfVisibleElements(locator, num, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      if (!res || res.length === 0) return false;
-      let selected = await forEachAsync(res, async el => el.isDisplayed());
-
-      if (!Array.isArray(selected)) selected = [selected];
-      selected = selected.filter(val => val === true);
-      return selected.length === num;
-    }, { timeout: aSec * 1000, timeoutMsg: `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec` });
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser
+      .waitUntil(
+        async () => {
+          const res = await this._res(locator)
+          if (!res || res.length === 0) return false
+          let selected = await forEachAsync(res, async el => el.isDisplayed())
+
+          if (!Array.isArray(selected)) selected = [selected]
+          selected = selected.filter(val => val === true)
+          return selected.length === num
+        },
+        {
+          timeout: aSec * 1000,
+          timeoutMsg: `The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec`,
+        },
+      )
+      .catch(e => {
+        throw wrapError(e)
+      })
   }
 
   /**
    * {{> waitForInvisible }}
    */
   async waitForInvisible(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      if (!res || res.length === 0) return true;
-      const selected = await forEachAsync(res, async el => el.isDisplayed());
-      return !selected.length;
-    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still visible after ${aSec} sec` });
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(locator)
+        if (!res || res.length === 0) return true
+        const selected = await forEachAsync(res, async el => el.isDisplayed())
+        return !selected.length
+      },
+      { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still visible after ${aSec} sec` },
+    )
   }
 
   /**
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec = null) {
-    return this.waitForInvisible(locator, sec);
+    return this.waitForInvisible(locator, sec)
   }
 
   /**
    * {{> waitForDetached }}
    */
   async waitForDetached(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
 
-    return this.browser.waitUntil(async () => {
-      const res = await this._res(locator);
-      if (!res || res.length === 0) {
-        return true;
-      }
-      return false;
-    }, { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still on page after ${aSec} sec` });
+    return this.browser.waitUntil(
+      async () => {
+        const res = await this._res(locator)
+        if (!res || res.length === 0) {
+          return true
+        }
+        return false
+      },
+      { timeout: aSec * 1000, timeoutMsg: `element (${new Locator(locator)}) still on page after ${aSec} sec` },
+    )
   }
 
   /**
    * {{> waitForFunction }}
    */
   async waitForFunction(fn, argsOrSec = null, sec = null) {
-    let args = [];
+    let args = []
     if (argsOrSec) {
       if (Array.isArray(argsOrSec)) {
-        args = argsOrSec;
+        args = argsOrSec
       } else if (typeof argsOrSec === 'number') {
-        sec = argsOrSec;
+        sec = argsOrSec
       }
     }
 
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
 
-    return this.browser.waitUntil(async () => this.browser.execute(fn, ...args), { timeout: aSec * 1000, timeoutMsg: '' });
+    return this.browser.waitUntil(async () => this.browser.execute(fn, ...args), {
+      timeout: aSec * 1000,
+      timeoutMsg: '',
+    })
   }
 
   /**
    * {{> waitForNumberOfTabs }}
    */
   async waitForNumberOfTabs(expectedTabs, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeoutInSeconds;
-    let currentTabs;
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeoutInSeconds
+    let currentTabs
+    let count = 0
 
     do {
-      currentTabs = await this.grabNumberOfOpenTabs();
-      await this.wait(1);
-      count += 1000;
-      if (currentTabs >= expectedTabs) return;
-    } while (count <= waitTimeout);
+      currentTabs = await this.grabNumberOfOpenTabs()
+      await this.wait(1)
+      count += 1000
+      if (currentTabs >= expectedTabs) return
+    } while (count <= waitTimeout)
 
-    throw new Error(`Expected ${expectedTabs} tabs are not met after ${waitTimeout / 1000} sec.`);
+    throw new Error(`Expected ${expectedTabs} tabs are not met after ${waitTimeout / 1000} sec.`)
   }
 
   /**
    * {{> switchTo }}
    */
   async switchTo(locator) {
-    this.browser.isInsideFrame = true;
-    if (Number.isInteger(locator)) {
-      if (this.options.automationProtocol) {
-        return this.browser.switchToFrame(locator + 1);
-      }
-      return this.browser.switchToFrame(locator);
-    }
+    this.browser.isInsideFrame = true
     if (!locator) {
-      return this.browser.switchToFrame(null);
+      return this.browser.switchFrame(null)
     }
 
-    let res = await this._locate(locator, true);
-    assertElementExists(res, locator);
-    res = usingFirstElement(res);
-    return this.browser.switchToFrame(res);
+    let res = await this._locate(locator, true)
+    assertElementExists(res, locator)
+    res = usingFirstElement(res)
+    return this.browser.switchFrame(res)
   }
 
   /**
    * {{> switchToNextTab }}
    */
   async switchToNextTab(num = 1, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    let target;
-    const current = await this.browser.getWindowHandle();
-
-    await this.browser.waitUntil(async () => {
-      await this.browser.getWindowHandles().then((handles) => {
-        if (handles.indexOf(current) + num + 1 <= handles.length) {
-          target = handles[handles.indexOf(current) + num];
-        }
-      });
-      return target;
-    }, { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to next tab with offset ${num}` });
-    return this.browser.switchToWindow(target);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    let target
+    const current = await this.browser.getWindowHandle()
+
+    await this.browser.waitUntil(
+      async () => {
+        await this.browser.getWindowHandles().then(handles => {
+          if (handles.indexOf(current) + num + 1 <= handles.length) {
+            target = handles[handles.indexOf(current) + num]
+          }
+        })
+        return target
+      },
+      { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to next tab with offset ${num}` },
+    )
+    return this.browser.switchToWindow(target)
   }
 
   /**
    * {{> switchToPreviousTab }}
    */
   async switchToPreviousTab(num = 1, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const current = await this.browser.getWindowHandle();
-    let target;
-
-    await this.browser.waitUntil(async () => {
-      await this.browser.getWindowHandles().then((handles) => {
-        if (handles.indexOf(current) - num > -1) {
-          target = handles[handles.indexOf(current) - num];
-        }
-      });
-      return target;
-    }, { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to previous tab with offset ${num}` });
-    return this.browser.switchToWindow(target);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const current = await this.browser.getWindowHandle()
+    let target
+
+    await this.browser.waitUntil(
+      async () => {
+        await this.browser.getWindowHandles().then(handles => {
+          if (handles.indexOf(current) - num > -1) {
+            target = handles[handles.indexOf(current) - num]
+          }
+        })
+        return target
+      },
+      { timeout: aSec * 1000, timeoutMsg: `There is no ability to switch to previous tab with offset ${num}` },
+    )
+    return this.browser.switchToWindow(target)
   }
 
   /**
    * {{> closeCurrentTab }}
    */
   async closeCurrentTab() {
-    await this.browser.closeWindow();
-    const handles = await this.browser.getWindowHandles();
-    if (handles[0]) await this.browser.switchToWindow(handles[0]);
+    await this.browser.closeWindow()
+    const handles = await this.browser.getWindowHandles()
+    if (handles[0]) await this.browser.switchToWindow(handles[0])
   }
 
   /**
    * {{> openNewTab }}
    */
   async openNewTab(url = 'about:blank', windowName = null) {
-    const client = this.browser;
-    const crypto = require('crypto');
+    const client = this.browser
     if (windowName == null) {
-      windowName = crypto.randomBytes(32).toString('hex');
+      windowName = crypto.randomBytes(32).toString('hex')
     }
-    return client.newWindow(url, windowName);
+    return client.newWindow(url, windowName)
   }
 
   /**
    * {{> grabNumberOfOpenTabs }}
    */
   async grabNumberOfOpenTabs() {
-    const pages = await this.browser.getWindowHandles();
-    this.debugSection('Tabs', `Total ${pages.length}`);
-    return pages.length;
+    const pages = await this.browser.getWindowHandles()
+    this.debugSection('Tabs', `Total ${pages.length}`)
+    return pages.length
   }
 
   /**
    * {{> refreshPage }}
    */
   async refreshPage() {
-    const client = this.browser;
-    return client.refresh();
+    const client = this.browser
+    return client.refresh()
   }
 
   /**
    * {{> scrollPageToTop }}
    */
   scrollPageToTop() {
-    const client = this.browser;
-    /* eslint-disable prefer-arrow-callback */
+    const client = this.browser
+
     return client.execute(function () {
-      window.scrollTo(0, 0);
-    });
-    /* eslint-enable */
+      window.scrollTo(0, 0)
+    })
   }
 
   /**
    * {{> scrollPageToBottom }}
    */
   scrollPageToBottom() {
-    const client = this.browser;
-    /* eslint-disable prefer-arrow-callback, comma-dangle */
+    const client = this.browser
+
     return client.execute(function () {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight
-      ));
-    });
-    /* eslint-enable */
+      const body = document.body
+      const html = document.documentElement
+      window.scrollTo(0, Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight))
+    })
   }
 
   /**
    * {{> grabPageScrollPosition }}
    */
   async grabPageScrollPosition() {
-    /* eslint-disable comma-dangle */
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
-    }
-    /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
-  }
-
-  /**
-   * This method is **deprecated**.
-   *
-   *
-   * {{> setGeoLocation }}
-   */
-  async setGeoLocation(latitude, longitude) {
-    if (!this.options.automationProtocol) {
-      console.log(`setGeoLocation deprecated:
-    * This command is deprecated due to using deprecated JSON Wire Protocol command. More info: https://webdriver.io/docs/api/jsonwp/#setgeolocation
-    * Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration`);
-      return;
+        y: window.pageYOffset,
+      }
     }
-    this.geoLocation = { latitude, longitude };
 
-    await this.browser.call(async () => {
-      const pages = await this.puppeteerBrowser.pages();
-      await pages[0].setGeolocation({ latitude, longitude });
-    });
-  }
-
-  /**
-   * This method is **deprecated**.
-   *
-   * {{> grabGeoLocation }}
-   *
-   */
-  async grabGeoLocation() {
-    if (!this.options.automationProtocol) {
-      console.log(`grabGeoLocation deprecated:
-    * This command is deprecated due to using deprecated JSON Wire Protocol command. More info: https://webdriver.io/docs/api/jsonwp/#getgeolocation
-    * Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration`);
-      return;
-    }
-    if (!this.geoLocation) return 'No GeoLocation is set!';
-    return this.geoLocation;
+    return this.executeScript(getScrollPosition)
   }
 
   /**
    * {{> grabElementBoundingRect }}
    */
   async grabElementBoundingRect(locator, prop) {
-    const res = await this._locate(locator, true);
-    assertElementExists(res, locator);
-    const el = usingFirstElement(res);
+    const res = await this._locate(locator, true)
+    assertElementExists(res, locator)
+    const el = usingFirstElement(res)
 
     const rect = {
       ...(await el.getLocation()),
       ...(await el.getSize()),
-    };
-    if (prop) return rect[prop];
-    return rect;
+    }
+    if (prop) return rect[prop]
+    return rect
   }
 
   /**
@@ -2663,164 +2854,56 @@ class WebDriver extends Helper {
    * @param {*} caps
    * @param {*} fn
    */
-  /* eslint-disable */
-  runOnIOS(caps, fn) {
-  }
+
+  runOnIOS(caps, fn) {}
 
   /**
    * Placeholder for ~ locator only test case write once run on both Appium and WebDriver.
    * @param {*} caps
    * @param {*} fn
    */
-  runOnAndroid(caps, fn) {
-  }
-  /* eslint-enable */
+  runOnAndroid(caps, fn) {}
 
   /**
    * Placeholder for ~ locator only test case write once run on both Appium and WebDriver.
    */
-  runInWeb(fn) {
-    return fn();
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> flushNetworkTraffics }}
-   */
-  flushNetworkTraffics() {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    this.requests = [];
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> stopRecordingTraffic }}
-   */
-  stopRecordingTraffic() {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    this.page.removeAllListeners('request');
-    this.recording = false;
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> startRecordingTraffic }}
-   *
-   */
-  async startRecordingTraffic() {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    this.flushNetworkTraffics();
-    this.recording = true;
-    this.recordedAtLeastOnce = true;
-
-    this.page = (await this.puppeteerBrowser.pages())[0];
-    await this.page.setRequestInterception(true);
-
-    this.page.on('request', (request) => {
-      const information = {
-        url: request.url(),
-        method: request.method(),
-        requestHeaders: request.headers(),
-        requestPostData: request.postData(),
-        response: request.response(),
-      };
-
-      this.debugSection('REQUEST: ', JSON.stringify(information));
-
-      if (typeof information.requestPostData === 'object') {
-        information.requestPostData = JSON.parse(information.requestPostData);
-      }
-      request.continue();
-      this.requests.push(information);
-    });
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> grabRecordedNetworkTraffics }}
-   */
-  async grabRecordedNetworkTraffics() {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    return grabRecordedNetworkTraffics.call(this);
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> seeTraffic }}
-   */
-  async seeTraffic({
-    name, url, parameters, requestPostData, timeout = 10,
-  }) {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    await seeTraffic.call(this, ...arguments);
-  }
-
-  /**
-   *
-   * _Note:_ Only works when devtoolsProtocol is enabled.
-   *
-   * {{> dontSeeTraffic }}
-   *
-   */
-  dontSeeTraffic({ name, url }) {
-    if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
-    }
-    dontSeeTraffic.call(this, ...arguments);
+  async runInWeb(fn) {
+    return fn()
   }
 }
 
 async function proceedSee(assertType, text, context, strict = false) {
-  let description;
+  let description
   if (!context) {
     if (this.context === webRoot) {
-      context = this.context;
-      description = 'web page';
+      context = this.context
+      description = 'web page'
     } else {
-      description = `current context ${this.context}`;
-      context = './/*';
+      description = `current context ${this.context}`
+      context = './/*'
     }
   } else {
-    description = `element ${context}`;
+    description = `element ${context}`
+  }
+
+  const smartWaitEnabled = assertType === 'assert'
+  const res = await this._locate(withStrictLocator(context), smartWaitEnabled)
+  assertElementExists(res, context)
+  let selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)))
+
+  // apply ignoreCase option
+  if (store?.currentStep?.opts?.ignoreCase === true) {
+    text = text.toLowerCase()
+    selected = selected.map(elText => elText.toLowerCase())
   }
 
-  const smartWaitEnabled = assertType === 'assert';
-  const res = await this._locate(withStrictLocator(context), smartWaitEnabled);
-  assertElementExists(res, context);
-  const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)));
   if (strict) {
     if (Array.isArray(selected) && selected.length !== 0) {
-      return selected.map(elText => equals(description)[assertType](text, elText));
+      return selected.map(elText => equals(description)[assertType](text, elText))
     }
-    return equals(description)[assertType](text, selected);
+    return equals(description)[assertType](text, selected)
   }
-  return stringIncludes(description)[assertType](text, selected);
+  return stringIncludes(description)[assertType](text, selected)
 }
 
 /**
@@ -2837,21 +2920,19 @@ async function proceedSee(assertType, text, context, strict = false) {
  * @return {Promise<Array>} - Array of values.
  */
 async function forEachAsync(array, callback, options = { expandArrayResults: true }) {
-  const {
-    expandArrayResults = true,
-  } = options;
-  const inputArray = Array.isArray(array) ? array : [array];
-  const values = [];
+  const { expandArrayResults = true } = options
+  const inputArray = Array.isArray(array) ? array : [array]
+  const values = []
   for (let index = 0; index < inputArray.length; index++) {
-    const res = await callback(inputArray[index], index, inputArray);
+    const res = await callback(inputArray[index], index, inputArray)
 
     if (Array.isArray(res) && expandArrayResults) {
-      res.forEach(val => values.push(val));
+      res.forEach(val => values.push(val))
     } else if (res) {
-      values.push(res);
+      values.push(res)
     }
   }
-  return values;
+  return values
 }
 
 /**
@@ -2866,374 +2947,433 @@ async function forEachAsync(array, callback, options = { expandArrayResults: tru
  * @return {Promise<Array>} - Array of values.
  */
 async function filterAsync(array, callback) {
-  const inputArray = Array.isArray(array) ? array : [array];
-  const values = [];
+  const inputArray = Array.isArray(array) ? array : [array]
+  const values = []
   for (let index = 0; index < inputArray.length; index++) {
-    const res = await callback(inputArray[index], index, inputArray);
-    const value = Array.isArray(res) ? res[0] : res;
+    const res = await callback(inputArray[index], index, inputArray)
+    const value = Array.isArray(res) ? res[0] : res
 
     if (value) {
-      values.push(inputArray[index]);
+      values.push(inputArray[index])
     }
   }
-  return values;
+  return values
 }
 
 async function findClickable(locator, locateFn) {
-  locator = new Locator(locator);
+  locator = new Locator(locator)
 
   if (this._isCustomLocator(locator)) {
-    return locateFn(locator.value);
+    return locateFn(locator.value)
   }
 
-  if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true);
-  if (!locator.isFuzzy()) return locateFn(locator, true);
+  if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true)
+  if (locator.isRole()) return locateFn(locator, true)
+  if (!locator.isFuzzy()) return locateFn(locator, true)
+
+  let els
+  const literal = xpathLocator.literal(locator.value)
 
-  let els;
-  const literal = xpathLocator.literal(locator.value);
+  els = await locateFn(Locator.clickable.narrow(literal))
+  if (els.length) return els
 
-  els = await locateFn(Locator.clickable.narrow(literal));
-  if (els.length) return els;
+  // Try ARIA selector for accessible name
+  try {
+    els = await locateFn(`aria/${locator.value}`)
+    if (els.length) return els
+  } catch (e) {
+    // ARIA selector not supported or failed
+  }
 
-  els = await locateFn(Locator.clickable.wide(literal));
-  if (els.length) return els;
+  els = await locateFn(Locator.clickable.wide(literal))
+  if (els.length) return els
 
-  els = await locateFn(Locator.clickable.self(literal));
-  if (els.length) return els;
+  els = await locateFn(Locator.clickable.self(literal))
+  if (els.length) return els
 
-  return locateFn(locator.value); // by css or xpath
+  return await locateFn(locator.value) // by css or xpath
 }
 
 async function findFields(locator) {
-  locator = new Locator(locator);
+  locator = new Locator(locator)
 
   if (this._isCustomLocator(locator)) {
-    return this._locate(locator);
+    return this._locate(locator)
   }
 
-  if (locator.isAccessibilityId() && !this.isWeb) return this._locate(locator, true);
-  if (!locator.isFuzzy()) return this._locate(locator, true);
+  if (locator.isAccessibilityId() && !this.isWeb) return this._locate(locator, true)
+  if (locator.isRole()) return this._locate(locator, true)
+  if (!locator.isFuzzy()) return this._locate(locator, true)
+
+  const literal = xpathLocator.literal(locator.value)
+  let els = await this._locate(Locator.field.labelEquals(literal))
+  if (els.length) return els
 
-  const literal = xpathLocator.literal(locator.value);
-  let els = await this._locate(Locator.field.labelEquals(literal));
-  if (els.length) return els;
+  els = await this._locate(Locator.field.labelContains(literal))
+  if (els.length) return els
 
-  els = await this._locate(Locator.field.labelContains(literal));
-  if (els.length) return els;
+  els = await this._locate(Locator.field.byName(literal))
+  if (els.length) return els
 
-  els = await this._locate(Locator.field.byName(literal));
-  if (els.length) return els;
-  return this._locate(locator.value); // by css or xpath
+  return await this._locate(locator.value) // by css or xpath
 }
 
 async function proceedSeeField(assertType, field, value) {
-  const res = await findFields.call(this, field);
-  assertElementExists(res, field, 'Field');
-  const elem = usingFirstElement(res);
-  const elemId = getElementId(elem);
-
-  const proceedMultiple = async (fields) => {
-    const fieldResults = toArray(await forEachAsync(fields, async (el) => {
-      const elementId = getElementId(el);
-      return this.browser.isW3C ? el.getValue() : this.browser.getElementAttribute(elementId, 'value');
-    }));
+  const res = await findFields.call(this, field)
+  assertElementExists(res, field, 'Field')
+  const elem = usingFirstElement(res)
+  const elemId = getElementId(elem)
+
+  const proceedMultiple = async fields => {
+    const fieldResults = toArray(
+      await forEachAsync(fields, async el => {
+        const elementId = getElementId(el)
+        return this.browser.getElementAttribute(elementId, 'value')
+      }),
+    )
 
     if (typeof value === 'boolean') {
-      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!fieldResults.length);
+      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!fieldResults.length)
     } else {
       // Assert that results were found so the forEach assert does not silently pass
-      equals(`no. of items matching > 0:  ${field}`)[assertType](true, !!fieldResults.length);
-      fieldResults.forEach(val => stringIncludes(`fields by ${field}`)[assertType](value, val));
+      equals(`no. of items matching > 0:  ${field}`)[assertType](true, !!fieldResults.length)
+      fieldResults.forEach(val => stringIncludes(`fields by ${field}`)[assertType](value, val))
     }
-  };
+  }
+
+  const proceedSingle = async el => {
+    let res = await el.getValue()
 
-  const proceedSingle = el => el.getValue().then((res) => {
     if (res === null) {
-      throw new Error(`Element ${el.selector} has no value attribute`);
+      res = await el.getText()
+    }
+
+    if (res === null || res === undefined) {
+      throw new Error(`Element ${el.selector} has no value attribute`)
     }
-    stringIncludes(`fields by ${field}`)[assertType](value, res);
-  });
 
-  const filterBySelected = async elements => filterAsync(elements, async el => this.browser.isElementSelected(getElementId(el)));
+    stringIncludes(`fields by ${field}`)[assertType](value, res)
+  }
+
+  const filterBySelected = async elements => filterAsync(elements, async el => this.browser.isElementSelected(getElementId(el)))
 
   const filterSelectedByValue = async (elements, value) => {
-    return filterAsync(elements, async (el) => {
-      const elementId = getElementId(el);
-      const currentValue = this.browser.isW3C ? await el.getValue() : await this.browser.getElementAttribute(elementId, 'value');
-      const isSelected = await this.browser.isElementSelected(elementId);
-      return currentValue === value && isSelected;
-    });
-  };
-
-  const tag = await elem.getTagName();
+    return filterAsync(elements, async el => {
+      const elementId = getElementId(el)
+      const currentValue = await this.browser.getElementAttribute(elementId, 'value')
+      const isSelected = await this.browser.isElementSelected(elementId)
+      return currentValue === value && isSelected
+    })
+  }
+
+  const tag = await elem.getTagName()
   if (tag === 'select') {
-    const subOptions = await this.browser.findElementsFromElement(elemId, 'css', 'option');
+    let subOptions
+
+    try {
+      subOptions = await this.browser.findElementsFromElement(elemId, 'css', 'option')
+    } catch (e) {
+      subOptions = await this.browser.findElementsFromElement(elemId, 'xpath', 'option')
+    }
 
     if (value === '') {
       // Don't filter by value
-      const selectedOptions = await filterBySelected(subOptions);
-      return proceedMultiple(selectedOptions);
+      const selectedOptions = await filterBySelected(subOptions)
+      return proceedMultiple(selectedOptions)
     }
 
-    const options = await filterSelectedByValue(subOptions, value);
-    return proceedMultiple(options);
+    const options = await filterSelectedByValue(subOptions, value)
+    return proceedMultiple(options)
   }
 
   if (tag === 'input') {
-    const fieldType = await elem.getAttribute('type');
+    const fieldType = await elem.getAttribute('type')
 
     if (fieldType === 'checkbox' || fieldType === 'radio') {
       if (typeof value === 'boolean') {
         // Support boolean values
-        const options = await filterBySelected(res);
-        return proceedMultiple(options);
+        const options = await filterBySelected(res)
+        return proceedMultiple(options)
       }
 
-      const options = await filterSelectedByValue(res, value);
-      return proceedMultiple(options);
+      const options = await filterSelectedByValue(res, value)
+      return proceedMultiple(options)
     }
-    return proceedSingle(elem);
+    return proceedSingle(elem)
   }
-  return proceedSingle(elem);
+  return proceedSingle(elem)
 }
 
 function toArray(item) {
   if (!Array.isArray(item)) {
-    return [item];
+    return [item]
   }
-  return item;
+  return item
 }
 
 async function proceedSeeCheckbox(assertType, field) {
-  const res = await findFields.call(this, field);
-  assertElementExists(res, field, 'Field');
+  const res = await findFields.call(this, field)
+  assertElementExists(res, field, 'Field')
+
+  const selected = await forEachAsync(res, async el => {
+    const elementId = getElementId(el)
+    return isElementChecked(this.browser, elementId)
+  })
+
+  return truth(`checkable field "${field}"`, 'to be checked')[assertType](selected)
+}
+
+async function getElementTextAttributes(element) {
+  const elementId = getElementId(element)
+  const ariaLabel = await this.browser.getElementAttribute(elementId, 'aria-label').catch(() => '')
+  const placeholder = await this.browser.getElementAttribute(elementId, 'placeholder').catch(() => '')
+  const innerText = await this.browser.getElementText(elementId).catch(() => '')
+  return [ariaLabel, placeholder, innerText]
+}
 
-  const selected = await forEachAsync(res, async el => this.browser.isElementSelected(getElementId(el)));
-  return truth(`checkable field "${field}"`, 'to be checked')[assertType](selected);
+async function isElementChecked(browser, elementId) {
+  let isChecked = await browser.isElementSelected(elementId)
+  if (!isChecked) {
+    const ariaChecked = await browser.getElementAttribute(elementId, 'aria-checked')
+    isChecked = ariaChecked === 'true'
+  }
+  return isChecked
 }
 
 async function findCheckable(locator, locateFn) {
-  let els;
-  locator = new Locator(locator);
+  let els
+  locator = new Locator(locator)
 
   if (this._isCustomLocator(locator)) {
-    return locateFn(locator.value);
+    return locateFn(locator.value)
   }
 
-  if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true);
-  if (!locator.isFuzzy()) return locateFn(locator, true);
+  if (locator.isAccessibilityId() && !this.isWeb) return locateFn(locator, true)
+  if (locator.isRole()) return locateFn(locator, true)
+  if (!locator.isFuzzy()) return locateFn(locator, true)
+
+  const literal = xpathLocator.literal(locator.value)
+  els = await locateFn(Locator.checkable.byText(literal))
+  if (els.length) return els
+
+  // Try ARIA selector for accessible name
+  try {
+    els = await locateFn(`aria/${locator.value}`)
+    if (els.length) return els
+  } catch (e) {
+    // ARIA selector not supported or failed
+  }
 
-  const literal = xpathLocator.literal(locator.value);
-  els = await locateFn(Locator.checkable.byText(literal));
-  if (els.length) return els;
-  els = await locateFn(Locator.checkable.byName(literal));
-  if (els.length) return els;
+  els = await locateFn(Locator.checkable.byName(literal))
+  if (els.length) return els
 
-  return locateFn(locator.value); // by css or xpath
+  return await locateFn(locator.value) // by css or xpath
 }
 
 function withStrictLocator(locator) {
-  locator = new Locator(locator);
-  return locator.simplify();
+  locator = new Locator(locator)
+  return locator.simplify()
 }
 
 function isFrameLocator(locator) {
-  locator = new Locator(locator);
-  if (locator.isFrame()) return locator.value;
-  return false;
+  locator = new Locator(locator)
+  if (locator.isFrame()) return locator.value
+  return false
 }
 
 function assertElementExists(res, locator, prefix, suffix) {
   if (!res || res.length === 0) {
-    throw new ElementNotFound(locator, prefix, suffix);
+    throw new ElementNotFound(locator, prefix, suffix)
   }
 }
 
 function usingFirstElement(els) {
-  if (els.length > 1) debug(`[Elements] Using first element out of ${els.length}`);
-  return els[0];
+  if (els.length > 1) debug(`[Elements] Using first element out of ${els.length}`)
+  return els[0]
 }
 
 function getElementId(el) {
   // W3C WebDriver web element identifier
   // https://w3c.github.io/webdriver/#dfn-web-element-identifier
   if (el['element-6066-11e4-a52e-4f735466cecf']) {
-    return el['element-6066-11e4-a52e-4f735466cecf'];
+    return el['element-6066-11e4-a52e-4f735466cecf']
   }
   // (deprecated) JsonWireProtocol identifier
   // https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol#webelement-json-object
   if (el.ELEMENT) {
-    return el.ELEMENT;
+    return el.ELEMENT
   }
 
-  return null;
+  return null
 }
 
 // List of known key values to unicode code points
 // https://www.w3.org/TR/webdriver/#keyboard-actions
 const keyUnicodeMap = {
-  /* eslint-disable quote-props */
-  'Unidentified': '\uE000',
-  'Cancel': '\uE001',
-  'Clear': '\uE005',
-  'Help': '\uE002',
-  'Pause': '\uE00B',
-  'Backspace': '\uE003',
-  'Return': '\uE006',
-  'Enter': '\uE007',
-  'Escape': '\uE00C',
-  'Alt': '\uE00A',
-  'AltLeft': '\uE00A',
-  'AltRight': '\uE052',
-  'Control': '\uE009',
-  'ControlLeft': '\uE009',
-  'ControlRight': '\uE051',
-  'Meta': '\uE03D',
-  'MetaLeft': '\uE03D',
-  'MetaRight': '\uE053',
-  'Shift': '\uE008',
-  'ShiftLeft': '\uE008',
-  'ShiftRight': '\uE050',
-  'Space': '\uE00D',
+  Unidentified: '\uE000',
+  Cancel: '\uE001',
+  Clear: '\uE005',
+  Help: '\uE002',
+  Pause: '\uE00B',
+  Backspace: '\uE003',
+  Return: '\uE006',
+  Enter: '\uE007',
+  Escape: '\uE00C',
+  Alt: '\uE00A',
+  AltLeft: '\uE00A',
+  AltRight: '\uE052',
+  Control: '\uE009',
+  ControlLeft: '\uE009',
+  ControlRight: '\uE051',
+  Meta: '\uE03D',
+  MetaLeft: '\uE03D',
+  MetaRight: '\uE053',
+  Shift: '\uE008',
+  ShiftLeft: '\uE008',
+  ShiftRight: '\uE050',
+  Space: '\uE00D',
   ' ': '\uE00D',
-  'Tab': '\uE004',
-  'Insert': '\uE016',
-  'Delete': '\uE017',
-  'End': '\uE010',
-  'Home': '\uE011',
-  'PageUp': '\uE00E',
-  'PageDown': '\uE00F',
-  'ArrowDown': '\uE015',
-  'ArrowLeft': '\uE012',
-  'ArrowRight': '\uE014',
-  'ArrowUp': '\uE013',
-  'F1': '\uE031',
-  'F2': '\uE032',
-  'F3': '\uE033',
-  'F4': '\uE034',
-  'F5': '\uE035',
-  'F6': '\uE036',
-  'F7': '\uE037',
-  'F8': '\uE038',
-  'F9': '\uE039',
-  'F10': '\uE03A',
-  'F11': '\uE03B',
-  'F12': '\uE03C',
-  'Numpad0': '\uE01A',
-  'Numpad1': '\uE01B',
-  'Numpad2': '\uE01C',
-  'Numpad3': '\uE01D',
-  'Numpad4': '\uE01E',
-  'Numpad5': '\uE01F',
-  'Numpad6': '\uE020',
-  'Numpad7': '\uE021',
-  'Numpad8': '\uE022',
-  'Numpad9': '\uE023',
-  'NumpadMultiply': '\uE024',
-  'NumpadAdd': '\uE025',
-  'NumpadSubtract': '\uE027',
-  'NumpadDecimal': '\uE028',
-  'NumpadDivide': '\uE029',
-  'NumpadEnter': '\uE007',
-  'NumpadInsert': '\uE05C', // 'Numpad0' alternate (when NumLock off)
-  'NumpadDelete': '\uE05D', // 'NumpadDecimal' alternate (when NumLock off)
-  'NumpadEnd': '\uE056', // 'Numpad1' alternate (when NumLock off)
-  'NumpadHome': '\uE057', // 'Numpad7' alternate (when NumLock off)
-  'NumpadPageDown': '\uE055', // 'Numpad3' alternate (when NumLock off)
-  'NumpadPageUp': '\uE054', // 'Numpad9' alternate (when NumLock off)
-  'NumpadArrowDown': '\uE05B', // 'Numpad2' alternate (when NumLock off)
-  'NumpadArrowLeft': '\uE058', // 'Numpad4' alternate (when NumLock off)
-  'NumpadArrowRight': '\uE05A', // 'Numpad6' alternate (when NumLock off)
-  'NumpadArrowUp': '\uE059', // 'Numpad8' alternate (when NumLock off)
-  'Comma': '\uE026', // ',' alias
-  'Digit0': '0', // '0' alias
-  'Digit1': '1', // '1' alias
-  'Digit2': '2', // '2' alias
-  'Digit3': '3', // '3' alias
-  'Digit4': '4', // '4' alias
-  'Digit5': '5', // '5' alias
-  'Digit6': '6', // '6' alias
-  'Digit7': '7', // '7' alias
-  'Digit8': '8', // '8' alias
-  'Digit9': '9', // '9' alias
-  'Equal': '\uE019', // '=' alias
-  'KeyA': 'a', // 'a' alias
-  'KeyB': 'b', // 'b' alias
-  'KeyC': 'c', // 'c' alias
-  'KeyD': 'd', // 'd' alias
-  'KeyE': 'e', // 'e' alias
-  'KeyF': 'f', // 'f' alias
-  'KeyG': 'g', // 'g' alias
-  'KeyH': 'h', // 'h' alias
-  'KeyI': 'i', // 'i' alias
-  'KeyJ': 'j', // 'j' alias
-  'KeyK': 'k', // 'k' alias
-  'KeyL': 'l', // 'l' alias
-  'KeyM': 'm', // 'm' alias
-  'KeyN': 'n', // 'n' alias
-  'KeyO': 'o', // 'o' alias
-  'KeyP': 'p', // 'p' alias
-  'KeyQ': 'q', // 'q' alias
-  'KeyR': 'r', // 'r' alias
-  'KeyS': 's', // 's' alias
-  'KeyT': 't', // 't' alias
-  'KeyU': 'u', // 'u' alias
-  'KeyV': 'v', // 'v' alias
-  'KeyW': 'w', // 'w' alias
-  'KeyX': 'x', // 'x' alias
-  'KeyY': 'y', // 'y' alias
-  'KeyZ': 'z', // 'z' alias
-  'Period': '.', // '.' alias
-  'Semicolon': '\uE018', // ';' alias
-  'Slash': '/', // '/' alias
-  'ZenkakuHankaku': '\uE040',
-  /* eslint-enable quote-props */
-};
+  Tab: '\uE004',
+  Insert: '\uE016',
+  Delete: '\uE017',
+  End: '\uE010',
+  Home: '\uE011',
+  PageUp: '\uE00E',
+  PageDown: '\uE00F',
+  ArrowDown: '\uE015',
+  ArrowLeft: '\uE012',
+  ArrowRight: '\uE014',
+  ArrowUp: '\uE013',
+  F1: '\uE031',
+  F2: '\uE032',
+  F3: '\uE033',
+  F4: '\uE034',
+  F5: '\uE035',
+  F6: '\uE036',
+  F7: '\uE037',
+  F8: '\uE038',
+  F9: '\uE039',
+  F10: '\uE03A',
+  F11: '\uE03B',
+  F12: '\uE03C',
+  Numpad0: '\uE01A',
+  Numpad1: '\uE01B',
+  Numpad2: '\uE01C',
+  Numpad3: '\uE01D',
+  Numpad4: '\uE01E',
+  Numpad5: '\uE01F',
+  Numpad6: '\uE020',
+  Numpad7: '\uE021',
+  Numpad8: '\uE022',
+  Numpad9: '\uE023',
+  NumpadMultiply: '\uE024',
+  NumpadAdd: '\uE025',
+  NumpadSubtract: '\uE027',
+  NumpadDecimal: '\uE028',
+  NumpadDivide: '\uE029',
+  NumpadEnter: '\uE007',
+  NumpadInsert: '\uE05C', // 'Numpad0' alternate (when NumLock off)
+  NumpadDelete: '\uE05D', // 'NumpadDecimal' alternate (when NumLock off)
+  NumpadEnd: '\uE056', // 'Numpad1' alternate (when NumLock off)
+  NumpadHome: '\uE057', // 'Numpad7' alternate (when NumLock off)
+  NumpadPageDown: '\uE055', // 'Numpad3' alternate (when NumLock off)
+  NumpadPageUp: '\uE054', // 'Numpad9' alternate (when NumLock off)
+  NumpadArrowDown: '\uE05B', // 'Numpad2' alternate (when NumLock off)
+  NumpadArrowLeft: '\uE058', // 'Numpad4' alternate (when NumLock off)
+  NumpadArrowRight: '\uE05A', // 'Numpad6' alternate (when NumLock off)
+  NumpadArrowUp: '\uE059', // 'Numpad8' alternate (when NumLock off)
+  Comma: '\uE026', // ',' alias
+  Digit0: '0', // '0' alias
+  Digit1: '1', // '1' alias
+  Digit2: '2', // '2' alias
+  Digit3: '3', // '3' alias
+  Digit4: '4', // '4' alias
+  Digit5: '5', // '5' alias
+  Digit6: '6', // '6' alias
+  Digit7: '7', // '7' alias
+  Digit8: '8', // '8' alias
+  Digit9: '9', // '9' alias
+  Equal: '\uE019', // '=' alias
+  KeyA: 'a', // 'a' alias
+  KeyB: 'b', // 'b' alias
+  KeyC: 'c', // 'c' alias
+  KeyD: 'd', // 'd' alias
+  KeyE: 'e', // 'e' alias
+  KeyF: 'f', // 'f' alias
+  KeyG: 'g', // 'g' alias
+  KeyH: 'h', // 'h' alias
+  KeyI: 'i', // 'i' alias
+  KeyJ: 'j', // 'j' alias
+  KeyK: 'k', // 'k' alias
+  KeyL: 'l', // 'l' alias
+  KeyM: 'm', // 'm' alias
+  KeyN: 'n', // 'n' alias
+  KeyO: 'o', // 'o' alias
+  KeyP: 'p', // 'p' alias
+  KeyQ: 'q', // 'q' alias
+  KeyR: 'r', // 'r' alias
+  KeyS: 's', // 's' alias
+  KeyT: 't', // 't' alias
+  KeyU: 'u', // 'u' alias
+  KeyV: 'v', // 'v' alias
+  KeyW: 'w', // 'w' alias
+  KeyX: 'x', // 'x' alias
+  KeyY: 'y', // 'y' alias
+  KeyZ: 'z', // 'z' alias
+  Period: '.', // '.' alias
+  Semicolon: '\uE018', // ';' alias
+  Slash: '/', // '/' alias
+  ZenkakuHankaku: '\uE040',
+}
 
 function convertKeyToRawKey(key) {
   if (Object.prototype.hasOwnProperty.call(keyUnicodeMap, key)) {
-    return keyUnicodeMap[key];
+    return keyUnicodeMap[key]
   }
   // Key is raw key when no representative unicode code point for value
-  return key;
+  return key
 }
 
 function getNormalizedKey(key) {
-  let normalizedKey = getNormalizedKeyAttributeValue(key);
+  let normalizedKey = getNormalizedKeyAttributeValue(key)
   // Always use "left" modifier keys for non-W3C sessions,
   // as JsonWireProtocol does not support "right" modifier keys
   if (!this.browser.isW3C) {
-    normalizedKey = normalizedKey.replace(/^(Alt|Control|Meta|Shift)Right$/, '$1');
+    normalizedKey = normalizedKey.replace(/^(Alt|Control|Meta|Shift)Right$/, '$1')
   }
   if (key !== normalizedKey) {
-    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`);
+    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`)
   }
-  return convertKeyToRawKey(normalizedKey);
+  return convertKeyToRawKey(normalizedKey)
 }
 
-const unicodeModifierKeys = modifierKeys.map(k => convertKeyToRawKey(k));
+const unicodeModifierKeys = modifierKeys.map(k => convertKeyToRawKey(k))
 function isModifierKey(key) {
-  return unicodeModifierKeys.includes(key);
+  return unicodeModifierKeys.includes(key)
 }
 
 function highlightActiveElement(element) {
   if (this.options.highlightElement && global.debugMode) {
-    highlightElement(element, this.browser);
+    highlightElement(element, this.browser)
   }
 }
 
 function prepareLocateFn(context) {
-  if (!context) return this._locate.bind(this);
-  return (l) => {
-    l = new Locator(l, 'css');
-    return this._locate(context, true).then(async (res) => {
-      assertElementExists(res, context, 'Context element');
+  if (!context) return this._locate.bind(this)
+  return l => {
+    l = new Locator(l, 'css')
+    return this._locate(context, true).then(async res => {
+      assertElementExists(res, context, 'Context element')
       if (l.react) {
-        return res[0].react$$(l.react, l.props || undefined);
+        return res[0].react$$(l.react, l.props || undefined)
       }
-      return res[0].$$(l.simplify());
-    });
-  };
+      return res[0].$$(l.simplify())
+    })
+  }
+}
+
+function logEvents(event) {
+  browserLogs.push(event.text) // add log message to the array
 }
 
-export default WebDriver;
+export { WebDriver as default }