diff --git a/.eslintrc.js b/.eslintrc.js
index 8b8c9405f..b38236895 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -43,6 +43,21 @@ module.exports = {
     'no-loop-func': 0,
     'arrow-parens': 0,
     'default-param-last': 0,
+    semi: 0,
+    'operator-linebreak': 0,
+    'nonblock-statement-body-position': 0,
+    curly: 0,
+    'implicit-arrow-linebreak': 0,
+    indent: 0,
+    'object-curly-newline': 0,
+    'semi-style': 0,
+    'function-paren-newline': 0,
+    'prefer-template': 0,
+    'newline-per-chained-call': 0,
+    'prefer-arrow-callback': 0,
+    'no-bitwise': 0,
+    'prefer-const': 0,
+    'no-extra-semi': 0,
   },
   ignorePatterns: ['test/data/output', 'lib/css2xpath/*'],
 };
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 35aaaf72b..4dfcda903 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -17,7 +17,7 @@ jobs:
       - name: Check out the repo with latest code
         uses: actions/checkout@v4
       - name: Push latest to Docker Hub
-        uses: docker/build-push-action@v4 # Info: https://github.com/docker/build-push-action/tree/releases/v1#tags
+        uses: docker/build-push-action@v6 # Info: https://github.com/docker/build-push-action/tree/releases/v1#tags
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -36,7 +36,7 @@ jobs:
           ref: ${{ env.TAG }}
 
       - name: Push current tag to Docker Hub
-        uses: docker/build-push-action@v1 # Info: https://github.com/docker/build-push-action/tree/releases/v1#tags
+        uses: docker/build-push-action@v6 # Info: https://github.com/docker/build-push-action/tree/releases/v1#tags
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
diff --git a/.husky/pre-commit b/.husky/pre-commit
index 1eda87251..635d81b70 100755
--- a/.husky/pre-commit
+++ b/.husky/pre-commit
@@ -1,4 +1,4 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-npm run lint && npm run dtslint
+npm run prettier && npm run lint && npm run dtslint
diff --git a/.semaphore/semaphore.yml b/.semaphore/semaphore.yml
deleted file mode 100644
index 7b7bafd6b..000000000
--- a/.semaphore/semaphore.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-version: v1.0
-name: Initial Pipeline
-agent:
-  machine:
-    type: e1-standard-2
-    os_image: ubuntu1804
-blocks:
-  - name: Appium tests
-    task:
-      secrets:
-        - name: saucelabs
-      prologue:
-        commands:
-          - checkout
-          - npm i
-          - cache restore
-      jobs:
-        - name: Quick tests
-          commands:
-            - 'npm run test:appium-quick'
-        - name: Other Tests
-          commands:
-            - 'npm run test:appium-other'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d1e748b2..7767540bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,35 @@
+## 3.6.5
+
+❤️ Thanks all to those who contributed to make this release! ❤️
+
+🛩️ *Features*
+* feat(helper): playwright > wait for disabled (#4412) - by @kobenguyent
+```
+it('should wait for input text field to be disabled', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled('#text', 1)))
+
+    it('should wait for input text field to be enabled by xpath', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled("//*[@name = 'test']", 1)))
+
+    it('should wait for a button to be disabled', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled('#text', 1)))
+
+Waits for element to become disabled (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional) time in seconds to wait, 1 by default.
+@returns {void} automatically synchronized promise through #recorder
+```
+
+🐛 *Bug Fixes*
+* fix(AI): AI is not triggered (#4422) - by @kobenguyent
+* fix(plugin): stepByStep > report doesn't sync properly (#4413) - by @kobenguyent
+* fix: Locator > Unsupported pseudo selector 'has' (#4448) - by @anils92
+
+📖 *Documentation*
+* docs: setup azure open ai using bearer token (#4434) - by @kobenguyent
+
 ## 3.6.4
 
 ❤️ Thanks all to those who contributed to make this release! ❤️
@@ -19,7 +51,7 @@ REST: {
 › [CURL Request] curl --location --request POST https://httpbin.org/post -H ...
 ```
 
-* feat(AI): Generate PageObject, added types, shell improvement (#4319) - by @davert
+* feat(AI): Generate PageObject, added types, shell improvement (#4319) - by @DavertMik
   * added `askForPageObject` method to generate PageObjects on the fly
   * improved AI types
   * interactive shell improved to restore history
@@ -30,7 +62,7 @@ REST: {
 * fix(heal): wrong priority (#4394) - by @kobenguyent
 
 📖 *Documentation*
-* AI docs improvements
+* AI docs improvements by @DavertMik
 
 ## 3.6.3
 
diff --git a/README.md b/README.md
index b483e3c80..4f5406735 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,6 @@ Build Status:
 
 Appium Helper:
 [![Appium V2 Tests - Android](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_Android.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_Android.yml)
-[![Appium V2 Tests - iOS](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_iOS.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/appiumV2_iOS.yml)
 
 Web Helper:
 [![Playwright Tests](https://github.com/codeceptjs/CodeceptJS/actions/workflows/playwright.yml/badge.svg)](https://github.com/codeceptjs/CodeceptJS/actions/workflows/playwright.yml)
diff --git a/bin/codecept.js b/bin/codecept.js
index 9477d809c..9a0ff7db0 100755
--- a/bin/codecept.js
+++ b/bin/codecept.js
@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-const program = require('commander');
-const Codecept = require('../lib/codecept');
-const { print, error } = require('../lib/output');
-const { printError } = require('../lib/command/utils');
+const program = require('commander')
+const Codecept = require('../lib/codecept')
+const { print, error } = require('../lib/output')
+const { printError } = require('../lib/command/utils')
 
 const commandFlags = {
   ai: {
@@ -29,104 +29,120 @@ const commandFlags = {
     flag: '--steps',
     description: 'show step-by-step execution',
   },
-};
-
-const errorHandler = (fn) => async (...args) => {
-  try {
-    await fn(...args);
-  } catch (e) {
-    printError(e);
-    process.exitCode = 1;
+}
+
+const errorHandler =
+  (fn) =>
+  async (...args) => {
+    try {
+      await fn(...args)
+    } catch (e) {
+      printError(e)
+      process.exitCode = 1
+    }
   }
-};
 
 if (process.versions.node && process.versions.node.split('.') && process.versions.node.split('.')[0] < 12) {
-  error('NodeJS >= 12 is required to run.');
-  print();
-  print('Please upgrade your NodeJS engine');
-  print(`Current NodeJS version: ${process.version}`);
-  process.exit(1);
+  error('NodeJS >= 12 is required to run.')
+  print()
+  print('Please upgrade your NodeJS engine')
+  print(`Current NodeJS version: ${process.version}`)
+  process.exit(1)
 }
 
-program.usage('<command> [options]');
-program.version(Codecept.version());
+program.usage('<command> [options]')
+program.version(Codecept.version())
 
-program.command('init [path]')
+program
+  .command('init [path]')
   .description('Creates dummy config in current dir or [path]')
-  .action(errorHandler(require('../lib/command/init')));
+  .action(errorHandler(require('../lib/command/init')))
 
-program.command('migrate [path]')
+program
+  .command('migrate [path]')
   .description('Migrate json config to js config in current dir or [path]')
-  .action(errorHandler(require('../lib/command/configMigrate')));
+  .action(errorHandler(require('../lib/command/configMigrate')))
 
-program.command('shell [path]')
+program
+  .command('shell [path]')
   .alias('sh')
   .description('Interactive shell')
   .option(commandFlags.verbose.flag, commandFlags.verbose.description)
   .option(commandFlags.profile.flag, commandFlags.profile.description)
   .option(commandFlags.ai.flag, commandFlags.ai.description)
   .option(commandFlags.config.flag, commandFlags.config.description)
-  .action(errorHandler(require('../lib/command/interactive')));
+  .action(errorHandler(require('../lib/command/interactive')))
 
-program.command('list [path]')
+program
+  .command('list [path]')
   .alias('l')
   .description('List all actions for I.')
-  .action(errorHandler(require('../lib/command/list')));
+  .action(errorHandler(require('../lib/command/list')))
 
-program.command('def [path]')
+program
+  .command('def [path]')
   .description('Generates TypeScript definitions for all I actions.')
   .option(commandFlags.config.flag, commandFlags.config.description)
   .option('-o, --output [folder]', 'target folder to paste definitions')
-  .action(errorHandler(require('../lib/command/definitions')));
+  .action(errorHandler(require('../lib/command/definitions')))
 
-program.command('gherkin:init [path]')
+program
+  .command('gherkin:init [path]')
   .alias('bdd:init')
   .description('Prepare CodeceptJS to run feature files.')
   .option(commandFlags.config.flag, commandFlags.config.description)
-  .action(errorHandler(require('../lib/command/gherkin/init')));
+  .action(errorHandler(require('../lib/command/gherkin/init')))
 
-program.command('gherkin:steps [path]')
+program
+  .command('gherkin:steps [path]')
   .alias('bdd:steps')
   .description('Prints all defined gherkin steps.')
   .option(commandFlags.config.flag, commandFlags.config.description)
-  .action(errorHandler(require('../lib/command/gherkin/steps')));
+  .action(errorHandler(require('../lib/command/gherkin/steps')))
 
-program.command('gherkin:snippets [path]')
+program
+  .command('gherkin:snippets [path]')
   .alias('bdd:snippets')
   .description('Generate step definitions from steps.')
   .option('--dry-run', "don't save snippets to file")
   .option(commandFlags.config.flag, commandFlags.config.description)
   .option('--feature [file]', 'feature files(s) to scan')
   .option('--path [file]', 'file in which to place the new snippets')
-  .action(errorHandler(require('../lib/command/gherkin/snippets')));
+  .action(errorHandler(require('../lib/command/gherkin/snippets')))
 
-program.command('generate:test [path]')
+program
+  .command('generate:test [path]')
   .alias('gt')
   .description('Generates an empty test')
-  .action(errorHandler(require('../lib/command/generate').test));
+  .action(errorHandler(require('../lib/command/generate').test))
 
-program.command('generate:pageobject [path]')
+program
+  .command('generate:pageobject [path]')
   .alias('gpo')
   .description('Generates an empty page object')
-  .action(errorHandler(require('../lib/command/generate').pageObject));
+  .action(errorHandler(require('../lib/command/generate').pageObject))
 
-program.command('generate:object [path]')
+program
+  .command('generate:object [path]')
   .alias('go')
   .option('--type, -t [kind]', 'type of object to be created')
   .description('Generates an empty support object (page/step/fragment)')
-  .action(errorHandler(require('../lib/command/generate').pageObject));
+  .action(errorHandler(require('../lib/command/generate').pageObject))
 
-program.command('generate:helper [path]')
+program
+  .command('generate:helper [path]')
   .alias('gh')
   .description('Generates a new helper')
-  .action(errorHandler(require('../lib/command/generate').helper));
+  .action(errorHandler(require('../lib/command/generate').helper))
 
-program.command('generate:heal [path]')
+program
+  .command('generate:heal [path]')
   .alias('gr')
   .description('Generates basic heal recipes')
-  .action(errorHandler(require('../lib/command/generate').heal));
+  .action(errorHandler(require('../lib/command/generate').heal))
 
-program.command('run [test]')
+program
+  .command('run [test]')
   .description('Executes tests')
 
   // codecept-only options
@@ -162,9 +178,10 @@ program.command('run [test]')
   .option('--recursive', 'include sub directories')
   .option('--trace', 'trace function calls')
   .option('--child <string>', 'option for child processes')
-  .action(errorHandler(require('../lib/command/run')));
+  .action(errorHandler(require('../lib/command/run')))
 
-program.command('run-workers <workers> [selectedRuns...]')
+program
+  .command('run-workers <workers> [selectedRuns...]')
   .description('Executes tests in workers')
   .option(commandFlags.config.flag, commandFlags.config.description)
   .option('-g, --grep <pattern>', 'only run tests matching <pattern>')
@@ -180,9 +197,10 @@ program.command('run-workers <workers> [selectedRuns...]')
   .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
   .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options')
   .option('-R, --reporter <name>', 'specify the reporter to use')
-  .action(errorHandler(require('../lib/command/run-workers')));
+  .action(errorHandler(require('../lib/command/run-workers')))
 
-program.command('run-multiple [suites...]')
+program
+  .command('run-multiple [suites...]')
   .description('Executes tests multiple')
   .option(commandFlags.config.flag, commandFlags.config.description)
   .option(commandFlags.profile.flag, commandFlags.profile.description)
@@ -205,14 +223,16 @@ program.command('run-multiple [suites...]')
   // mocha options
   .option('--colors', 'force enabling of colors')
 
-  .action(errorHandler(require('../lib/command/run-multiple')));
+  .action(errorHandler(require('../lib/command/run-multiple')))
 
-program.command('info [path]')
+program
+  .command('info [path]')
   .description('Print debugging information concerning the local environment')
   .option('-c, --config', 'your config file path')
-  .action(errorHandler(require('../lib/command/info')));
+  .action(errorHandler(require('../lib/command/info')))
 
-program.command('dry-run [test]')
+program
+  .command('dry-run [test]')
   .description('Prints step-by-step scenario for a test without actually running it')
   .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
   .option('--bootstrap', 'enable bootstrap & teardown scripts for dry-run')
@@ -226,9 +246,10 @@ program.command('dry-run [test]')
   .option(commandFlags.steps.flag, commandFlags.steps.description)
   .option(commandFlags.verbose.flag, commandFlags.verbose.description)
   .option(commandFlags.debug.flag, commandFlags.debug.description)
-  .action(errorHandler(require('../lib/command/dryRun')));
+  .action(errorHandler(require('../lib/command/dryRun')))
 
-program.command('run-rerun [test]')
+program
+  .command('run-rerun [test]')
   .description('Executes tests in more than one test suite run')
 
   // codecept-only options
@@ -263,15 +284,15 @@ program.command('run-rerun [test]')
   .option('--trace', 'trace function calls')
   .option('--child <string>', 'option for child processes')
 
-  .action(require('../lib/command/run-rerun'));
+  .action(require('../lib/command/run-rerun'))
 
 program.on('command:*', (cmd) => {
-  console.log(`\nUnknown command ${cmd}\n`);
-  program.outputHelp();
-});
+  console.log(`\nUnknown command ${cmd}\n`)
+  program.outputHelp()
+})
 
 if (process.argv.length <= 2) {
-  program.outputHelp();
+  program.outputHelp()
 } else {
-  program.parse(process.argv);
+  program.parse(process.argv)
 }
diff --git a/docs/ai.md b/docs/ai.md
index a06c3b243..5d99712d1 100644
--- a/docs/ai.md
+++ b/docs/ai.md
@@ -154,6 +154,8 @@ ai: {
 
 #### Azure OpenAI
 
+When your setup using Azure API key
+
 Prerequisite:
 
 * Install `@azure/openai` package
@@ -175,7 +177,88 @@ ai: {
 }
 ```
 
+When your setup using `bearer token`
+
+Prerequisite:
+
+* Install `@azure/openai`, `@azure/identity` packages
+* obtain `AZURE_TENANT_ID`, `AZURE_CLIENT_ID`, and `AZURE_CLIENT_SECRET`
+
+```js
+ai: {
+  request: async (messages) => {
+    try {
+      const { OpenAIClient} = require("@azure/openai");
+      const { DefaultAzureCredential } = require("@azure/identity");
+
+      const endpoint = process.env.API_ENDPOINT;
+      const deploymentId = process.env.DEPLOYMENT_ID;
+
+      const client = new OpenAIClient(endpoint, new DefaultAzureCredential());
+      const result = await client.getCompletions(deploymentId, {
+        prompt: messages,
+        model: 'gpt-3.5-turbo' // your preferred model
+      });
+
+      return result.choices[0]?.text;
+    } catch (error) {
+      console.error("Error calling API:", error);
+      throw error;
+    }
+  }
+}
+```
+
+Or you could try with direct API request
+
+```js
+ai: {
+  request: async (messages) => {
+    try {
+      const endpoint = process.env.API_ENDPOINT;
+      const deploymentId = process.env.DEPLOYMENT_ID;
 
+      const result = await makeApiRequest(endpoint, deploymentId, messages)
+
+      return result.choices[0]?.message.content
+    } catch (error) {
+      console.error("Error calling API:", error);
+      throw error;
+    }
+  }
+}
+...
+
+async function getAccessToken() {
+  const credential = new DefaultAzureCredential();
+  const scope = "https://cognitiveservices.azure.com/.default";
+
+  try {
+    const accessToken = await credential.getToken(scope);
+    return `Bearer ${accessToken.token}`;
+  } catch (err) {
+    console.error("Failed to get access token:", err);
+  }
+}
+
+async function makeApiRequest(endpoint, deploymentId, messages) {
+  const token = await getAccessToken();
+  const url = `${endpoint}/openai/deployments/${deploymentId}/chat/completions?api-version=2024-06-01`;
+
+  const data = { messages };
+
+  try {
+    const response = await axios.post(url, data, {
+      headers: {
+        'Authorization': `${token}`
+      }
+    });
+    return response.data
+  } catch (err) {
+    console.error("API request failed:", err.response);
+  }
+}
+```
 
 ### Writing Tests with AI Copilot
 
@@ -490,4 +573,4 @@ or if you run it in shell mode:
 
 ```
 DEBUG="codeceptjs:ai" npx codeceptjs shell --ai
-```
\ No newline at end of file
+```
diff --git a/docs/changelog.md b/docs/changelog.md
index a2ecb9c23..7ef0f19da 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -7,6 +7,40 @@ layout: Section
 
 # Releases
 
+## 3.6.4
+
+❤️ Thanks all to those who contributed to make this release! ❤️
+
+🛩️ *Features*
+* feat(rest): print curl ([#4396](https://github.com/codeceptjs/CodeceptJS/issues/4396)) - by **[kobenguyent](https://github.com/kobenguyent)**
+
+```
+Config:
+
+...
+REST: {
+ ...
+ printCurl: true,
+ ...
+}
+... 
+
+› [CURL Request] curl --location --request POST https://httpbin.org/post -H ...
+```
+
+* feat(AI): Generate PageObject, added types, shell improvement ([#4319](https://github.com/codeceptjs/CodeceptJS/issues/4319)) - by **[DavertMik](https://github.com/DavertMik)**
+  * added `askForPageObject` method to generate PageObjects on the fly
+  * improved AI types
+  * interactive shell improved to restore history
+
+![Screenshot from 2024-06-17 02-47-37](https://github.com/codeceptjs/CodeceptJS/assets/220264/12acd2c7-18d1-4105-a24b-84070ec4d393)
+
+🐛 *Bug Fixes*
+* fix(heal): wrong priority ([#4394](https://github.com/codeceptjs/CodeceptJS/issues/4394)) - by **[kobenguyent](https://github.com/kobenguyent)**
+
+📖 *Documentation*
+* AI docs improvements by **[DavertMik](https://github.com/DavertMik)**
+
 ## 3.6.3
 
 ❤️ Thanks all to those who contributed to make this release! ❤️
diff --git a/docs/helpers/AI.md b/docs/helpers/AI.md
index 2ee6c6582..a3b6082ea 100644
--- a/docs/helpers/AI.md
+++ b/docs/helpers/AI.md
@@ -14,13 +14,13 @@ title: AI
 AI Helper for CodeceptJS.
 
 This helper class provides integration with the AI GPT-3.5 or 4 language model for generating responses to questions or prompts within the context of web pages. It allows you to interact with the GPT-3.5 model to obtain intelligent responses based on HTML fragments or general prompts.
-This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDrvier to ensure the HTML context is available.
+This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDriver to ensure the HTML context is available.
 
 Use it only in development mode. It is recommended to run it only inside pause() mode.
 
 ## Configuration
 
-This helper should be configured in codecept.json or codecept.conf.js
+This helper should be configured in codecept.conf.{js|ts}
 
 -   `chunkSize`:  - The maximum number of characters to send to the AI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
 
diff --git a/docs/helpers/Playwright.md b/docs/helpers/Playwright.md
index c75b5cc7f..75b41c06f 100644
--- a/docs/helpers/Playwright.md
+++ b/docs/helpers/Playwright.md
@@ -2444,6 +2444,18 @@ I.waitForDetached('#popup');
 
 Returns **void** automatically synchronized promise through #recorder
 
+### waitForDisabled
+
+Waits for element to become disabled (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+#### Parameters
+
+-   `locator` **([string][9] | [object][6])** element located by CSS|XPath|strict locator.
+-   `sec` **[number][20]** (optional) time in seconds to wait, 1 by default. 
+
+Returns **void** automatically synchronized promise through #recorder
+
 ### waitForElement
 
 Waits for element to be present on page (by default waits for 1sec).
diff --git a/docs/webapi/waitForDisabled.mustache b/docs/webapi/waitForDisabled.mustache
new file mode 100644
index 000000000..c2822db30
--- /dev/null
+++ b/docs/webapi/waitForDisabled.mustache
@@ -0,0 +1,6 @@
+Waits for element to become disabled (by default waits for 1sec).
+Element can be located by CSS or XPath.
+
+@param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
+@param {number} [sec=1] (optional) time in seconds to wait, 1 by default.
+@returns {void} automatically synchronized promise through #recorder
diff --git a/lib/assert/empty.js b/lib/assert/empty.js
index 2b1fd67fe..859bcbfa7 100644
--- a/lib/assert/empty.js
+++ b/lib/assert/empty.js
@@ -1,43 +1,43 @@
-const Assertion = require('../assert');
-const AssertionFailedError = require('./error');
-const { template } = require('../utils');
-const output = require('../output');
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
 class EmptinessAssertion extends Assertion {
   constructor(params) {
     super((value) => {
       if (Array.isArray(value)) {
-        return value.length === 0;
+        return value.length === 0
       }
-      return !value;
-    }, params);
-    this.params.type = 'to be empty';
+      return !value
+    }, params)
+    this.params.type = 'to be empty'
   }
 
   getException() {
     if (Array.isArray(this.params.value)) {
-      this.params.value = `[${this.params.value.join(', ')}]`;
+      this.params.value = `[${this.params.value.join(', ')}]`
     }
 
-    const err = new AssertionFailedError(this.params, "{{customMessage}}expected {{subject}} '{{value}}' {{type}}");
+    const err = new AssertionFailedError(this.params, "{{customMessage}}expected {{subject}} '{{value}}' {{type}}")
 
     err.cliMessage = () => {
       const msg = err.template
         .replace('{{value}}', output.colors.bold('{{value}}'))
-        .replace('{{subject}}', output.colors.bold('{{subject}}'));
-      return template(msg, this.params);
-    };
-    return err;
+        .replace('{{subject}}', output.colors.bold('{{subject}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   addAssertParams() {
-    this.params.value = this.params.actual = arguments[0];
-    this.params.expected = [];
-    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : '';
+    this.params.value = this.params.actual = arguments[0]
+    this.params.expected = []
+    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : ''
   }
 }
 
 module.exports = {
   Assertion: EmptinessAssertion,
-  empty: subject => new EmptinessAssertion({ subject }),
-};
+  empty: (subject) => new EmptinessAssertion({ subject }),
+}
diff --git a/lib/assert/equal.js b/lib/assert/equal.js
index 17db64e5c..f8ef0a9d9 100644
--- a/lib/assert/equal.js
+++ b/lib/assert/equal.js
@@ -1,55 +1,57 @@
-const Assertion = require('../assert');
-const AssertionFailedError = require('./error');
-const { template } = require('../utils');
-const output = require('../output');
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
 class EqualityAssertion extends Assertion {
   constructor(params) {
     const comparator = function (a, b) {
       if (b.length === 0) {
-        b = '';
+        b = ''
       }
-      return a === b;
-    };
-    super(comparator, params);
-    this.params.type = 'to equal';
+      return a === b
+    }
+    super(comparator, params)
+    this.params.type = 'to equal'
   }
 
   getException() {
-    const params = this.params;
-    params.jar = template(params.jar, params);
-    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} "{{expected}}" {{type}} "{{actual}}"');
-    err.showDiff = false;
+    const params = this.params
+    params.jar = template(params.jar, params)
+    const err = new AssertionFailedError(
+      params,
+      '{{customMessage}}expected {{jar}} "{{expected}}" {{type}} "{{actual}}"',
+    )
+    err.showDiff = false
     if (typeof err.cliMessage === 'function') {
-      err.message = err.cliMessage();
+      err.message = err.cliMessage()
     }
     err.cliMessage = () => {
-      const msg = err.template
-        .replace('{{jar}}', output.colors.bold('{{jar}}'));
-      return template(msg, this.params);
-    };
-    return err;
+      const msg = err.template.replace('{{jar}}', output.colors.bold('{{jar}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   addAssertParams() {
-    this.params.expected = arguments[0];
-    this.params.actual = arguments[1];
-    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : '';
+    this.params.expected = arguments[0]
+    this.params.actual = arguments[1]
+    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : ''
   }
 }
 
 module.exports = {
   Assertion: EqualityAssertion,
-  equals: jar => new EqualityAssertion({ jar }),
+  equals: (jar) => new EqualityAssertion({ jar }),
   urlEquals: (baseUrl) => {
-    const assert = new EqualityAssertion({ jar: 'url of current page' });
+    const assert = new EqualityAssertion({ jar: 'url of current page' })
     assert.comparator = function (expected, actual) {
       if (expected.indexOf('http') !== 0) {
-        actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length);
+        actual = actual.slice(actual.indexOf(baseUrl) + baseUrl.length)
       }
-      return actual === expected;
-    };
-    return assert;
+      return actual === expected
+    }
+    return assert
   },
-  fileEquals: file => new EqualityAssertion({ file, jar: 'contents of {{file}}' }),
-};
+  fileEquals: (file) => new EqualityAssertion({ file, jar: 'contents of {{file}}' }),
+}
diff --git a/lib/assert/error.js b/lib/assert/error.js
index 072d82372..ed72233ec 100644
--- a/lib/assert/error.js
+++ b/lib/assert/error.js
@@ -1,4 +1,4 @@
-const subs = require('../utils').template;
+const subs = require('../utils').template
 
 /**
  * Assertion errors, can provide a detailed error messages.
@@ -6,27 +6,27 @@ const subs = require('../utils').template;
  * inspect() and cliMessage() added to display errors with params.
  */
 function AssertionFailedError(params, template) {
-  this.params = params;
-  this.template = template;
+  this.params = params
+  this.template = template
   // this.message = "AssertionFailedError";
   // this.showDiff = true;
 
   // @todo cut assert things nicer
-  this.showDiff = true;
+  this.showDiff = true
 
-  this.actual = this.params.actual;
-  this.expected = this.params.expected;
+  this.actual = this.params.actual
+  this.expected = this.params.expected
 
   this.inspect = () => {
-    const params = this.params || {};
-    const msg = params.customMessage || '';
-    return msg + subs(this.template, params);
-  };
+    const params = this.params || {}
+    const msg = params.customMessage || ''
+    return msg + subs(this.template, params)
+  }
 
-  this.cliMessage = () => this.inspect();
+  this.cliMessage = () => this.inspect()
 }
 
-AssertionFailedError.prototype = Object.create(Error.prototype);
-AssertionFailedError.constructor = AssertionFailedError;
+AssertionFailedError.prototype = Object.create(Error.prototype)
+AssertionFailedError.constructor = AssertionFailedError
 
-module.exports = AssertionFailedError;
+module.exports = AssertionFailedError
diff --git a/lib/assert/include.js b/lib/assert/include.js
index 6019bcc59..3899f4ca0 100644
--- a/lib/assert/include.js
+++ b/lib/assert/include.js
@@ -1,78 +1,78 @@
-const Assertion = require('../assert');
-const AssertionFailedError = require('./error');
-const { template } = require('../utils');
-const output = require('../output');
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
-const MAX_LINES = 10;
+const MAX_LINES = 10
 
 class InclusionAssertion extends Assertion {
   constructor(params) {
-    params.jar = params.jar || 'string';
+    params.jar = params.jar || 'string'
     const comparator = function (needle, haystack) {
       if (Array.isArray(haystack)) {
-        return haystack.filter(part => part.indexOf(needle) >= 0).length > 0;
+        return haystack.filter((part) => part.indexOf(needle) >= 0).length > 0
       }
-      return haystack.indexOf(needle) >= 0;
-    };
-    super(comparator, params);
-    this.params.type = 'to include';
+      return haystack.indexOf(needle) >= 0
+    }
+    super(comparator, params)
+    this.params.type = 'to include'
   }
 
   getException() {
-    const params = this.params;
-    params.jar = template(params.jar, params);
-    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"');
-    err.expected = params.needle;
-    err.actual = params.haystack;
+    const params = this.params
+    params.jar = template(params.jar, params)
+    const err = new AssertionFailedError(params, '{{customMessage}}expected {{jar}} {{type}} "{{needle}}"')
+    err.expected = params.needle
+    err.actual = params.haystack
     if (Array.isArray(this.params.haystack)) {
-      this.params.haystack = this.params.haystack.join('\n___(next element)___\n');
+      this.params.haystack = this.params.haystack.join('\n___(next element)___\n')
     }
     err.cliMessage = function () {
       const msg = this.template
         .replace('{{jar}}', output.colors.bold('{{jar}}'))
-        .replace('{{needle}}', output.colors.bold('{{needle}}'));
-      return template(msg, this.params);
-    };
-    return err;
+        .replace('{{needle}}', output.colors.bold('{{needle}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   getFailedAssertion() {
-    const err = this.getException();
-    const lines = this.params.haystack.split('\n');
+    const err = this.getException()
+    const lines = this.params.haystack.split('\n')
     if (lines.length > MAX_LINES) {
-      const more = lines.length - MAX_LINES;
-      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`;
+      const more = lines.length - MAX_LINES
+      err.actual = `${lines.slice(0, MAX_LINES).join('\n')}\n--( ${more} lines more )---`
     }
-    return err;
+    return err
   }
 
   getFailedNegation() {
-    this.params.type = 'not to include';
-    const err = this.getException();
-    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm');
-    const matched = this.params.haystack.match(pattern);
-    if (!matched) return err;
-    err.actual = matched[0].replace(this.params.needle, output.colors.bold(this.params.needle));
-    err.actual = `------\n${err.actual}\n------`;
-    return err;
+    this.params.type = 'not to include'
+    const err = this.getException()
+    const pattern = new RegExp(`^.*?\n?^.*?\n?^.*?${escapeRegExp(this.params.needle)}.*?$\n?.*$\n?.*$`, 'm')
+    const matched = this.params.haystack.match(pattern)
+    if (!matched) return err
+    err.actual = matched[0].replace(this.params.needle, output.colors.bold(this.params.needle))
+    err.actual = `------\n${err.actual}\n------`
+    return err
   }
 
   addAssertParams() {
-    this.params.needle = arguments[0];
-    this.params.haystack = arguments[1];
-    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : '';
+    this.params.needle = arguments[0]
+    this.params.haystack = arguments[1]
+    this.params.customMessage = arguments[2] ? `${arguments[2]}\n\n` : ''
   }
 }
 
 module.exports = {
   Assertion: InclusionAssertion,
   includes: (needleType) => {
-    needleType = needleType || 'string';
-    return new InclusionAssertion({ jar: needleType });
+    needleType = needleType || 'string'
+    return new InclusionAssertion({ jar: needleType })
   },
-  fileIncludes: file => new InclusionAssertion({ file, jar: 'file {{file}}' }),
-};
+  fileIncludes: (file) => new InclusionAssertion({ file, jar: 'file {{file}}' }),
+}
 
 function escapeRegExp(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&')
 }
diff --git a/lib/assert/throws.js b/lib/assert/throws.js
index c5b97f007..c0e92276c 100644
--- a/lib/assert/throws.js
+++ b/lib/assert/throws.js
@@ -1,20 +1,22 @@
 function errorThrown(actual, expected) {
-  if (!expected) return null;
-  if (!actual) throw new Error(`Expected ${expected} error to be thrown`);
-  const msg = actual.inspect ? actual.inspect() : actual.toString();
+  if (!expected) return null
+  if (!actual) throw new Error(`Expected ${expected} error to be thrown`)
+  const msg = actual.inspect ? actual.inspect() : actual.toString()
   if (expected instanceof RegExp) {
-    if (msg.match(expected)) return null;
-    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`);
+    if (msg.match(expected)) return null
+    throw new Error(`Expected error to be thrown with message matching ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'string') {
-    if (msg === expected) return null;
-    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`);
+    if (msg === expected) return null
+    throw new Error(`Expected error to be thrown with message ${expected} while '${msg}' caught`)
   }
   if (typeof expected === 'object') {
-    if (actual.constructor.name !== expected.constructor.name) throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`);
-    if (expected.message && expected.message !== msg) throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`);
+    if (actual.constructor.name !== expected.constructor.name)
+      throw new Error(`Expected ${expected} error to be thrown but ${actual} was caught`)
+    if (expected.message && expected.message !== msg)
+      throw new Error(`Expected error to be thrown with message ${expected.message} while '${msg}' caught`)
   }
-  return null;
+  return null
 }
 
-module.exports = errorThrown;
+module.exports = errorThrown
diff --git a/lib/assert/truth.js b/lib/assert/truth.js
index 0d72ba491..51dbe2def 100644
--- a/lib/assert/truth.js
+++ b/lib/assert/truth.js
@@ -1,37 +1,36 @@
-const Assertion = require('../assert');
-const AssertionFailedError = require('./error');
-const { template } = require('../utils');
-const output = require('../output');
+const Assertion = require('../assert')
+const AssertionFailedError = require('./error')
+const { template } = require('../utils')
+const output = require('../output')
 
 class TruthAssertion extends Assertion {
   constructor(params) {
     super((value) => {
       if (Array.isArray(value)) {
-        return value.filter(val => !!val).length > 0;
+        return value.filter((val) => !!val).length > 0
       }
-      return !!value;
-    }, params);
-    this.params.type = this.params.type || 'to be true';
+      return !!value
+    }, params)
+    this.params.type = this.params.type || 'to be true'
   }
 
   getException() {
-    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}');
+    const err = new AssertionFailedError(this.params, '{{customMessage}}expected {{subject}} {{type}}')
     err.cliMessage = () => {
-      const msg = err.template
-        .replace('{{subject}}', output.colors.bold('{{subject}}'));
-      return template(msg, this.params);
-    };
-    return err;
+      const msg = err.template.replace('{{subject}}', output.colors.bold('{{subject}}'))
+      return template(msg, this.params)
+    }
+    return err
   }
 
   addAssertParams() {
-    this.params.value = this.params.actual = arguments[0];
-    this.params.expected = true;
-    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : '';
+    this.params.value = this.params.actual = arguments[0]
+    this.params.expected = true
+    this.params.customMessage = arguments[1] ? `${arguments[1]}\n\n` : ''
   }
 }
 
 module.exports = {
   Assertion: TruthAssertion,
   truth: (subject, type) => new TruthAssertion({ subject, type }),
-};
+}
diff --git a/lib/command/configMigrate.js b/lib/command/configMigrate.js
index b06815359..0101c9cc2 100644
--- a/lib/command/configMigrate.js
+++ b/lib/command/configMigrate.js
@@ -1,71 +1,76 @@
-const colors = require('chalk');
-const fs = require('fs');
-const inquirer = require('inquirer');
-const mkdirp = require('mkdirp');
-const path = require('path');
-const util = require('util');
+const colors = require('chalk')
+const fs = require('fs')
+const inquirer = require('inquirer')
+const mkdirp = require('mkdirp')
+const path = require('path')
+const util = require('util')
 
-const { print, success, error } = require('../output');
-const { fileExists } = require('../utils');
-const { getTestRoot } = require('./utils');
+const { print, success, error } = require('../output')
+const { fileExists } = require('../utils')
+const { getTestRoot } = require('./utils')
 
 module.exports = function (initPath) {
-  const testsPath = getTestRoot(initPath);
+  const testsPath = getTestRoot(initPath)
 
-  print();
-  print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`);
-  print(`  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`);
-  print();
+  print()
+  print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} configuration migration tool`)
+  print(
+    `  It will help you switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format at ease`,
+  )
+  print()
 
   if (!path) {
-    print('No config file is specified.');
-    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
-    print('----------------------------------');
+    print('No config file is specified.')
+    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
+    print('----------------------------------')
   } else {
-    print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`);
+    print(`Migrating ${colors.magenta.bold('.js')} config to ${colors.bold(testsPath)}`)
   }
 
   if (!fileExists(testsPath)) {
-    print(`Directory ${testsPath} does not exist, creating...`);
-    mkdirp.sync(testsPath);
+    print(`Directory ${testsPath} does not exist, creating...`)
+    mkdirp.sync(testsPath)
   }
 
-  const configFile = path.join(testsPath, 'codecept.conf.js');
+  const configFile = path.join(testsPath, 'codecept.conf.js')
   if (fileExists(configFile)) {
-    error(`Config is already created at ${configFile}`);
-    return;
+    error(`Config is already created at ${configFile}`)
+    return
   }
 
-  inquirer.prompt([{
-    name: 'configFile',
-    type: 'confirm',
-    message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
-    default: true,
-  },
-  {
-    name: 'delete',
-    type: 'confirm',
-    message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
-    default: true,
-  },
-  ]).then((result) => {
-    if (result.configFile) {
-      const jsonConfigFile = path.join(testsPath, 'codecept.js');
-      const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'));
-      config.name = testsPath.split(path.sep).pop();
+  inquirer
+    .prompt([
+      {
+        name: 'configFile',
+        type: 'confirm',
+        message: `Would you like to switch from ${colors.cyan.bold('.json')} to ${colors.magenta.bold('.js')} config format?`,
+        default: true,
+      },
+      {
+        name: 'delete',
+        type: 'confirm',
+        message: `Would you like to delete ${colors.cyan.bold('.json')} config format afterwards?`,
+        default: true,
+      },
+    ])
+    .then((result) => {
+      if (result.configFile) {
+        const jsonConfigFile = path.join(testsPath, 'codecept.js')
+        const config = JSON.parse(fs.readFileSync(jsonConfigFile, 'utf8'))
+        config.name = testsPath.split(path.sep).pop()
 
-      const finish = () => {
-        fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8');
-        success(`Config is successfully migrated at ${configFile}`);
+        const finish = () => {
+          fs.writeFileSync(configFile, `exports.config = ${util.inspect(config, false, 4, false)}`, 'utf-8')
+          success(`Config is successfully migrated at ${configFile}`)
 
-        if (result.delete) {
-          if (fileExists(jsonConfigFile)) {
-            fs.unlinkSync(jsonConfigFile);
-            success('JSON config file is deleted!');
+          if (result.delete) {
+            if (fileExists(jsonConfigFile)) {
+              fs.unlinkSync(jsonConfigFile)
+              success('JSON config file is deleted!')
+            }
           }
         }
-      };
-      finish();
-    }
-  });
-};
+        finish()
+      }
+    })
+}
diff --git a/lib/command/definitions.js b/lib/command/definitions.js
index 3751fe5fa..cfa4ae459 100644
--- a/lib/command/definitions.js
+++ b/lib/command/definitions.js
@@ -1,11 +1,11 @@
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs')
+const path = require('path')
 
-const { getConfig, getTestRoot } = require('./utils');
-const Codecept = require('../codecept');
-const container = require('../container');
-const output = require('../output');
-const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST'];
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const container = require('../container')
+const output = require('../output')
+const actingHelpers = [...require('../plugin/standardActingHelpers'), 'REST']
 
 /**
  * Prepare data and generate content of definitions file
@@ -29,32 +29,27 @@ const getDefinitionsFileContent = ({
   importPaths,
   translations,
 }) => {
-  const getHelperListFragment = ({
-    hasCustomHelper,
-    hasCustomStepsFile,
-  }) => {
+  const getHelperListFragment = ({ hasCustomHelper, hasCustomStepsFile }) => {
     if (hasCustomHelper && hasCustomStepsFile) {
-      return `${['ReturnType<steps_file>', 'WithTranslation<Methods>'].join(', ')}`;
+      return `${['ReturnType<steps_file>', 'WithTranslation<Methods>'].join(', ')}`
     }
 
     if (hasCustomStepsFile) {
-      return 'ReturnType<steps_file>';
+      return 'ReturnType<steps_file>'
     }
 
-    return 'WithTranslation<Methods>';
-  };
+    return 'WithTranslation<Methods>'
+  }
 
   const helpersListFragment = getHelperListFragment({
     hasCustomHelper,
     hasCustomStepsFile,
-  });
+  })
 
-  const importPathsFragment = importPaths.join('\n');
-  const supportObjectsTypeFragment = convertMapToType(supportObject);
-  const methodsTypeFragment = helperNames.length > 0
-    ? `interface Methods extends ${helperNames.join(', ')} {}`
-    : '';
-  const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2);
+  const importPathsFragment = importPaths.join('\n')
+  const supportObjectsTypeFragment = convertMapToType(supportObject)
+  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : ''
+  const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2)
 
   return generateDefinitionsContent({
     helpersListFragment,
@@ -62,8 +57,8 @@ const getDefinitionsFileContent = ({
     supportObjectsTypeFragment,
     methodsTypeFragment,
     translatedActionsFragment,
-  });
-};
+  })
+}
 
 /**
  * Generate content for definitions file from fragments
@@ -96,83 +91,83 @@ declare namespace CodeceptJS {
     interface Actions ${translatedActionsFragment}
   }
 }
-`;
-};
+`
+}
 
 /** @type {Array<string>} */
-const helperNames = [];
+const helperNames = []
 /** @type {Array<string>} */
-const customHelpers = [];
+const customHelpers = []
 
 module.exports = function (genPath, options) {
-  const configFile = options.config || genPath;
+  const configFile = options.config || genPath
   /** @type {string} */
-  const testsPath = getTestRoot(configFile);
-  const config = getConfig(configFile);
-  if (!config) return;
+  const testsPath = getTestRoot(configFile)
+  const config = getConfig(configFile)
+  if (!config) return
 
   /** @type {Object<string, string>} */
-  const helperPaths = {};
+  const helperPaths = {}
   /** @type {Object<string, string>} */
-  const supportPaths = {};
+  const supportPaths = {}
   /** @type {boolean} */
-  let hasCustomStepsFile = false;
+  let hasCustomStepsFile = false
   /** @type {boolean} */
-  let hasCustomHelper = false;
+  let hasCustomHelper = false
 
   /** @type {string} */
-  const targetFolderPath = options.output && getTestRoot(options.output) || testsPath;
+  const targetFolderPath = (options.output && getTestRoot(options.output)) || testsPath
 
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  const codecept = new Codecept(config, {})
+  codecept.init(testsPath)
 
-  const helpers = container.helpers();
-  const translations = container.translation();
+  const helpers = container.helpers()
+  const translations = container.translation()
   for (const name in helpers) {
-    const require = codecept.config.helpers[name].require;
+    const require = codecept.config.helpers[name].require
     if (require) {
-      helperPaths[name] = require;
-      helperNames.push(name);
+      helperPaths[name] = require
+      helperNames.push(name)
     } else {
-      const fullBasedPromised = codecept.config.fullPromiseBased;
-      helperNames.push(fullBasedPromised === true ? `${name}Ts` : name);
+      const fullBasedPromised = codecept.config.fullPromiseBased
+      helperNames.push(fullBasedPromised === true ? `${name}Ts` : name)
     }
 
     if (!actingHelpers.includes(name)) {
-      customHelpers.push(name);
+      customHelpers.push(name)
     }
   }
 
-  let autoLogin;
+  let autoLogin
   if (config.plugins.autoLogin) {
-    autoLogin = config.plugins.autoLogin.inject;
+    autoLogin = config.plugins.autoLogin.inject
   }
 
-  const supportObject = new Map();
-  supportObject.set('I', 'I');
-  supportObject.set('current', 'any');
+  const supportObject = new Map()
+  supportObject.set('I', 'I')
+  supportObject.set('current', 'any')
 
   if (translations.loaded) {
-    supportObject.set(translations.I, translations.I);
+    supportObject.set(translations.I, translations.I)
   }
 
   if (autoLogin) {
-    supportObject.set(autoLogin, 'any');
+    supportObject.set(autoLogin, 'any')
   }
 
   if (customHelpers.length > 0) {
-    hasCustomHelper = true;
+    hasCustomHelper = true
   }
 
   for (const name in codecept.config.include) {
-    const includePath = codecept.config.include[name];
+    const includePath = codecept.config.include[name]
     if (name === 'I' || name === translations.I) {
-      hasCustomStepsFile = true;
-      supportPaths.steps_file = includePath;
-      continue;
+      hasCustomStepsFile = true
+      supportPaths.steps_file = includePath
+      continue
     }
-    supportPaths[name] = includePath;
-    supportObject.set(name, name);
+    supportPaths[name] = includePath
+    supportObject.set(name, name)
   }
 
   let definitionsFileContent = getDefinitionsFileContent({
@@ -182,31 +177,34 @@ module.exports = function (genPath, options) {
     translations,
     hasCustomStepsFile,
     hasCustomHelper,
-  });
+  })
 
   // add aliases for translations
   if (translations.loaded) {
-    const namespaceTranslationAliases = [];
-    namespaceTranslationAliases.push(`interface ${translations.vocabulary.I} extends WithTranslation<Methods> {}`);
+    const namespaceTranslationAliases = []
+    namespaceTranslationAliases.push(`interface ${translations.vocabulary.I} extends WithTranslation<Methods> {}`)
 
-    namespaceTranslationAliases.push('  namespace Translation {');
-    definitionsFileContent = definitionsFileContent.replace('namespace Translation {', namespaceTranslationAliases.join('\n'));
+    namespaceTranslationAliases.push('  namespace Translation {')
+    definitionsFileContent = definitionsFileContent.replace(
+      'namespace Translation {',
+      namespaceTranslationAliases.join('\n'),
+    )
 
-    const translationAliases = [];
+    const translationAliases = []
 
     if (translations.vocabulary.contexts) {
-      Object.keys(translations.vocabulary.contexts).forEach(k => {
-        translationAliases.push(`declare const ${translations.vocabulary.contexts[k]}: typeof ${k};`);
-      });
+      Object.keys(translations.vocabulary.contexts).forEach((k) => {
+        translationAliases.push(`declare const ${translations.vocabulary.contexts[k]}: typeof ${k};`)
+      })
     }
 
-    definitionsFileContent += `\n${translationAliases.join('\n')}`;
+    definitionsFileContent += `\n${translationAliases.join('\n')}`
   }
 
-  fs.writeFileSync(path.join(targetFolderPath, 'steps.d.ts'), definitionsFileContent);
-  output.print('TypeScript Definitions provide autocompletion in Visual Studio Code and other IDEs');
-  output.print('Definitions were generated in steps.d.ts');
-};
+  fs.writeFileSync(path.join(targetFolderPath, 'steps.d.ts'), definitionsFileContent)
+  output.print('TypeScript Definitions provide autocompletion in Visual Studio Code and other IDEs')
+  output.print('Definitions were generated in steps.d.ts')
+}
 
 /**
  * Returns the relative path from the  to the targeted folder.
@@ -215,13 +213,13 @@ module.exports = function (genPath, options) {
  * @param {string} testsPath
  */
 function getPath(originalPath, targetFolderPath, testsPath) {
-  const parsedPath = path.parse(originalPath);
+  const parsedPath = path.parse(originalPath)
 
   // Remove typescript extension if exists.
-  if (parsedPath.base.endsWith('.d.ts')) parsedPath.base = parsedPath.base.substring(0, parsedPath.base.length - 5);
-  else if (parsedPath.ext === '.ts') parsedPath.base = parsedPath.name;
+  if (parsedPath.base.endsWith('.d.ts')) parsedPath.base = parsedPath.base.substring(0, parsedPath.base.length - 5)
+  else if (parsedPath.ext === '.ts') parsedPath.base = parsedPath.name
 
-  if (!parsedPath.dir.startsWith('.')) return path.posix.join(parsedPath.dir, parsedPath.base);
+  if (!parsedPath.dir.startsWith('.')) return path.posix.join(parsedPath.dir, parsedPath.base)
   const relativePath = path.posix.relative(
     targetFolderPath.split(path.sep).join(path.posix.sep),
     path.posix.join(
@@ -229,9 +227,9 @@ function getPath(originalPath, targetFolderPath, testsPath) {
       parsedPath.dir.split(path.sep).join(path.posix.sep),
       parsedPath.base.split(path.sep).join(path.posix.sep),
     ),
-  );
+  )
 
-  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+  return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
 }
 
 /**
@@ -245,19 +243,19 @@ function getPath(originalPath, targetFolderPath, testsPath) {
  * @returns {Array<string>}
  */
 function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue) {
-  const importStrings = [];
+  const importStrings = []
 
   for (const name in pathsToType) {
-    const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath);
-    importStrings.push(`type ${name} = typeof import('${relativePath}');`);
+    const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath)
+    importStrings.push(`type ${name} = typeof import('${relativePath}');`)
   }
 
   for (const name in pathsToValue) {
-    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath);
-    importStrings.push(`type ${name} = import('${relativePath}');`);
+    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath)
+    importStrings.push(`type ${name} = import('${relativePath}');`)
   }
 
-  return importStrings;
+  return importStrings
 }
 
 /**
@@ -266,5 +264,7 @@ function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue)
  * @returns {string}
  */
 function convertMapToType(map) {
-  return `{ ${Array.from(map).map(([key, value]) => `${key}: ${value}`).join(', ')} }`;
+  return `{ ${Array.from(map)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(', ')} }`
 }
diff --git a/lib/command/dryRun.js b/lib/command/dryRun.js
index f6fe2a490..0de23df4f 100644
--- a/lib/command/dryRun.js
+++ b/lib/command/dryRun.js
@@ -1,120 +1,122 @@
-const { getConfig, getTestRoot } = require('./utils');
-const Config = require('../config');
-const Codecept = require('../codecept');
-const output = require('../output');
-const event = require('../event');
-const store = require('../store');
-const Container = require('../container');
+const { getConfig, getTestRoot } = require('./utils')
+const Config = require('../config')
+const Codecept = require('../codecept')
+const output = require('../output')
+const event = require('../event')
+const store = require('../store')
+const Container = require('../container')
 
 module.exports = async function (test, options) {
-  if (options.grep) process.env.grep = options.grep.toLowerCase();
-  const configFile = options.config;
-  let codecept;
+  if (options.grep) process.env.grep = options.grep.toLowerCase()
+  const configFile = options.config
+  let codecept
 
-  const testRoot = getTestRoot(configFile);
-  let config = getConfig(configFile);
+  const testRoot = getTestRoot(configFile)
+  let config = getConfig(configFile)
   if (options.override) {
-    config = Config.append(JSON.parse(options.override));
+    config = Config.append(JSON.parse(options.override))
   }
 
   if (config.plugins) {
     // disable all plugins by default, they can be enabled with -p option
     for (const plugin in config.plugins) {
       // if `-p all` is passed, then enabling all plugins, otherwise plugins could be enabled by `-p customLocator,commentStep,tryTo`
-      config.plugins[plugin].enabled = options.plugins === 'all';
+      config.plugins[plugin].enabled = options.plugins === 'all'
     }
   }
 
   try {
-    codecept = new Codecept(config, options);
-    codecept.init(testRoot);
+    codecept = new Codecept(config, options)
+    codecept.init(testRoot)
 
-    if (options.bootstrap) await codecept.bootstrap();
+    if (options.bootstrap) await codecept.bootstrap()
 
-    codecept.loadTests();
-    store.dryRun = true;
+    codecept.loadTests()
+    store.dryRun = true
 
     if (!options.steps && !options.verbose && !options.debug) {
-      printTests(codecept.testFiles);
-      return;
+      printTests(codecept.testFiles)
+      return
     }
-    event.dispatcher.on(event.all.result, printFooter);
-    codecept.run(test);
+    event.dispatcher.on(event.all.result, printFooter)
+    codecept.run(test)
   } catch (err) {
-    console.error(err);
-    process.exit(1);
+    console.error(err)
+    process.exit(1)
   }
-};
+}
 
 function printTests(files) {
-  const figures = require('figures');
-  const colors = require('chalk');
+  const figures = require('figures')
+  const colors = require('chalk')
 
-  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`));
-  output.print();
+  output.print(output.styles.debug(`Tests from ${global.codecept_dir}:`))
+  output.print()
 
-  const mocha = Container.mocha();
-  mocha.files = files;
-  mocha.loadFiles();
+  const mocha = Container.mocha()
+  mocha.files = files
+  mocha.loadFiles()
 
-  let numOfTests = 0;
-  let numOfSuites = 0;
-  let outputString = '';
-  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined;
+  let numOfTests = 0
+  let numOfSuites = 0
+  let outputString = ''
+  const filterBy = process.env.grep ? process.env.grep.toLowerCase() : undefined
 
   if (filterBy) {
     for (const suite of mocha.suite.suites) {
-      const currentSuite = suite.title;
+      const currentSuite = suite.title
       if (suite.title.toLowerCase().includes(filterBy)) {
-        outputString += `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests\n`;
-        numOfSuites++;
+        outputString += `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests\n`
+        numOfSuites++
       }
 
       for (test of suite.tests) {
         if (test.title.toLowerCase().includes(filterBy)) {
-          numOfTests++;
-          outputString += `${colors.white.bold(test.parent.title)} -- ${output.styles.log(test.parent.file || '')} -- ${mocha.suite.suites.length} tests\n`;
-          outputString += `  ${output.styles.scenario(figures.checkboxOff)} ${test.title}\n`;
+          numOfTests++
+          outputString += `${colors.white.bold(test.parent.title)} -- ${output.styles.log(test.parent.file || '')} -- ${mocha.suite.suites.length} tests\n`
+          outputString += `  ${output.styles.scenario(figures.checkboxOff)} ${test.title}\n`
         }
       }
     }
-    numOfSuites = countSuites(outputString);
+    numOfSuites = countSuites(outputString)
   } else {
     for (const suite of mocha.suite.suites) {
-      output.print(`${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests`);
-      numOfSuites++;
+      output.print(
+        `${colors.white.bold(suite.title)} -- ${output.styles.log(suite.file || '')} -- ${mocha.suite.suites.length} tests`,
+      )
+      numOfSuites++
 
       for (test of suite.tests) {
-        numOfTests++;
-        output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`);
+        numOfTests++
+        output.print(`  ${output.styles.scenario(figures.checkboxOff)} ${test.title}`)
       }
     }
   }
 
-  output.print(removeDuplicates(outputString));
-  output.print('');
-  output.success(`  Total: ${numOfSuites} suites | ${numOfTests} tests  `);
-  printFooter();
-  process.exit(0);
+  output.print(removeDuplicates(outputString))
+  output.print('')
+  output.success(`  Total: ${numOfSuites} suites | ${numOfTests} tests  `)
+  printFooter()
+  process.exit(0)
 }
 
 function printFooter() {
-  output.print();
-  output.print('--- DRY MODE: No tests were executed ---');
+  output.print()
+  output.print('--- DRY MODE: No tests were executed ---')
 }
 
 function removeDuplicates(inputString) {
-  const array = inputString.split('\n');
-  const uniqueLines = [...new Set(array)];
-  const resultString = uniqueLines.join('\n');
+  const array = inputString.split('\n')
+  const uniqueLines = [...new Set(array)]
+  const resultString = uniqueLines.join('\n')
 
-  return resultString;
+  return resultString
 }
 
 function countSuites(inputString) {
-  const array = inputString.split('\n');
+  const array = inputString.split('\n')
 
-  const uniqueLines = [...new Set(array)];
-  const res = uniqueLines.filter(item => item.includes('-- '));
-  return res.length;
+  const uniqueLines = [...new Set(array)]
+  const res = uniqueLines.filter((item) => item.includes('-- '))
+  return res.length
 }
diff --git a/lib/command/generate.js b/lib/command/generate.js
index 8d4011731..914b11bca 100644
--- a/lib/command/generate.js
+++ b/lib/command/generate.js
@@ -1,80 +1,80 @@
-const colors = require('chalk');
-const fs = require('fs');
-const inquirer = require('inquirer');
-const mkdirp = require('mkdirp');
-const path = require('path');
-const {
-  fileExists, ucfirst, lcfirst, beautify,
-} = require('../utils');
-const output = require('../output');
-const generateDefinitions = require('./definitions');
-const {
-  getConfig, getTestRoot, safeFileWrite, readConfig,
-} = require('./utils');
-
-let extension = 'js';
+const colors = require('chalk')
+const fs = require('fs')
+const inquirer = require('inquirer')
+const mkdirp = require('mkdirp')
+const path = require('path')
+const { fileExists, ucfirst, lcfirst, beautify } = require('../utils')
+const output = require('../output')
+const generateDefinitions = require('./definitions')
+const { getConfig, getTestRoot, safeFileWrite, readConfig } = require('./utils')
+
+let extension = 'js'
 
 const testTemplate = `Feature('{{feature}}');
 
 Scenario('test something', async ({ {{actor}} }) => {
 
 });
-`;
+`
 
 // generates empty test
 module.exports.test = function (genPath) {
-  const testsPath = getTestRoot(genPath);
-  global.codecept_dir = testsPath;
-  const config = getConfig(testsPath);
-  if (!config) return;
-
-  output.print('Creating a new test...');
-  output.print('----------------------');
-
-  const defaultExt = config.tests.match(/([^\*/]*?)$/)[1] || `_test.${extension}`;
-
-  return inquirer.prompt([
-    {
-      type: 'input',
-      name: 'feature',
-      message: 'Feature which is being tested (ex: account, login, etc)',
-      validate: (val) => !!val,
-    },
-    {
-      type: 'input',
-      message: 'Filename of a test',
-      name: 'filename',
-      default(answers) {
-        return (answers.feature).replace(' ', '_') + defaultExt;
+  const testsPath = getTestRoot(genPath)
+  global.codecept_dir = testsPath
+  const config = getConfig(testsPath)
+  if (!config) return
+
+  output.print('Creating a new test...')
+  output.print('----------------------')
+
+  const defaultExt = config.tests.match(/([^\*/]*?)$/)[1] || `_test.${extension}`
+
+  return inquirer
+    .prompt([
+      {
+        type: 'input',
+        name: 'feature',
+        message: 'Feature which is being tested (ex: account, login, etc)',
+        validate: (val) => !!val,
       },
-    },
-  ]).then((result) => {
-    const testFilePath = path.dirname(path.join(testsPath, config.tests)).replace(/\*\*$/, '');
-    let testFile = path.join(testFilePath, result.filename);
-    const ext = path.extname(testFile);
-    if (!ext) testFile += defaultExt;
-    const dir = path.dirname(testFile);
-    if (!fileExists(dir)) mkdirp.sync(dir);
-    let testContent = testTemplate.replace('{{feature}}', result.feature);
-
-    const container = require('../container');
-    container.create(config, {});
-    // translate scenario test
-    if (container.translation().loaded) {
-      const vocabulary = container.translation().vocabulary;
-      testContent = testContent.replace('{{actor}}', container.translation().I);
-      if (vocabulary.contexts.Feature) testContent = testContent.replace('Feature', vocabulary.contexts.Feature);
-      if (vocabulary.contexts.Scenario) testContent = testContent.replace('Scenario', vocabulary.contexts.Scenario);
-      output.print(`Test was created in ${colors.bold(config.translation)} localization. See: https://codecept.io/translation/`);
-    } else {
-      testContent = testContent.replace('{{actor}}', 'I');
-    }
-    if (!config.fullPromiseBased) testContent = testContent.replace('async', '');
+      {
+        type: 'input',
+        message: 'Filename of a test',
+        name: 'filename',
+        default(answers) {
+          return answers.feature.replace(' ', '_') + defaultExt
+        },
+      },
+    ])
+    .then((result) => {
+      const testFilePath = path.dirname(path.join(testsPath, config.tests)).replace(/\*\*$/, '')
+      let testFile = path.join(testFilePath, result.filename)
+      const ext = path.extname(testFile)
+      if (!ext) testFile += defaultExt
+      const dir = path.dirname(testFile)
+      if (!fileExists(dir)) mkdirp.sync(dir)
+      let testContent = testTemplate.replace('{{feature}}', result.feature)
+
+      const container = require('../container')
+      container.create(config, {})
+      // translate scenario test
+      if (container.translation().loaded) {
+        const vocabulary = container.translation().vocabulary
+        testContent = testContent.replace('{{actor}}', container.translation().I)
+        if (vocabulary.contexts.Feature) testContent = testContent.replace('Feature', vocabulary.contexts.Feature)
+        if (vocabulary.contexts.Scenario) testContent = testContent.replace('Scenario', vocabulary.contexts.Scenario)
+        output.print(
+          `Test was created in ${colors.bold(config.translation)} localization. See: https://codecept.io/translation/`,
+        )
+      } else {
+        testContent = testContent.replace('{{actor}}', 'I')
+      }
+      if (!config.fullPromiseBased) testContent = testContent.replace('async', '')
 
-    if (!safeFileWrite(testFile, testContent)) return;
-    output.success(`\nTest for ${result.filename} was created in ${testFile}`);
-  });
-};
+      if (!safeFileWrite(testFile, testContent)) return
+      output.success(`\nTest for ${result.filename} was created in ${testFile}`)
+    })
+}
 
 const pageObjectTemplate = `const { I } = inject();
 
@@ -82,7 +82,7 @@ module.exports = {
 
   // insert your locators and methods here
 }
-`;
+`
 
 const poModuleTemplateTS = `const { I } = inject();
 
@@ -90,7 +90,7 @@ export = {
 
   // insert your locators and methods here
 }
-`;
+`
 
 const poClassTemplate = `const { I } = inject();
 
@@ -105,96 +105,101 @@ class {{name}} {
 // For inheritance
 module.exports = new {{name}}();
 export = {{name}};
-`;
+`
 
 module.exports.pageObject = function (genPath, opts) {
-  const testsPath = getTestRoot(genPath);
-  const config = getConfig(testsPath);
-  const kind = opts.T || 'page';
-  if (!config) return;
+  const testsPath = getTestRoot(genPath)
+  const config = getConfig(testsPath)
+  const kind = opts.T || 'page'
+  if (!config) return
 
-  let configFile = path.join(testsPath, `codecept.conf.${extension}`);
+  let configFile = path.join(testsPath, `codecept.conf.${extension}`)
 
   if (!fileExists(configFile)) {
-    extension = 'ts';
-    configFile = path.join(testsPath, `codecept.conf.${extension}`);
+    extension = 'ts'
+    configFile = path.join(testsPath, `codecept.conf.${extension}`)
   }
-  output.print(`Creating a new ${kind} object`);
-  output.print('--------------------------');
-
-  return inquirer.prompt([
-    {
-      type: 'input',
-      name: 'name',
-      message: `Name of a ${kind} object`,
-      validate: (val) => !!val,
-    },
-    {
-      type: 'input',
-      name: 'filename',
-      message: 'Where should it be stored',
-      default: answers => `./${kind}s/${answers.name}.${extension}`,
-    },
-    {
-      type: 'list',
-      name: 'objectType',
-      message: 'What is your preferred object type',
-      choices: ['module', 'class'],
-      default: 'module',
-    },
-  ]).then((result) => {
-    const pageObjectFile = path.join(testsPath, result.filename);
-    const dir = path.dirname(pageObjectFile);
-    if (!fileExists(dir)) fs.mkdirSync(dir);
-
-    let actor = 'actor';
-
-    if (config.include.I) {
-      let actorPath = config.include.I;
-      if (actorPath.charAt(0) === '.') { // relative path
-        actorPath = path.relative(dir, path.dirname(path.join(testsPath, actorPath))) + actorPath.substring(1); // get an upper level
+  output.print(`Creating a new ${kind} object`)
+  output.print('--------------------------')
+
+  return inquirer
+    .prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: `Name of a ${kind} object`,
+        validate: (val) => !!val,
+      },
+      {
+        type: 'input',
+        name: 'filename',
+        message: 'Where should it be stored',
+        default: (answers) => `./${kind}s/${answers.name}.${extension}`,
+      },
+      {
+        type: 'list',
+        name: 'objectType',
+        message: 'What is your preferred object type',
+        choices: ['module', 'class'],
+        default: 'module',
+      },
+    ])
+    .then((result) => {
+      const pageObjectFile = path.join(testsPath, result.filename)
+      const dir = path.dirname(pageObjectFile)
+      if (!fileExists(dir)) fs.mkdirSync(dir)
+
+      let actor = 'actor'
+
+      if (config.include.I) {
+        let actorPath = config.include.I
+        if (actorPath.charAt(0) === '.') {
+          // relative path
+          actorPath = path.relative(dir, path.dirname(path.join(testsPath, actorPath))) + actorPath.substring(1) // get an upper level
+        }
+        actor = `require('${actorPath}')`
       }
-      actor = `require('${actorPath}')`;
-    }
 
-    const name = lcfirst(result.name) + ucfirst(kind);
-    if (result.objectType === 'module' && extension === 'ts') {
-      if (!safeFileWrite(pageObjectFile, poModuleTemplateTS.replace('{{actor}}', actor))) return;
-    } else if (result.objectType === 'module' && extension === 'js') {
-      if (!safeFileWrite(pageObjectFile, pageObjectTemplate.replace('{{actor}}', actor))) return;
-    } else if (result.objectType === 'class') {
-      const content = poClassTemplate.replace(/{{actor}}/g, actor).replace(/{{name}}/g, name);
-      if (!safeFileWrite(pageObjectFile, content)) return;
-    }
+      const name = lcfirst(result.name) + ucfirst(kind)
+      if (result.objectType === 'module' && extension === 'ts') {
+        if (!safeFileWrite(pageObjectFile, poModuleTemplateTS.replace('{{actor}}', actor))) return
+      } else if (result.objectType === 'module' && extension === 'js') {
+        if (!safeFileWrite(pageObjectFile, pageObjectTemplate.replace('{{actor}}', actor))) return
+      } else if (result.objectType === 'class') {
+        const content = poClassTemplate.replace(/{{actor}}/g, actor).replace(/{{name}}/g, name)
+        if (!safeFileWrite(pageObjectFile, content)) return
+      }
 
-    let data = readConfig(configFile);
-    config.include[name] = result.filename;
+      let data = readConfig(configFile)
+      config.include[name] = result.filename
 
-    if (!data) throw Error('Config file is empty');
-    const currentInclude = `${data.match(/include:[\s\S][^\}]*/i)[0]}\n ${name}:${JSON.stringify(config.include[name])}`;
+      if (!data) throw Error('Config file is empty')
+      const currentInclude = `${data.match(/include:[\s\S][^\}]*/i)[0]}\n ${name}:${JSON.stringify(config.include[name])}`
 
-    data = data.replace(/include:[\s\S][^\}]*/i, `${currentInclude},`);
+      data = data.replace(/include:[\s\S][^\}]*/i, `${currentInclude},`)
 
-    fs.writeFileSync(configFile, beautify(data), 'utf-8');
+      fs.writeFileSync(configFile, beautify(data), 'utf-8')
 
-    output.success(`${ucfirst(kind)} object for ${result.name} was created in ${pageObjectFile}`);
-    output.print(`Your config file (${colors.cyan('include')} section) has included the new created PO:
+      output.success(`${ucfirst(kind)} object for ${result.name} was created in ${pageObjectFile}`)
+      output.print(`Your config file (${colors.cyan('include')} section) has included the new created PO:
 
     include: {
     ...
       ${name}: '${result.filename}',
-    },`);
+    },`)
 
-    output.print(`Use ${output.colors.bold(colors.cyan(name))} as parameter in test scenarios to access this object:`);
-    output.print(`\nScenario('my new test', ({ I, ${name} })) { /** ... */ }\n`);
+      output.print(`Use ${output.colors.bold(colors.cyan(name))} as parameter in test scenarios to access this object:`)
+      output.print(`\nScenario('my new test', ({ I, ${name} })) { /** ... */ }\n`)
 
-    try {
-      generateDefinitions(testsPath, {});
-    } catch (_err) {
-      output.print(`Run ${colors.green('npx codeceptjs def')} to update your types to get auto-completion for object.`);
-    }
-  });
-};
+      try {
+        generateDefinitions(testsPath, {})
+      } catch (_err) {
+        output.print(
+          `Run ${colors.green('npx codeceptjs def')} to update your types to get auto-completion for object.`,
+        )
+      }
+    })
+}
 
 const helperTemplate = `const Helper = require('@codeceptjs/helper');
 
@@ -222,59 +227,64 @@ class {{name}} extends Helper {
 }
 
 module.exports = {{name}};
-`;
+`
 
 module.exports.helper = function (genPath) {
-  const testsPath = getTestRoot(genPath);
-
-  output.print('Creating a new helper');
-  output.print('--------------------------');
-
-  return inquirer.prompt([{
-    type: 'input',
-    name: 'name',
-    message: 'Name of a Helper',
-    validate: (val) => !!val,
-  }, {
-    type: 'input',
-    name: 'filename',
-    message: 'Where should it be stored',
-    default: answers => `./${answers.name.toLowerCase()}_helper.${extension}`,
-  }]).then((result) => {
-    const name = ucfirst(result.name);
-    const helperFile = path.join(testsPath, result.filename);
-    const dir = path.dirname(helperFile);
-    if (!fileExists(dir)) fs.mkdirSync(dir);
-
-    if (!safeFileWrite(helperFile, helperTemplate.replace(/{{name}}/g, name))) return;
-    output.success(`Helper for ${name} was created in ${helperFile}`);
-    output.print(`Update your config file (add to ${colors.cyan('helpers')} section):
+  const testsPath = getTestRoot(genPath)
+
+  output.print('Creating a new helper')
+  output.print('--------------------------')
+
+  return inquirer
+    .prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Name of a Helper',
+        validate: (val) => !!val,
+      },
+      {
+        type: 'input',
+        name: 'filename',
+        message: 'Where should it be stored',
+        default: (answers) => `./${answers.name.toLowerCase()}_helper.${extension}`,
+      },
+    ])
+    .then((result) => {
+      const name = ucfirst(result.name)
+      const helperFile = path.join(testsPath, result.filename)
+      const dir = path.dirname(helperFile)
+      if (!fileExists(dir)) fs.mkdirSync(dir)
+
+      if (!safeFileWrite(helperFile, helperTemplate.replace(/{{name}}/g, name))) return
+      output.success(`Helper for ${name} was created in ${helperFile}`)
+      output.print(`Update your config file (add to ${colors.cyan('helpers')} section):
 
 helpers: {
   ${name}: {
     require: '${result.filename}',
   },
 },
-    `);
-  });
-};
+    `)
+    })
+}
 
-const healTemplate = fs.readFileSync(path.join(__dirname, '../template/heal.js'), 'utf8').toString();
+const healTemplate = fs.readFileSync(path.join(__dirname, '../template/heal.js'), 'utf8').toString()
 
 module.exports.heal = function (genPath) {
-  const testsPath = getTestRoot(genPath);
+  const testsPath = getTestRoot(genPath)
 
-  let configFile = path.join(testsPath, `codecept.conf.${extension}`);
+  let configFile = path.join(testsPath, `codecept.conf.${extension}`)
 
   if (!fileExists(configFile)) {
-    configFile = path.join(testsPath, `codecept.conf.${extension}`);
-    if (fileExists(configFile)) extension = 'ts';
+    configFile = path.join(testsPath, `codecept.conf.${extension}`)
+    if (fileExists(configFile)) extension = 'ts'
   }
 
-  output.print('Creating basic heal recipes');
-  output.print(`Add your own custom recipes to ./heal.${extension} file`);
-  output.print('Require this file in the config file and enable heal plugin:');
-  output.print('--------------------------');
+  output.print('Creating basic heal recipes')
+  output.print(`Add your own custom recipes to ./heal.${extension} file`)
+  output.print('Require this file in the config file and enable heal plugin:')
+  output.print('--------------------------')
   output.print(`
 require('./heal')
 
@@ -286,9 +296,9 @@ exports.config = {
     }
   }
 }
-  `);
+  `)
 
-  const healFile = path.join(testsPath, `heal.${extension}`);
-  if (!safeFileWrite(healFile, healTemplate)) return;
-  output.success(`Heal recipes were created in ${healFile}`);
-};
+  const healFile = path.join(testsPath, `heal.${extension}`)
+  if (!safeFileWrite(healFile, healTemplate)) return
+  output.success(`Heal recipes were created in ${healFile}`)
+}
diff --git a/lib/command/info.js b/lib/command/info.js
index 933a469a6..55f9856c3 100644
--- a/lib/command/info.js
+++ b/lib/command/info.js
@@ -1,42 +1,44 @@
-const envinfo = require('envinfo');
+const envinfo = require('envinfo')
 
-const { getConfig, getTestRoot } = require('./utils');
-const Codecept = require('../codecept');
-const output = require('../output');
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const output = require('../output')
 
 module.exports = async function (path) {
-  const testsPath = getTestRoot(path);
-  const config = getConfig(testsPath);
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  const testsPath = getTestRoot(path)
+  const config = getConfig(testsPath)
+  const codecept = new Codecept(config, {})
+  codecept.init(testsPath)
 
-  output.print('\n Environment information:-\n');
-  const info = {};
-  info.codeceptVersion = Codecept.version();
-  info.nodeInfo = await envinfo.helpers.getNodeInfo();
-  info.osInfo = await envinfo.helpers.getOSInfo();
-  info.cpuInfo = await envinfo.helpers.getCPUInfo();
-  info.chromeInfo = await envinfo.helpers.getChromeInfo();
-  info.edgeInfo = await envinfo.helpers.getEdgeInfo();
-  info.firefoxInfo = await envinfo.helpers.getFirefoxInfo();
-  info.safariInfo = await envinfo.helpers.getSafariInfo();
-  const { helpers, plugins } = config;
-  info.helpers = helpers || "You don't use any helpers";
-  info.plugins = plugins || "You don't have any enabled plugins";
+  output.print('\n Environment information:-\n')
+  const info = {}
+  info.codeceptVersion = Codecept.version()
+  info.nodeInfo = await envinfo.helpers.getNodeInfo()
+  info.osInfo = await envinfo.helpers.getOSInfo()
+  info.cpuInfo = await envinfo.helpers.getCPUInfo()
+  info.chromeInfo = await envinfo.helpers.getChromeInfo()
+  info.edgeInfo = await envinfo.helpers.getEdgeInfo()
+  info.firefoxInfo = await envinfo.helpers.getFirefoxInfo()
+  info.safariInfo = await envinfo.helpers.getSafariInfo()
+  const { helpers, plugins } = config
+  info.helpers = helpers || "You don't use any helpers"
+  info.plugins = plugins || "You don't have any enabled plugins"
 
   for (const [key, value] of Object.entries(info)) {
     if (Array.isArray(value)) {
-      output.print(`${key}:  ${value[1]}`);
+      output.print(`${key}:  ${value[1]}`)
     } else {
-      output.print(`${key}:  ${JSON.stringify(value, null, ' ')}`);
+      output.print(`${key}:  ${JSON.stringify(value, null, ' ')}`)
     }
   }
-  output.print('***************************************');
-  output.print('If you have questions ask them in our Slack: http://bit.ly/chat-codeceptjs');
-  output.print('Or ask them on our discussion board: https://codecept.discourse.group/');
-  output.print('Please copy environment info when you report issues on GitHub: https://github.com/Codeception/CodeceptJS/issues');
-  output.print('***************************************');
-};
+  output.print('***************************************')
+  output.print('If you have questions ask them in our Slack: http://bit.ly/chat-codeceptjs')
+  output.print('Or ask them on our discussion board: https://codecept.discourse.group/')
+  output.print(
+    'Please copy environment info when you report issues on GitHub: https://github.com/Codeception/CodeceptJS/issues',
+  )
+  output.print('***************************************')
+}
 
 module.exports.getMachineInfo = async () => {
   const info = {
@@ -47,17 +49,17 @@ module.exports.getMachineInfo = async () => {
     edgeInfo: await envinfo.helpers.getEdgeInfo(),
     firefoxInfo: await envinfo.helpers.getFirefoxInfo(),
     safariInfo: await envinfo.helpers.getSafariInfo(),
-  };
+  }
 
-  output.print('***************************************');
+  output.print('***************************************')
   for (const [key, value] of Object.entries(info)) {
     if (Array.isArray(value)) {
-      output.print(`${key}:  ${value[1]}`);
+      output.print(`${key}:  ${value[1]}`)
     } else {
-      output.print(`${key}:  ${JSON.stringify(value, null, ' ')}`);
+      output.print(`${key}:  ${JSON.stringify(value, null, ' ')}`)
     }
   }
-  output.print('If you need more detailed info, just run this: npx codeceptjs info');
-  output.print('***************************************');
-  return info;
-};
+  output.print('If you need more detailed info, just run this: npx codeceptjs info')
+  output.print('***************************************')
+  return info
+}
diff --git a/lib/command/init.js b/lib/command/init.js
index 0e1321646..dc7027a77 100644
--- a/lib/command/init.js
+++ b/lib/command/init.js
@@ -1,37 +1,37 @@
-const colors = require('chalk');
-const fs = require('fs');
-const inquirer = require('inquirer');
-const mkdirp = require('mkdirp');
-const path = require('path');
-const { inspect } = require('util');
-const spawn = require('cross-spawn');
-
-const { print, success, error } = require('../output');
-const { fileExists, beautify, installedLocally } = require('../utils');
-const { getTestRoot } = require('./utils');
-const generateDefinitions = require('./definitions');
-const { test: generateTest } = require('./generate');
-const isLocal = require('../utils').installedLocally();
+const colors = require('chalk')
+const fs = require('fs')
+const inquirer = require('inquirer')
+const mkdirp = require('mkdirp')
+const path = require('path')
+const { inspect } = require('util')
+const spawn = require('cross-spawn')
+
+const { print, success, error } = require('../output')
+const { fileExists, beautify, installedLocally } = require('../utils')
+const { getTestRoot } = require('./utils')
+const generateDefinitions = require('./definitions')
+const { test: generateTest } = require('./generate')
+const isLocal = require('../utils').installedLocally()
 
 const defaultConfig = {
   tests: './*_test.js',
   output: '',
   helpers: {},
   include: {},
-};
+}
 
-const helpers = ['Playwright', 'WebDriver', 'Puppeteer', 'REST', 'GraphQL', 'Appium', 'TestCafe'];
-const translations = Object.keys(require('../../translations'));
+const helpers = ['Playwright', 'WebDriver', 'Puppeteer', 'REST', 'GraphQL', 'Appium', 'TestCafe']
+const translations = Object.keys(require('../../translations'))
 
-const noTranslation = 'English (no localization)';
-translations.unshift(noTranslation);
+const noTranslation = 'English (no localization)'
+translations.unshift(noTranslation)
 
-const packages = [];
-let isTypeScript = false;
-let extension = 'js';
+const packages = []
+let isTypeScript = false
+let extension = 'js'
 
-const requireCodeceptConfigure = "const { setHeadlessWhen, setCommonPlugins } = require('@codeceptjs/configure');";
-const importCodeceptConfigure = "import { setHeadlessWhen, setCommonPlugins } from '@codeceptjs/configure';";
+const requireCodeceptConfigure = "const { setHeadlessWhen, setCommonPlugins } = require('@codeceptjs/configure');"
+const importCodeceptConfigure = "import { setHeadlessWhen, setCommonPlugins } from '@codeceptjs/configure';"
 
 const configHeader = `
 // turn on headless mode when running with HEADLESS=true environment variable
@@ -41,7 +41,7 @@ setHeadlessWhen(process.env.HEADLESS);
 // enable all common plugins https://github.com/codeceptjs/configure#setcommonplugins
 setCommonPlugins();
 
-`;
+`
 
 const defaultActor = `// in this file you can append custom step methods to 'I' object
 
@@ -53,7 +53,7 @@ module.exports = function() {
 
   });
 }
-`;
+`
 
 const defaultActorTs = `// in this file you can append custom step methods to 'I' object
 
@@ -65,354 +65,357 @@ export = function() {
 
   });
 }
-`;
+`
 
 module.exports = function (initPath) {
-  const testsPath = getTestRoot(initPath);
-
-  print();
-  print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} initialization tool`);
-  print('  It will prepare and configure a test environment for you');
-  print();
-  print(' Useful links:');
-  print();
-  print('  👉 How to start testing ASAP: https://codecept.io/quickstart/#init');
-  print('  👉 How to select helper: https://codecept.io/basics/#architecture');
-  print('  👉 TypeScript setup: https://codecept.io/typescript/#getting-started');
-  print();
+  const testsPath = getTestRoot(initPath)
+
+  print()
+  print(`  Welcome to ${colors.magenta.bold('CodeceptJS')} initialization tool`)
+  print('  It will prepare and configure a test environment for you')
+  print()
+  print(' Useful links:')
+  print()
+  print('  👉 How to start testing ASAP: https://codecept.io/quickstart/#init')
+  print('  👉 How to select helper: https://codecept.io/basics/#architecture')
+  print('  👉 TypeScript setup: https://codecept.io/typescript/#getting-started')
+  print()
 
   if (!path) {
-    print('No test root specified.');
-    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`);
-    print('----------------------------------');
+    print('No test root specified.')
+    print(`Test root is assumed to be ${colors.yellow.bold(testsPath)}`)
+    print('----------------------------------')
   } else {
-    print(`Installing to ${colors.bold(testsPath)}`);
+    print(`Installing to ${colors.bold(testsPath)}`)
   }
 
   if (!fileExists(testsPath)) {
-    print(`Directory ${testsPath} does not exist, creating...`);
-    mkdirp.sync(testsPath);
+    print(`Directory ${testsPath} does not exist, creating...`)
+    mkdirp.sync(testsPath)
   }
 
-  const configFile = path.join(testsPath, 'codecept.conf.js');
+  const configFile = path.join(testsPath, 'codecept.conf.js')
   if (fileExists(configFile)) {
-    error(`Config is already created at ${configFile}`);
-    return;
+    error(`Config is already created at ${configFile}`)
+    return
   }
 
-  const typeScriptconfigFile = path.join(testsPath, 'codecept.conf.ts');
+  const typeScriptconfigFile = path.join(testsPath, 'codecept.conf.ts')
   if (fileExists(typeScriptconfigFile)) {
-    error(`Config is already created at ${typeScriptconfigFile}`);
-    return;
+    error(`Config is already created at ${typeScriptconfigFile}`)
+    return
   }
 
-  inquirer.prompt([
-    {
-      name: 'typescript',
-      type: 'confirm',
-      default: false,
-      message: 'Do you plan to write tests in TypeScript?',
-    },
-    {
-      name: 'tests',
-      type: 'input',
-      default: (answers) => `./*_test.${answers.typescript ? 'ts' : 'js'}`,
-      message: 'Where are your tests located?',
-    },
-    {
-      name: 'helper',
-      type: 'list',
-      choices: helpers,
-      default: 'Playwright',
-      message: 'What helpers do you want to use?',
-    },
-    {
-      name: 'jsonResponse',
-      type: 'confirm',
-      default: true,
-      message: 'Do you want to use JSONResponse helper for assertions on JSON responses? http://bit.ly/3ASVPy9',
-      when: (answers) => ['GraphQL', 'REST'].includes(answers.helper) === true,
-    },
-    {
-      name: 'output',
-      default: './output',
-      message: 'Where should logs, screenshots, and reports to be stored?',
-    },
-    {
-      name: 'translation',
-      type: 'list',
-      message: 'Do you want to enable localization for tests? http://bit.ly/3GNUBbh',
-      choices: translations,
-    },
-  ]).then((result) => {
-    if (result.typescript === true) {
-      isTypeScript = true;
-      extension = isTypeScript === true ? 'ts' : 'js';
-      packages.push('typescript');
-      packages.push('ts-node');
-      packages.push('@types/node');
-    }
-
-    const config = defaultConfig;
-    config.name = testsPath.split(path.sep).pop();
-    config.output = result.output;
+  inquirer
+    .prompt([
+      {
+        name: 'typescript',
+        type: 'confirm',
+        default: false,
+        message: 'Do you plan to write tests in TypeScript?',
+      },
+      {
+        name: 'tests',
+        type: 'input',
+        default: (answers) => `./*_test.${answers.typescript ? 'ts' : 'js'}`,
+        message: 'Where are your tests located?',
+      },
+      {
+        name: 'helper',
+        type: 'list',
+        choices: helpers,
+        default: 'Playwright',
+        message: 'What helpers do you want to use?',
+      },
+      {
+        name: 'jsonResponse',
+        type: 'confirm',
+        default: true,
+        message: 'Do you want to use JSONResponse helper for assertions on JSON responses? http://bit.ly/3ASVPy9',
+        when: (answers) => ['GraphQL', 'REST'].includes(answers.helper) === true,
+      },
+      {
+        name: 'output',
+        default: './output',
+        message: 'Where should logs, screenshots, and reports to be stored?',
+      },
+      {
+        name: 'translation',
+        type: 'list',
+        message: 'Do you want to enable localization for tests? http://bit.ly/3GNUBbh',
+        choices: translations,
+      },
+    ])
+    .then((result) => {
+      if (result.typescript === true) {
+        isTypeScript = true
+        extension = isTypeScript === true ? 'ts' : 'js'
+        packages.push('typescript')
+        packages.push('ts-node')
+        packages.push('@types/node')
+      }
 
-    config.tests = result.tests;
-    if (isTypeScript) {
-      config.tests = `${config.tests.replace(/\.js$/, `.${extension}`)}`;
-    }
+      const config = defaultConfig
+      config.name = testsPath.split(path.sep).pop()
+      config.output = result.output
 
-    // create a directory tests if it is included in tests path
-    const matchResults = config.tests.match(/[^*.]+/);
-    if (matchResults) {
-      mkdirp.sync(path.join(testsPath, matchResults[0]));
-    }
-
-    if (result.translation !== noTranslation) config.translation = result.translation;
+      config.tests = result.tests
+      if (isTypeScript) {
+        config.tests = `${config.tests.replace(/\.js$/, `.${extension}`)}`
+      }
 
-    const helperName = result.helper;
-    config.helpers[helperName] = {};
+      // create a directory tests if it is included in tests path
+      const matchResults = config.tests.match(/[^*.]+/)
+      if (matchResults) {
+        mkdirp.sync(path.join(testsPath, matchResults[0]))
+      }
 
-    if (result.jsonResponse === true) {
-      config.helpers.JSONResponse = {};
-    }
+      if (result.translation !== noTranslation) config.translation = result.translation
 
-    let helperConfigs = [];
+      const helperName = result.helper
+      config.helpers[helperName] = {}
 
-    try {
-      const Helper = require(`../helper/${helperName}`);
-      if (Helper._checkRequirements) {
-        packages.concat(Helper._checkRequirements());
+      if (result.jsonResponse === true) {
+        config.helpers.JSONResponse = {}
       }
 
-      if (!Helper._config()) return;
-      helperConfigs = helperConfigs.concat(Helper._config().map((config) => {
-        config.message = `[${helperName}] ${config.message}`;
-        config.name = `${helperName}_${config.name}`;
-        config.type = config.type || 'input';
-        return config;
-      }));
-    } catch (err) {
-      error(err);
-    }
+      let helperConfigs = []
 
-    const finish = async () => {
-      // create steps file by default
-      // no extra step file for typescript (as it doesn't match TS conventions)
-      const stepFile = `./steps_file.${extension}`;
-      fs.writeFileSync(path.join(testsPath, stepFile), extension === 'ts' ? defaultActorTs : defaultActor);
+      try {
+        const Helper = require(`../helper/${helperName}`)
+        if (Helper._checkRequirements) {
+          packages.concat(Helper._checkRequirements())
+        }
 
-      if (isTypeScript) {
-        config.include = _actorTranslation('./steps_file', config.translation);
-      } else {
-        config.include = _actorTranslation(stepFile, config.translation);
+        if (!Helper._config()) return
+        helperConfigs = helperConfigs.concat(
+          Helper._config().map((config) => {
+            config.message = `[${helperName}] ${config.message}`
+            config.name = `${helperName}_${config.name}`
+            config.type = config.type || 'input'
+            return config
+          }),
+        )
+      } catch (err) {
+        error(err)
       }
 
-      print(`Steps file created at ${stepFile}`);
+      const finish = async () => {
+        // create steps file by default
+        // no extra step file for typescript (as it doesn't match TS conventions)
+        const stepFile = `./steps_file.${extension}`
+        fs.writeFileSync(path.join(testsPath, stepFile), extension === 'ts' ? defaultActorTs : defaultActor)
 
-      let configSource;
-      const hasConfigure = isLocal && !initPath;
-
-      if (isTypeScript) {
-        configSource = beautify(`export const config : CodeceptJS.MainConfig = ${inspect(config, false, 4, false)}`);
+        if (isTypeScript) {
+          config.include = _actorTranslation('./steps_file', config.translation)
+        } else {
+          config.include = _actorTranslation(stepFile, config.translation)
+        }
 
-        if (hasConfigure) configSource = importCodeceptConfigure + configHeader + configSource;
+        print(`Steps file created at ${stepFile}`)
 
-        fs.writeFileSync(typeScriptconfigFile, configSource, 'utf-8');
-        print(`Config created at ${typeScriptconfigFile}`);
-      } else {
-        configSource = beautify(`/** @type {CodeceptJS.MainConfig} */\nexports.config = ${inspect(config, false, 4, false)}`);
+        let configSource
+        const hasConfigure = isLocal && !initPath
 
-        if (hasConfigure) configSource = requireCodeceptConfigure + configHeader + configSource;
+        if (isTypeScript) {
+          configSource = beautify(`export const config : CodeceptJS.MainConfig = ${inspect(config, false, 4, false)}`)
 
-        fs.writeFileSync(configFile, configSource, 'utf-8');
-        print(`Config created at ${configFile}`);
-      }
+          if (hasConfigure) configSource = importCodeceptConfigure + configHeader + configSource
 
-      if (config.output) {
-        if (!fileExists(config.output)) {
-          mkdirp.sync(path.join(testsPath, config.output));
-          print(`Directory for temporary output files created at '${config.output}'`);
+          fs.writeFileSync(typeScriptconfigFile, configSource, 'utf-8')
+          print(`Config created at ${typeScriptconfigFile}`)
         } else {
-          print(`Directory for temporary output files is already created at '${config.output}'`);
+          configSource = beautify(
+            `/** @type {CodeceptJS.MainConfig} */\nexports.config = ${inspect(config, false, 4, false)}`,
+          )
+
+          if (hasConfigure) configSource = requireCodeceptConfigure + configHeader + configSource
+
+          fs.writeFileSync(configFile, configSource, 'utf-8')
+          print(`Config created at ${configFile}`)
         }
-      }
 
-      const jsconfig = {
-        compilerOptions: {
-          allowJs: true,
-        },
-      };
-
-      const tsconfig = {
-        'ts-node': {
-          files: true,
-        },
-        compilerOptions: {
-          target: 'es2018',
-          lib: ['es2018', 'DOM'],
-          esModuleInterop: true,
-          module: 'commonjs',
-          strictNullChecks: false,
-          types: ['codeceptjs', 'node'],
-          declaration: true,
-          skipLibCheck: true,
-        },
-        exclude: ['node_modules'],
-      };
+        if (config.output) {
+          if (!fileExists(config.output)) {
+            mkdirp.sync(path.join(testsPath, config.output))
+            print(`Directory for temporary output files created at '${config.output}'`)
+          } else {
+            print(`Directory for temporary output files is already created at '${config.output}'`)
+          }
+        }
 
-      if (isTypeScript) {
-        const tsconfigJson = beautify(JSON.stringify(tsconfig));
-        const tsconfigFile = path.join(testsPath, 'tsconfig.json');
-        if (fileExists(tsconfigFile)) {
-          print(`tsconfig.json already exists at ${tsconfigFile}`);
-        } else {
-          fs.writeFileSync(tsconfigFile, tsconfigJson);
+        const jsconfig = {
+          compilerOptions: {
+            allowJs: true,
+          },
         }
-      } else {
-        const jsconfigJson = beautify(JSON.stringify(jsconfig));
-        const jsconfigFile = path.join(testsPath, 'jsconfig.json');
-        if (fileExists(jsconfigFile)) {
-          print(`jsconfig.json already exists at ${jsconfigFile}`);
+
+        const tsconfig = {
+          'ts-node': {
+            files: true,
+          },
+          compilerOptions: {
+            target: 'es2018',
+            lib: ['es2018', 'DOM'],
+            esModuleInterop: true,
+            module: 'commonjs',
+            strictNullChecks: false,
+            types: ['codeceptjs', 'node'],
+            declaration: true,
+            skipLibCheck: true,
+          },
+          exclude: ['node_modules'],
+        }
+
+        if (isTypeScript) {
+          const tsconfigJson = beautify(JSON.stringify(tsconfig))
+          const tsconfigFile = path.join(testsPath, 'tsconfig.json')
+          if (fileExists(tsconfigFile)) {
+            print(`tsconfig.json already exists at ${tsconfigFile}`)
+          } else {
+            fs.writeFileSync(tsconfigFile, tsconfigJson)
+          }
         } else {
-          fs.writeFileSync(jsconfigFile, jsconfigJson);
-          print(`Intellisense enabled in ${jsconfigFile}`);
+          const jsconfigJson = beautify(JSON.stringify(jsconfig))
+          const jsconfigFile = path.join(testsPath, 'jsconfig.json')
+          if (fileExists(jsconfigFile)) {
+            print(`jsconfig.json already exists at ${jsconfigFile}`)
+          } else {
+            fs.writeFileSync(jsconfigFile, jsconfigJson)
+            print(`Intellisense enabled in ${jsconfigFile}`)
+          }
         }
-      }
 
-      const generateDefinitionsManually = colors.bold(`To get auto-completion support, please generate type definitions: ${colors.green('npx codeceptjs def')}`);
+        const generateDefinitionsManually = colors.bold(
+          `To get auto-completion support, please generate type definitions: ${colors.green('npx codeceptjs def')}`,
+        )
+
+        if (packages) {
+          try {
+            install(packages)
+          } catch (err) {
+            print(colors.bold.red(err.toString()))
+            print()
+            print(colors.bold.red('Please install next packages manually:'))
+            print(`npm i ${packages.join(' ')} --save-dev`)
+            print()
+            print('Things to do after missing packages installed:')
+            print('☑', generateDefinitionsManually)
+            print('☑ Create first test:', colors.green('npx codeceptjs gt'))
+            print(colors.bold.magenta('Find more information at https://codecept.io'))
+            return
+          }
+        }
 
-      if (packages) {
         try {
-          install(packages);
+          generateDefinitions(testsPath, {})
         } catch (err) {
-          print(colors.bold.red(err.toString()));
-          print();
-          print(colors.bold.red('Please install next packages manually:'));
-          print(`npm i ${packages.join(' ')} --save-dev`);
-          print();
-          print('Things to do after missing packages installed:');
-          print('☑', generateDefinitionsManually);
-          print('☑ Create first test:', colors.green('npx codeceptjs gt'));
-          print(colors.bold.magenta('Find more information at https://codecept.io'));
-          return;
+          print(colors.bold.red("Couldn't generate type definitions"))
+          print(colors.red(err.toString()))
+          print('Skipping type definitions...')
+          print(generateDefinitionsManually)
         }
-      }
 
-      try {
-        generateDefinitions(testsPath, {});
-      } catch (err) {
-        print(colors.bold.red('Couldn\'t generate type definitions'));
-        print(colors.red(err.toString()));
-        print('Skipping type definitions...');
-        print(generateDefinitionsManually);
+        print('')
+        success(' Almost ready... Next step:')
+
+        const generatedTest = generateTest(testsPath)
+        if (!generatedTest) return
+        generatedTest.then(() => {
+          print('\n--')
+          print(colors.bold.green('CodeceptJS Installed! Enjoy supercharged testing! 🤩'))
+          print(colors.bold.magenta('Find more information at https://codecept.io'))
+          print()
+        })
       }
 
-      print('');
-      success(' Almost ready... Next step:');
-
-      const generatedTest = generateTest(testsPath);
-      if (!generatedTest) return;
-      generatedTest.then(() => {
-        print('\n--');
-        print(colors.bold.green('CodeceptJS Installed! Enjoy supercharged testing! 🤩'));
-        print(colors.bold.magenta('Find more information at https://codecept.io'));
-        print();
-      });
-    };
-
-    print('Configure helpers...');
-    inquirer.prompt(helperConfigs).then(async (helperResult) => {
-      if (helperResult.Playwright_browser === 'electron') {
-        delete helperResult.Playwright_url;
-        delete helperResult.Playwright_show;
-
-        helperResult.Playwright_electron = {
-          executablePath: '// require("electron") or require("electron-forge")',
-          args: ['path/to/your/main.js'],
-        };
-      }
+      print('Configure helpers...')
+      inquirer.prompt(helperConfigs).then(async (helperResult) => {
+        if (helperResult.Playwright_browser === 'electron') {
+          delete helperResult.Playwright_url
+          delete helperResult.Playwright_show
 
-      Object.keys(helperResult).forEach((key) => {
-        const parts = key.split('_');
-        const helperName = parts[0];
-        const configName = parts[1];
-        if (!configName) return;
-        config.helpers[helperName][configName] = helperResult[key];
-      });
-
-      print('');
-      await finish();
-    });
-  });
-};
+          helperResult.Playwright_electron = {
+            executablePath: '// require("electron") or require("electron-forge")',
+            args: ['path/to/your/main.js'],
+          }
+        }
+
+        Object.keys(helperResult).forEach((key) => {
+          const parts = key.split('_')
+          const helperName = parts[0]
+          const configName = parts[1]
+          if (!configName) return
+          config.helpers[helperName][configName] = helperResult[key]
+        })
+
+        print('')
+        await finish()
+      })
+    })
+}
 
 function install(dependencies) {
-  let command;
-  let args;
+  let command
+  let args
 
   if (!fs.existsSync(path.join(process.cwd(), 'package.json'))) {
-    dependencies.push('codeceptjs');
-    throw new Error("Error: 'package.json' file not found. Generate it with 'npm init -y' command.");
+    dependencies.push('codeceptjs')
+    throw new Error("Error: 'package.json' file not found. Generate it with 'npm init -y' command.")
   }
 
   if (!installedLocally()) {
-    console.log('CodeceptJS should be installed locally');
-    dependencies.push('codeceptjs');
+    console.log('CodeceptJS should be installed locally')
+    dependencies.push('codeceptjs')
   }
 
-  console.log('Installing packages: ', colors.green(dependencies.join(', ')));
+  console.log('Installing packages: ', colors.green(dependencies.join(', ')))
 
   if (fileExists('yarn.lock')) {
-    command = 'yarnpkg';
-    args = ['add', '-D', '--exact'];
-    [].push.apply(args, dependencies);
+    command = 'yarnpkg'
+    args = ['add', '-D', '--exact']
+    ;[].push.apply(args, dependencies)
 
-    args.push('--cwd');
-    args.push(process.cwd());
+    args.push('--cwd')
+    args.push(process.cwd())
   } else {
-    command = 'npm';
-    args = [
-      'install',
-      '--save-dev',
-      '--loglevel',
-      'error',
-    ].concat(dependencies);
+    command = 'npm'
+    args = ['install', '--save-dev', '--loglevel', 'error'].concat(dependencies)
   }
 
   if (process.env._INIT_DRY_RUN_INSTALL) {
-    args.push('--dry-run');
+    args.push('--dry-run')
   }
 
-  const { status } = spawn.sync(command, args, { stdio: 'inherit' });
+  const { status } = spawn.sync(command, args, { stdio: 'inherit' })
   if (status !== 0) {
-    throw new Error(`${command} ${args.join(' ')} failed`);
+    throw new Error(`${command} ${args.join(' ')} failed`)
   }
-  return true;
+  return true
 }
 
 function _actorTranslation(stepFile, translationSelected) {
-  let actor;
+  let actor
 
   for (const translationAvailable of translations) {
     if (actor) {
-      break;
+      break
     }
 
     if (translationSelected === translationAvailable) {
-      const nameOfActor = require('../../translations')[translationAvailable].I;
+      const nameOfActor = require('../../translations')[translationAvailable].I
 
       actor = {
         [nameOfActor]: stepFile,
-      };
+      }
     }
   }
 
   if (!actor) {
     actor = {
       I: stepFile,
-    };
+    }
   }
 
-  return actor;
+  return actor
 }
diff --git a/lib/command/interactive.js b/lib/command/interactive.js
index e3a33536a..7f92cbec8 100644
--- a/lib/command/interactive.js
+++ b/lib/command/interactive.js
@@ -1,55 +1,55 @@
-const { getConfig, getTestRoot } = require('./utils');
-const recorder = require('../recorder');
-const Codecept = require('../codecept');
-const Container = require('../container');
-const event = require('../event');
-const output = require('../output');
-const webHelpers = require('../plugin/standardActingHelpers');
+const { getConfig, getTestRoot } = require('./utils')
+const recorder = require('../recorder')
+const Codecept = require('../codecept')
+const Container = require('../container')
+const event = require('../event')
+const output = require('../output')
+const webHelpers = require('../plugin/standardActingHelpers')
 
 module.exports = async function (path, options) {
   // Backward compatibility for --profile
-  process.profile = options.profile;
-  process.env.profile = options.profile;
-  const configFile = options.config;
+  process.profile = options.profile
+  process.env.profile = options.profile
+  const configFile = options.config
 
-  const config = getConfig(configFile);
-  const testsPath = getTestRoot(configFile);
+  const config = getConfig(configFile)
+  const testsPath = getTestRoot(configFile)
 
-  const codecept = new Codecept(config, options);
-  codecept.init(testsPath);
+  const codecept = new Codecept(config, options)
+  codecept.init(testsPath)
 
   try {
-    await codecept.bootstrap();
+    await codecept.bootstrap()
 
-    if (options.verbose) output.level(3);
+    if (options.verbose) output.level(3)
 
-    output.print('Starting interactive shell for current suite...');
-    recorder.start();
+    output.print('Starting interactive shell for current suite...')
+    recorder.start()
     event.emit(event.suite.before, {
       fullTitle: () => 'Interactive Shell',
       tests: [],
-    });
+    })
     event.emit(event.test.before, {
       title: '',
       artifacts: {},
-    });
+    })
 
-    const enabledHelpers = Container.helpers();
+    const enabledHelpers = Container.helpers()
     for (const helperName of Object.keys(enabledHelpers)) {
       if (webHelpers.includes(helperName)) {
-        const I = enabledHelpers[helperName];
-        recorder.add(() => I.amOnPage('/'));
-        recorder.catchWithoutStop(e => output.print(`Error while loading home page: ${e.message}}`));
-        break;
+        const I = enabledHelpers[helperName]
+        recorder.add(() => I.amOnPage('/'))
+        recorder.catchWithoutStop((e) => output.print(`Error while loading home page: ${e.message}}`))
+        break
       }
     }
-    require('../pause')();
+    require('../pause')()
     // recorder.catchWithoutStop((err) => console.log(err.stack));
-    recorder.add(() => event.emit(event.test.after, {}));
-    recorder.add(() => event.emit(event.suite.after, {}));
-    recorder.add(() => event.emit(event.all.result, {}));
-    recorder.add(() => codecept.teardown());
+    recorder.add(() => event.emit(event.test.after, {}))
+    recorder.add(() => event.emit(event.suite.after, {}))
+    recorder.add(() => event.emit(event.all.result, {}))
+    recorder.add(() => codecept.teardown())
   } catch (err) {
-    output.error(`Error while running bootstrap file :${err}`);
+    output.error(`Error while running bootstrap file :${err}`)
   }
-};
+}
diff --git a/lib/command/list.js b/lib/command/list.js
index 3a14e5942..47a1047c9 100644
--- a/lib/command/list.js
+++ b/lib/command/list.js
@@ -1,36 +1,36 @@
-const { getConfig, getTestRoot } = require('./utils');
-const Codecept = require('../codecept');
-const container = require('../container');
-const { getParamsToString } = require('../parser');
-const { methodsOfObject } = require('../utils');
-const output = require('../output');
+const { getConfig, getTestRoot } = require('./utils')
+const Codecept = require('../codecept')
+const container = require('../container')
+const { getParamsToString } = require('../parser')
+const { methodsOfObject } = require('../utils')
+const output = require('../output')
 
 module.exports = function (path) {
-  const testsPath = getTestRoot(path);
-  const config = getConfig(testsPath);
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+  const testsPath = getTestRoot(path)
+  const config = getConfig(testsPath)
+  const codecept = new Codecept(config, {})
+  codecept.init(testsPath)
 
-  output.print('List of test actions: -- ');
-  const helpers = container.helpers();
-  const supportI = container.support('I');
-  const actions = [];
+  output.print('List of test actions: -- ')
+  const helpers = container.helpers()
+  const supportI = container.support('I')
+  const actions = []
   for (const name in helpers) {
-    const helper = helpers[name];
+    const helper = helpers[name]
     methodsOfObject(helper).forEach((action) => {
-      const params = getParamsToString(helper[action]);
-      actions[action] = 1;
-      output.print(` ${output.colors.grey(name)} I.${output.colors.bold(action)}(${params})`);
-    });
+      const params = getParamsToString(helper[action])
+      actions[action] = 1
+      output.print(` ${output.colors.grey(name)} I.${output.colors.bold(action)}(${params})`)
+    })
   }
   for (const name in supportI) {
     if (actions[name]) {
-      continue;
+      continue
     }
-    const actor = supportI[name];
-    const params = getParamsToString(actor);
-    output.print(` I.${output.colors.bold(name)}(${params})`);
+    const actor = supportI[name]
+    const params = getParamsToString(actor)
+    output.print(` I.${output.colors.bold(name)}(${params})`)
   }
-  output.print('PS: Actions are retrieved from enabled helpers. ');
-  output.print('Implement custom actions in your helper classes.');
-};
+  output.print('PS: Actions are retrieved from enabled helpers. ')
+  output.print('Implement custom actions in your helper classes.')
+}
diff --git a/lib/command/run-multiple.js b/lib/command/run-multiple.js
index 228cbb36c..0600b4372 100644
--- a/lib/command/run-multiple.js
+++ b/lib/command/run-multiple.js
@@ -1,186 +1,206 @@
-const { fork } = require('child_process');
-const path = require('path');
-const crypto = require('crypto');
-
-const runHook = require('../hooks');
-const event = require('../event');
-const collection = require('./run-multiple/collection');
-const { clearString, replaceValueDeep } = require('../utils');
-const {
-  getConfig, getTestRoot, fail,
-} = require('./utils');
-
-const runner = path.join(__dirname, '/../../bin/codecept');
-let config;
-const childOpts = {};
-const copyOptions = ['override', 'steps', 'reporter', 'verbose', 'config', 'reporter-options', 'grep', 'fgrep', 'invert', 'debug', 'plugins', 'colors'];
-let overrides = {};
+const { fork } = require('child_process')
+const path = require('path')
+const crypto = require('crypto')
+
+const runHook = require('../hooks')
+const event = require('../event')
+const collection = require('./run-multiple/collection')
+const { clearString, replaceValueDeep } = require('../utils')
+const { getConfig, getTestRoot, fail } = require('./utils')
+
+const runner = path.join(__dirname, '/../../bin/codecept')
+let config
+const childOpts = {}
+const copyOptions = [
+  'override',
+  'steps',
+  'reporter',
+  'verbose',
+  'config',
+  'reporter-options',
+  'grep',
+  'fgrep',
+  'invert',
+  'debug',
+  'plugins',
+  'colors',
+]
+let overrides = {}
 
 // codeceptjs run-multiple smoke:chrome regression:firefox - will launch smoke run in chrome and regression in firefox
 // codeceptjs run-multiple smoke:chrome regression - will launch smoke run in chrome and regression in firefox and chrome
 // codeceptjs run-multiple --all - will launch all runs
 // codeceptjs run-multiple smoke regression'
 
-let runId = 1;
-let subprocessCount = 0;
-let totalSubprocessCount = 0;
-let processesDone;
+let runId = 1
+let subprocessCount = 0
+let totalSubprocessCount = 0
+let processesDone
 
 module.exports = async function (selectedRuns, options) {
   // registering options globally to use in config
   if (options.profile) {
-    process.env.profile = options.profile;
+    process.env.profile = options.profile
   }
-  const configFile = options.config;
+  const configFile = options.config
 
-  const testRoot = getTestRoot(configFile);
-  global.codecept_dir = testRoot;
+  const testRoot = getTestRoot(configFile)
+  global.codecept_dir = testRoot
 
   // copy opts to run
   Object.keys(options)
-    .filter(key => copyOptions.indexOf(key) > -1)
+    .filter((key) => copyOptions.indexOf(key) > -1)
     .forEach((key) => {
-      childOpts[key] = options[key];
-    });
+      childOpts[key] = options[key]
+    })
 
   try {
-    overrides = JSON.parse(childOpts.override);
-    delete childOpts.override;
+    overrides = JSON.parse(childOpts.override)
+    delete childOpts.override
   } catch (e) {
-    overrides = {};
+    overrides = {}
   }
 
   config = {
     ...getConfig(configFile),
     ...overrides,
-  };
+  }
 
   if (!config.multiple) {
-    fail('Multiple runs not configured, add "multiple": { /../ } section to config');
+    fail('Multiple runs not configured, add "multiple": { /../ } section to config')
   }
 
-  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns;
+  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns
   if (!selectedRuns.length) {
-    fail('No runs provided. Use --all option to run all configured runs');
+    fail('No runs provided. Use --all option to run all configured runs')
   }
 
-  await runHook(config.bootstrapAll, 'bootstrapAll');
+  await runHook(config.bootstrapAll, 'bootstrapAll')
 
-  event.emit(event.multiple.before, null);
-  if (options.config) { // update paths to config path
+  event.emit(event.multiple.before, null)
+  if (options.config) {
+    // update paths to config path
     if (config.tests) {
-      config.tests = path.resolve(testRoot, config.tests);
+      config.tests = path.resolve(testRoot, config.tests)
     }
     if (config.gherkin && config.gherkin.features) {
-      config.gherkin.features = path.resolve(testRoot, config.gherkin.features);
+      config.gherkin.features = path.resolve(testRoot, config.gherkin.features)
     }
   }
 
   if (options.features) {
-    config.tests = '';
+    config.tests = ''
   }
 
   if (options.tests && config.gherkin) {
-    config.gherkin.features = '';
+    config.gherkin.features = ''
   }
 
   const childProcessesPromise = new Promise((resolve) => {
-    processesDone = resolve;
-  });
+    processesDone = resolve
+  })
 
-  const runsToExecute = [];
+  const runsToExecute = []
   collection.createRuns(selectedRuns, config).forEach((run) => {
-    const runName = run.getOriginalName() || run.getName();
-    const runConfig = run.getConfig();
-    runsToExecute.push(executeRun(runName, runConfig));
-  });
+    const runName = run.getOriginalName() || run.getName()
+    const runConfig = run.getConfig()
+    runsToExecute.push(executeRun(runName, runConfig))
+  })
 
   if (!runsToExecute.length) {
-    fail('Nothing scheduled for execution');
+    fail('Nothing scheduled for execution')
   }
 
   // Execute all forks
-  totalSubprocessCount = runsToExecute.length;
-  runsToExecute.forEach(runToExecute => runToExecute.call(this));
+  totalSubprocessCount = runsToExecute.length
+  runsToExecute.forEach((runToExecute) => runToExecute.call(this))
 
   return childProcessesPromise.then(async () => {
     // fire hook
-    await runHook(config.teardownAll, 'teardownAll');
-    event.emit(event.multiple.after, null);
-  });
-};
+    await runHook(config.teardownAll, 'teardownAll')
+    event.emit(event.multiple.after, null)
+  })
+}
 
 function executeRun(runName, runConfig) {
   // clone config
-  let overriddenConfig = { ...config };
+  let overriddenConfig = { ...config }
 
   // get configuration
-  const browserConfig = runConfig.browser;
-  const browserName = browserConfig.browser;
+  const browserConfig = runConfig.browser
+  const browserName = browserConfig.browser
 
   for (const key in browserConfig) {
-    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key]);
+    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key])
   }
 
-  let outputDir = `${runName}_`;
+  let outputDir = `${runName}_`
   if (browserConfig.outputName) {
-    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName;
+    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName
   } else {
-    const hash = crypto.createHash('sha256');
-    hash.update(JSON.stringify(browserConfig));
-    outputDir += hash.digest('hex');
+    const hash = crypto.createHash('sha256')
+    hash.update(JSON.stringify(browserConfig))
+    outputDir += hash.digest('hex')
   }
-  outputDir += `_${runId}`;
+  outputDir += `_${runId}`
 
-  outputDir = clearString(outputDir);
+  outputDir = clearString(outputDir)
 
   // tweaking default output directories and for mochawesome
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir));
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir));
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir))
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir))
+  overriddenConfig = replaceValueDeep(
+    overriddenConfig,
+    'mochaFile',
+    path.join(config.output, outputDir, `${browserName}_report.xml`),
+  )
 
   // override tests configuration
   if (overriddenConfig.tests) {
-    overriddenConfig.tests = runConfig.tests;
+    overriddenConfig.tests = runConfig.tests
   }
 
   if (overriddenConfig.gherkin && runConfig.gherkin && runConfig.gherkin.features) {
-    overriddenConfig.gherkin.features = runConfig.gherkin.features;
+    overriddenConfig.gherkin.features = runConfig.gherkin.features
   }
 
   // override grep param and collect all params
-  const params = ['run',
-    '--child', `${runId++}.${runName}:${browserName}`,
-    '--override', JSON.stringify(overriddenConfig),
-  ];
+  const params = [
+    'run',
+    '--child',
+    `${runId++}.${runName}:${browserName}`,
+    '--override',
+    JSON.stringify(overriddenConfig),
+  ]
 
   Object.keys(childOpts).forEach((key) => {
-    params.push(`--${key}`);
-    if (childOpts[key] !== true) params.push(childOpts[key]);
-  });
+    params.push(`--${key}`)
+    if (childOpts[key] !== true) params.push(childOpts[key])
+  })
 
   if (runConfig.grep) {
-    params.push('--grep');
-    params.push(runConfig.grep);
+    params.push('--grep')
+    params.push(runConfig.grep)
   }
 
   const onProcessEnd = (errorCode) => {
     if (errorCode !== 0) {
-      process.exitCode = errorCode;
+      process.exitCode = errorCode
     }
-    subprocessCount += 1;
+    subprocessCount += 1
     if (subprocessCount === totalSubprocessCount) {
-      processesDone();
+      processesDone()
     }
-    return errorCode;
-  };
+    return errorCode
+  }
 
   // Return function of fork for later execution
-  return () => fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
-    .on('exit', (code) => {
-      return onProcessEnd(code);
-    })
-    .on('error', () => {
-      return onProcessEnd(1);
-    });
+  return () =>
+    fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
+      .on('exit', (code) => {
+        return onProcessEnd(code)
+      })
+      .on('error', () => {
+        return onProcessEnd(1)
+      })
 }
diff --git a/lib/command/run-rerun.js b/lib/command/run-rerun.js
index a104bbaa6..62f17bdae 100644
--- a/lib/command/run-rerun.js
+++ b/lib/command/run-rerun.js
@@ -1,38 +1,38 @@
-const { getConfig, getTestRoot } = require('./utils');
-const { printError, createOutputDir } = require('./utils');
-const Config = require('../config');
-const Codecept = require('../rerun');
+const { getConfig, getTestRoot } = require('./utils')
+const { printError, createOutputDir } = require('./utils')
+const Config = require('../config')
+const Codecept = require('../rerun')
 
 module.exports = async function (test, options) {
   // registering options globally to use in config
   // Backward compatibility for --profile
-  process.profile = options.profile;
-  process.env.profile = options.profile;
-  const configFile = options.config;
+  process.profile = options.profile
+  process.env.profile = options.profile
+  const configFile = options.config
 
-  let config = getConfig(configFile);
+  let config = getConfig(configFile)
   if (options.override) {
-    config = Config.append(JSON.parse(options.override));
+    config = Config.append(JSON.parse(options.override))
   }
-  const testRoot = getTestRoot(configFile);
-  createOutputDir(config, testRoot);
+  const testRoot = getTestRoot(configFile)
+  createOutputDir(config, testRoot)
 
   function processError(err) {
-    printError(err);
-    process.exit(1);
+    printError(err)
+    process.exit(1)
   }
-  const codecept = new Codecept(config, options);
+  const codecept = new Codecept(config, options)
 
   try {
-    codecept.init(testRoot);
+    codecept.init(testRoot)
 
-    await codecept.bootstrap();
-    codecept.loadTests(test);
-    await codecept.run();
+    await codecept.bootstrap()
+    codecept.loadTests(test)
+    await codecept.run()
   } catch (err) {
-    printError(err);
-    process.exitCode = 1;
+    printError(err)
+    process.exitCode = 1
   } finally {
-    await codecept.teardown();
+    await codecept.teardown()
   }
-};
+}
diff --git a/lib/command/run-workers.js b/lib/command/run-workers.js
index 4b968b971..caae6f6cd 100644
--- a/lib/command/run-workers.js
+++ b/lib/command/run-workers.js
@@ -1,89 +1,89 @@
 // For Node version >=10.5.0, have to use experimental flag
-const { tryOrDefault } = require('../utils');
-const output = require('../output');
-const store = require('../store');
-const event = require('../event');
-const Workers = require('../workers');
+const { tryOrDefault } = require('../utils')
+const output = require('../output')
+const store = require('../store')
+const event = require('../event')
+const Workers = require('../workers')
 
 module.exports = async function (workerCount, selectedRuns, options) {
-  process.env.profile = options.profile;
-
-  const suiteArr = [];
-  const passedTestArr = [];
-  const failedTestArr = [];
-  const skippedTestArr = [];
-  const stepArr = [];
-
-  const { config: testConfig, override = '' } = options;
-  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {});
-  const by = options.suites ? 'suite' : 'test';
-  delete options.parent;
+  process.env.profile = options.profile
+
+  const suiteArr = []
+  const passedTestArr = []
+  const failedTestArr = []
+  const skippedTestArr = []
+  const stepArr = []
+
+  const { config: testConfig, override = '' } = options
+  const overrideConfigs = tryOrDefault(() => JSON.parse(override), {})
+  const by = options.suites ? 'suite' : 'test'
+  delete options.parent
   const config = {
     by,
     testConfig,
     options,
     selectedRuns,
-  };
+  }
 
-  const numberOfWorkers = parseInt(workerCount, 10);
+  const numberOfWorkers = parseInt(workerCount, 10)
 
-  output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`);
-  output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`);
-  output.print();
+  output.print(`CodeceptJS v${require('../codecept').version()} ${output.standWithUkraine()}`)
+  output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
+  output.print()
 
-  const workers = new Workers(numberOfWorkers, config);
-  workers.overrideConfig(overrideConfigs);
+  const workers = new Workers(numberOfWorkers, config)
+  workers.overrideConfig(overrideConfigs)
 
   workers.on(event.suite.before, (suite) => {
-    suiteArr.push(suite);
-  });
+    suiteArr.push(suite)
+  })
 
   workers.on(event.step.passed, (step) => {
-    stepArr.push(step);
-  });
+    stepArr.push(step)
+  })
 
   workers.on(event.step.failed, (step) => {
-    stepArr.push(step);
-  });
+    stepArr.push(step)
+  })
 
   workers.on(event.test.failed, (test) => {
-    failedTestArr.push(test);
-    output.test.failed(test);
-  });
+    failedTestArr.push(test)
+    output.test.failed(test)
+  })
 
   workers.on(event.test.passed, (test) => {
-    passedTestArr.push(test);
-    output.test.passed(test);
-  });
+    passedTestArr.push(test)
+    output.test.passed(test)
+  })
 
   workers.on(event.test.skipped, (test) => {
-    skippedTestArr.push(test);
-    output.test.skipped(test);
-  });
+    skippedTestArr.push(test)
+    output.test.skipped(test)
+  })
 
   workers.on(event.all.result, () => {
     // expose test stats after all workers finished their execution
     function addStepsToTest(test, stepArr) {
-      stepArr.test.steps.forEach(step => {
+      stepArr.test.steps.forEach((step) => {
         if (test.steps.length === 0) {
-          test.steps.push(step);
+          test.steps.push(step)
         }
-      });
+      })
     }
 
-    stepArr.forEach(step => {
-      passedTestArr.forEach(test => {
+    stepArr.forEach((step) => {
+      passedTestArr.forEach((test) => {
         if (step.test.title === test.title) {
-          addStepsToTest(test, step);
+          addStepsToTest(test, step)
         }
-      });
+      })
 
-      failedTestArr.forEach(test => {
+      failedTestArr.forEach((test) => {
         if (step.test.title === test.title) {
-          addStepsToTest(test, step);
+          addStepsToTest(test, step)
         }
-      });
-    });
+      })
+    })
 
     event.dispatcher.emit(event.workers.result, {
       suites: suiteArr,
@@ -92,24 +92,24 @@ module.exports = async function (workerCount, selectedRuns, options) {
         failed: failedTestArr,
         skipped: skippedTestArr,
       },
-    });
-    workers.printResults();
-  });
+    })
+    workers.printResults()
+  })
 
   try {
-    if (options.verbose || options.debug) store.debugMode = true;
+    if (options.verbose || options.debug) store.debugMode = true
 
     if (options.verbose) {
-      global.debugMode = true;
-      const { getMachineInfo } = require('./info');
-      await getMachineInfo();
+      global.debugMode = true
+      const { getMachineInfo } = require('./info')
+      await getMachineInfo()
     }
-    await workers.bootstrapAll();
-    await workers.run();
+    await workers.bootstrapAll()
+    await workers.run()
   } catch (err) {
-    output.error(err);
-    process.exit(1);
+    output.error(err)
+    process.exit(1)
   } finally {
-    await workers.teardownAll();
+    await workers.teardownAll()
   }
-};
+}
diff --git a/lib/command/run.js b/lib/command/run.js
index ec3248e24..e76257404 100644
--- a/lib/command/run.js
+++ b/lib/command/run.js
@@ -1,48 +1,46 @@
-const {
-  getConfig, printError, getTestRoot, createOutputDir,
-} = require('./utils');
-const Config = require('../config');
-const store = require('../store');
-const Codecept = require('../codecept');
+const { getConfig, printError, getTestRoot, createOutputDir } = require('./utils')
+const Config = require('../config')
+const store = require('../store')
+const Codecept = require('../codecept')
 
 module.exports = async function (test, options) {
   // registering options globally to use in config
   // Backward compatibility for --profile
   // TODO: remove in CodeceptJS 4
-  process.profile = options.profile;
+  process.profile = options.profile
 
   if (options.profile) {
-    process.env.profile = options.profile;
+    process.env.profile = options.profile
   }
-  if (options.verbose || options.debug) store.debugMode = true;
+  if (options.verbose || options.debug) store.debugMode = true
 
-  const configFile = options.config;
+  const configFile = options.config
 
-  let config = getConfig(configFile);
+  let config = getConfig(configFile)
   if (options.override) {
-    config = Config.append(JSON.parse(options.override));
+    config = Config.append(JSON.parse(options.override))
   }
-  const testRoot = getTestRoot(configFile);
-  createOutputDir(config, testRoot);
+  const testRoot = getTestRoot(configFile)
+  createOutputDir(config, testRoot)
 
-  const codecept = new Codecept(config, options);
+  const codecept = new Codecept(config, options)
 
   try {
-    codecept.init(testRoot);
-    await codecept.bootstrap();
-    codecept.loadTests(test);
+    codecept.init(testRoot)
+    await codecept.bootstrap()
+    codecept.loadTests(test)
 
     if (options.verbose) {
-      global.debugMode = true;
-      const { getMachineInfo } = require('./info');
-      await getMachineInfo();
+      global.debugMode = true
+      const { getMachineInfo } = require('./info')
+      await getMachineInfo()
     }
 
-    await codecept.run();
+    await codecept.run()
   } catch (err) {
-    printError(err);
-    process.exitCode = 1;
+    printError(err)
+    process.exitCode = 1
   } finally {
-    await codecept.teardown();
+    await codecept.teardown()
   }
-};
+}
diff --git a/lib/command/utils.js b/lib/command/utils.js
index 60ceee8a1..cb5620b79 100644
--- a/lib/command/utils.js
+++ b/lib/command/utils.js
@@ -1,117 +1,118 @@
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-const mkdirp = require('mkdirp');
+const fs = require('fs')
+const path = require('path')
+const util = require('util')
+const mkdirp = require('mkdirp')
 
-const output = require('../output');
-const { fileExists, beautify } = require('../utils');
+const output = require('../output')
+const { fileExists, beautify } = require('../utils')
 
 // alias to deep merge
-module.exports.deepMerge = require('../utils').deepMerge;
+module.exports.deepMerge = require('../utils').deepMerge
 
 module.exports.getConfig = function (configFile) {
   try {
-    return require('../config').load(configFile);
+    return require('../config').load(configFile)
   } catch (err) {
-    fail(err.stack);
+    fail(err.stack)
   }
-};
+}
 
 module.exports.readConfig = function (configFile) {
   try {
-    const data = fs.readFileSync(configFile, 'utf8');
-    return data;
+    const data = fs.readFileSync(configFile, 'utf8')
+    return data
   } catch (err) {
-    output.error(err);
+    output.error(err)
   }
-};
+}
 
 function getTestRoot(currentPath) {
-  if (!currentPath) currentPath = '.';
-  if (!path.isAbsolute(currentPath)) currentPath = path.join(process.cwd(), currentPath);
-  currentPath = fs.lstatSync(currentPath).isDirectory() || !path.extname(currentPath) ? currentPath : path.dirname(currentPath);
-  return currentPath;
+  if (!currentPath) currentPath = '.'
+  if (!path.isAbsolute(currentPath)) currentPath = path.join(process.cwd(), currentPath)
+  currentPath =
+    fs.lstatSync(currentPath).isDirectory() || !path.extname(currentPath) ? currentPath : path.dirname(currentPath)
+  return currentPath
 }
-module.exports.getTestRoot = getTestRoot;
+module.exports.getTestRoot = getTestRoot
 
 function fail(msg) {
-  output.error(msg);
-  process.exit(1);
+  output.error(msg)
+  process.exit(1)
 }
 
-module.exports.fail = fail;
+module.exports.fail = fail
 
 function updateConfig(testsPath, config, extension) {
-  const configFile = path.join(testsPath, `codecept.conf.${extension}`);
+  const configFile = path.join(testsPath, `codecept.conf.${extension}`)
   if (!fileExists(configFile)) {
-    const msg = `codecept.conf.${extension} config can\'t be updated automatically`;
-    console.log();
-    console.log(`${output.colors.bold.red(msg)}`);
-    console.log(`${output.colors.bold.red('Please update it manually:')}`);
-    console.log();
-    console.log(config);
-    console.log();
-    return;
+    const msg = `codecept.conf.${extension} config can\'t be updated automatically`
+    console.log()
+    console.log(`${output.colors.bold.red(msg)}`)
+    console.log(`${output.colors.bold.red('Please update it manually:')}`)
+    console.log()
+    console.log(config)
+    console.log()
+    return
   }
-  console.log(`${output.colors.yellow('Updating configuration file...')}`);
-  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8');
+  console.log(`${output.colors.yellow('Updating configuration file...')}`)
+  return fs.writeFileSync(configFile, beautify(`exports.config = ${util.inspect(config, false, 4, false)}`), 'utf-8')
 }
 
-module.exports.updateConfig = updateConfig;
+module.exports.updateConfig = updateConfig
 
 function safeFileWrite(file, contents) {
   if (fileExists(file)) {
-    output.error(`File ${file} already exist, skipping...`);
-    return false;
+    output.error(`File ${file} already exist, skipping...`)
+    return false
   }
-  fs.writeFileSync(file, contents);
-  return true;
+  fs.writeFileSync(file, contents)
+  return true
 }
 
-module.exports.safeFileWrite = safeFileWrite;
+module.exports.safeFileWrite = safeFileWrite
 
 module.exports.captureStream = (stream) => {
-  let oldStream;
-  let buffer = '';
+  let oldStream
+  let buffer = ''
 
   return {
     startCapture() {
-      buffer = '';
-      oldStream = stream.write.bind(stream);
-      stream.write = chunk => (buffer += chunk);
+      buffer = ''
+      oldStream = stream.write.bind(stream)
+      stream.write = (chunk) => (buffer += chunk)
     },
     stopCapture() {
-      if (oldStream !== undefined) stream.write = oldStream;
+      if (oldStream !== undefined) stream.write = oldStream
     },
     getData: () => buffer,
-  };
-};
+  }
+}
 
 module.exports.printError = (err) => {
-  output.print('');
-  output.error(err.message);
-  output.print('');
-  output.print(output.colors.grey(err.stack.replace(err.message, '')));
-};
+  output.print('')
+  output.error(err.message)
+  output.print('')
+  output.print(output.colors.grey(err.stack.replace(err.message, '')))
+}
 
 module.exports.createOutputDir = (config, testRoot) => {
-  let outputDir;
-  if (path.isAbsolute(config.output)) outputDir = config.output;
-  else outputDir = path.join(testRoot, config.output);
+  let outputDir
+  if (path.isAbsolute(config.output)) outputDir = config.output
+  else outputDir = path.join(testRoot, config.output)
 
   if (!fileExists(outputDir)) {
-    output.print(`creating output directory: ${outputDir}`);
-    mkdirp.sync(outputDir);
+    output.print(`creating output directory: ${outputDir}`)
+    mkdirp.sync(outputDir)
   }
-};
+}
 
 module.exports.findConfigFile = (testsPath) => {
-  const extensions = ['js', 'ts'];
+  const extensions = ['js', 'ts']
   for (const ext of extensions) {
-    const configFile = path.join(testsPath, `codecept.conf.${ext}`);
+    const configFile = path.join(testsPath, `codecept.conf.${ext}`)
     if (fileExists(configFile)) {
-      return configFile;
+      return configFile
     }
   }
-  return null;
-};
+  return null
+}
diff --git a/lib/data/context.js b/lib/data/context.js
index 4d6d21bdf..82f3897f8 100644
--- a/lib/data/context.js
+++ b/lib/data/context.js
@@ -1,129 +1,129 @@
-const { isGenerator } = require('../utils');
-const DataTable = require('./table');
-const DataScenarioConfig = require('./dataScenarioConfig');
-const Secret = require('../secret');
+const { isGenerator } = require('../utils')
+const DataTable = require('./table')
+const DataScenarioConfig = require('./dataScenarioConfig')
+const Secret = require('../secret')
 
 module.exports = function (context) {
   context.Data = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
       Scenario(title, opts, fn) {
-        const scenarios = [];
+        const scenarios = []
         if (typeof opts === 'function' && !fn) {
-          fn = opts;
-          opts = {};
+          fn = opts
+          opts = {}
         }
-        opts.data = data.map(dataRow => dataRow.data);
+        opts.data = data.map((dataRow) => dataRow.data)
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
+          const dataTitle = replaceTitle(title, dataRow)
           if (dataRow.skip) {
-            context.xScenario(dataTitle);
+            context.xScenario(dataTitle)
           } else {
-            scenarios.push(context.Scenario(dataTitle, opts, fn)
-              .inject({ current: dataRow.data }));
+            scenarios.push(context.Scenario(dataTitle, opts, fn).inject({ current: dataRow.data }))
           }
-        });
-        maskSecretInTitle(scenarios);
-        return new DataScenarioConfig(scenarios);
+        })
+        maskSecretInTitle(scenarios)
+        return new DataScenarioConfig(scenarios)
       },
       only: {
         Scenario(title, opts, fn) {
-          const scenarios = [];
+          const scenarios = []
           if (typeof opts === 'function' && !fn) {
-            fn = opts;
-            opts = {};
+            fn = opts
+            opts = {}
           }
-          opts.data = data.map(dataRow => dataRow.data);
+          opts.data = data.map((dataRow) => dataRow.data)
           data.forEach((dataRow) => {
-            const dataTitle = replaceTitle(title, dataRow);
+            const dataTitle = replaceTitle(title, dataRow)
             if (dataRow.skip) {
-              context.xScenario(dataTitle);
+              context.xScenario(dataTitle)
             } else {
-              scenarios.push(context.Scenario.only(dataTitle, opts, fn)
-                .inject({ current: dataRow.data }));
+              scenarios.push(context.Scenario.only(dataTitle, opts, fn).inject({ current: dataRow.data }))
             }
-          });
-          maskSecretInTitle(scenarios);
-          return new DataScenarioConfig(scenarios);
+          })
+          maskSecretInTitle(scenarios)
+          return new DataScenarioConfig(scenarios)
         },
       },
-    };
-  };
+    }
+  }
 
   context.xData = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
       Scenario: (title) => {
         data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
-          context.xScenario(dataTitle);
-        });
-        return new DataScenarioConfig([]);
+          const dataTitle = replaceTitle(title, dataRow)
+          context.xScenario(dataTitle)
+        })
+        return new DataScenarioConfig([])
       },
-    };
-  };
-};
+    }
+  }
+}
 
 function replaceTitle(title, dataRow) {
   if (typeof dataRow.data !== 'object') {
-    return `${title} | {${JSON.stringify(dataRow.data)}}`;
+    return `${title} | {${JSON.stringify(dataRow.data)}}`
   }
 
   // if `dataRow` is object and has own `toString()` method,
   // it should be printed
-  if (Object.prototype.toString.call(dataRow.data) === (Object()).toString()
-    && dataRow.data.toString() !== (Object()).toString()) {
-    return `${title} | ${dataRow.data}`;
+  if (
+    Object.prototype.toString.call(dataRow.data) === Object().toString() &&
+    dataRow.data.toString() !== Object().toString()
+  ) {
+    return `${title} | ${dataRow.data}`
   }
 
-  return `${title} | ${JSON.stringify(dataRow.data)}`;
+  return `${title} | ${JSON.stringify(dataRow.data)}`
 }
 
 function isTableDataRow(row) {
-  const has = Object.prototype.hasOwnProperty;
-  return has.call(row, 'data') && has.call(row, 'skip');
+  const has = Object.prototype.hasOwnProperty
+  return has.call(row, 'data') && has.call(row, 'skip')
 }
 
 function detectDataType(dataTable) {
   if (dataTable instanceof DataTable) {
-    return dataTable.rows;
+    return dataTable.rows
   }
 
   if (isGenerator(dataTable)) {
-    const data = [];
+    const data = []
     for (const dataRow of dataTable()) {
       data.push({
         data: dataRow,
-      });
+      })
     }
-    return data;
+    return data
   }
   if (typeof dataTable === 'function') {
-    return dataTable();
+    return dataTable()
   }
   if (Array.isArray(dataTable)) {
     return dataTable.map((item) => {
       if (isTableDataRow(item)) {
-        return item;
+        return item
       }
       return {
         data: item,
         skip: false,
-      };
-    });
+      }
+    })
   }
 
-  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function');
+  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function')
 }
 
 function maskSecretInTitle(scenarios) {
-  scenarios.forEach(scenario => {
-    const res = [];
+  scenarios.forEach((scenario) => {
+    const res = []
 
-    scenario.test.title.split(',').forEach(item => {
-      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'));
-    });
+    scenario.test.title.split(',').forEach((item) => {
+      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'))
+    })
 
-    scenario.test.title = res.join(',');
-  });
+    scenario.test.title = res.join(',')
+  })
 }
diff --git a/lib/data/dataScenarioConfig.js b/lib/data/dataScenarioConfig.js
index 9cb9173f7..9d6977819 100644
--- a/lib/data/dataScenarioConfig.js
+++ b/lib/data/dataScenarioConfig.js
@@ -1,84 +1,84 @@
 class DataScenarioConfig {
   constructor(scenarios) {
-    this.scenarios = scenarios;
+    this.scenarios = scenarios
   }
 
   /**
-     * Declares that test throws error.
-     * Can pass an Error object or regex matching expected message.
-     *
-     * @param {*} err
-     */
+   * Declares that test throws error.
+   * Can pass an Error object or regex matching expected message.
+   *
+   * @param {*} err
+   */
   throws(err) {
-    this.scenarios.forEach(scenario => scenario.throws(err));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.throws(err))
+    return this
   }
 
   /**
-     * Declares that test should fail.
-     * If test passes - throws an error.
-     * Can pass an Error object or regex matching expected message.
-     *
-     */
+   * Declares that test should fail.
+   * If test passes - throws an error.
+   * Can pass an Error object or regex matching expected message.
+   *
+   */
   fails() {
-    this.scenarios.forEach(scenario => scenario.fails());
-    return this;
+    this.scenarios.forEach((scenario) => scenario.fails())
+    return this
   }
 
   /**
-     * Retry this test for x times
-     *
-     * @param {*} retries
-     */
+   * Retry this test for x times
+   *
+   * @param {*} retries
+   */
   retry(retries) {
-    this.scenarios.forEach(scenario => scenario.retry(retries));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.retry(retries))
+    return this
   }
 
   /**
-     * Set timeout for this test
-     * @param {*} timeout
-     */
+   * Set timeout for this test
+   * @param {*} timeout
+   */
   timeout(timeout) {
-    this.scenarios.forEach(scenario => scenario.timeout(timeout));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.timeout(timeout))
+    return this
   }
 
   /**
-     * Configures a helper.
-     * Helper name can be omitted and values will be applied to first helper.
-     */
+   * Configures a helper.
+   * Helper name can be omitted and values will be applied to first helper.
+   */
   config(helper, obj) {
-    this.scenarios.forEach(scenario => scenario.config(helper, obj));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.config(helper, obj))
+    return this
   }
 
   /**
-     * Append a tag name to scenario title
-     * @param {*} tagName
-     */
+   * Append a tag name to scenario title
+   * @param {*} tagName
+   */
   tag(tagName) {
-    this.scenarios.forEach(scenario => scenario.tag(tagName));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.tag(tagName))
+    return this
   }
 
   /**
-     * Pass in additional objects to inject into test
-     * @param {*} obj
-     */
+   * Pass in additional objects to inject into test
+   * @param {*} obj
+   */
   inject(obj) {
-    this.scenarios.forEach(scenario => scenario.inject(obj));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.inject(obj))
+    return this
   }
 
   /**
-     * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
-     * @param {*} dependencies
-     */
+   * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
+   * @param {*} dependencies
+   */
   injectDependencies(dependencies) {
-    this.scenarios.forEach(scenario => scenario.injectDependencies(dependencies));
-    return this;
+    this.scenarios.forEach((scenario) => scenario.injectDependencies(dependencies))
+    return this
   }
 }
 
-module.exports = DataScenarioConfig;
+module.exports = DataScenarioConfig
diff --git a/lib/data/dataTableArgument.js b/lib/data/dataTableArgument.js
index b32953483..7d1a72d32 100644
--- a/lib/data/dataTableArgument.js
+++ b/lib/data/dataTableArgument.js
@@ -7,60 +7,60 @@ class DataTableArgument {
   constructor(gherkinDataTable) {
     this.rawData = gherkinDataTable.rows.map((row) => {
       return row.cells.map((cell) => {
-        return cell.value;
-      });
-    });
+        return cell.value
+      })
+    })
   }
 
   /** Returns the table as a 2-D array
-  * @returns {string[][]}
-  */
+   * @returns {string[][]}
+   */
   raw() {
-    return this.rawData.slice(0);
+    return this.rawData.slice(0)
   }
 
   /** Returns the table as a 2-D array, without the first row
-  * @returns {string[][]}
-  */
+   * @returns {string[][]}
+   */
   rows() {
-    const copy = this.raw();
-    copy.shift();
-    return copy;
+    const copy = this.raw()
+    copy.shift()
+    return copy
   }
 
   /** Returns an array of objects where each row is converted to an object (column header is the key)
-  * @returns {any[]}
-  */
+   * @returns {any[]}
+   */
   hashes() {
-    const copy = this.raw();
-    const header = copy.shift();
+    const copy = this.raw()
+    const header = copy.shift()
     return copy.map((row) => {
-      const r = {};
-      row.forEach((cell, index) => r[header[index]] = cell);
-      return r;
-    });
+      const r = {}
+      row.forEach((cell, index) => (r[header[index]] = cell))
+      return r
+    })
   }
 
   /** Returns an object where each row corresponds to an entry
    * (first column is the key, second column is the value)
-  * @returns {Record<string, string>}
-  */
+   * @returns {Record<string, string>}
+   */
   rowsHash() {
-    const rows = this.raw();
-    const everyRowHasTwoColumns = rows.every((row) => row.length === 2);
+    const rows = this.raw()
+    const everyRowHasTwoColumns = rows.every((row) => row.length === 2)
     if (!everyRowHasTwoColumns) {
-      throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns');
+      throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns')
     }
     /** @type {Record<string, string>} */
-    const result = {};
-    rows.forEach((x) => (result[x[0]] = x[1]));
-    return result;
+    const result = {}
+    rows.forEach((x) => (result[x[0]] = x[1]))
+    return result
   }
 
   /** Transposed the data */
   transpose() {
-    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]));
+    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]))
   }
 }
 
-module.exports = DataTableArgument;
+module.exports = DataTableArgument
diff --git a/lib/data/table.js b/lib/data/table.js
index 20981a65a..841e444dc 100644
--- a/lib/data/table.js
+++ b/lib/data/table.js
@@ -4,40 +4,46 @@
 class DataTable {
   /** @param {Array<*>} array */
   constructor(array) {
-    this.array = array;
-    this.rows = new Array(0);
+    this.array = array
+    this.rows = new Array(0)
   }
 
   /** @param {Array<*>} array */
   add(array) {
-    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`);
-    const tempObj = {};
-    let arrayCounter = 0;
+    if (array.length !== this.array.length)
+      throw new Error(
+        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
+      )
+    const tempObj = {}
+    let arrayCounter = 0
     this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: false, data: tempObj });
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: false, data: tempObj })
   }
 
   /** @param {Array<*>} array */
   xadd(array) {
-    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`);
-    const tempObj = {};
-    let arrayCounter = 0;
+    if (array.length !== this.array.length)
+      throw new Error(
+        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
+      )
+    const tempObj = {}
+    let arrayCounter = 0
     this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: true, data: tempObj });
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: true, data: tempObj })
   }
 
   /** @param {Function} func */
   filter(func) {
-    return this.rows.filter(row => func(row.data));
+    return this.rows.filter((row) => func(row.data))
   }
 }
 
-module.exports = DataTable;
+module.exports = DataTable
diff --git a/lib/helper/AI.js b/lib/helper/AI.js
index b00d33e67..d59b15531 100644
--- a/lib/helper/AI.js
+++ b/lib/helper/AI.js
@@ -1,47 +1,52 @@
-const Helper = require('@codeceptjs/helper');
-const ora = require('ora-classic');
-const fs = require('fs');
-const path = require('path');
-const ai = require('../ai');
-const standardActingHelpers = require('../plugin/standardActingHelpers');
-const Container = require('../container');
-const { splitByChunks, minifyHtml } = require('../html');
-const { beautify } = require('../utils');
-const output = require('../output');
-const { registerVariable } = require('../pause');
+const Helper = require('@codeceptjs/helper')
+const ora = require('ora-classic')
+const fs = require('fs')
+const path = require('path')
+const ai = require('../ai')
+const standardActingHelpers = require('../plugin/standardActingHelpers')
+const Container = require('../container')
+const { splitByChunks, minifyHtml } = require('../html')
+const { beautify } = require('../utils')
+const output = require('../output')
+const { registerVariable } = require('../pause')
+
+const gtpRole = {
+  user: 'user',
+}
 
 /**
  * AI Helper for CodeceptJS.
  *
  * This helper class provides integration with the AI GPT-3.5 or 4 language model for generating responses to questions or prompts within the context of web pages. It allows you to interact with the GPT-3.5 model to obtain intelligent responses based on HTML fragments or general prompts.
- * This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDrvier to ensure the HTML context is available.
+ * This helper should be enabled with any web helpers like Playwright or Puppeteer or WebDriver to ensure the HTML context is available.
  *
  * Use it only in development mode. It is recommended to run it only inside pause() mode.
  *
  * ## Configuration
  *
- * This helper should be configured in codecept.json or codecept.conf.js
+ * This helper should be configured in codecept.conf.{js|ts}
  *
  * * `chunkSize`: (optional, default: 80000) - The maximum number of characters to send to the AI API at once. We split HTML fragments by 8000 chars to not exceed token limit. Increase this value if you use GPT-4.
  */
 class AI extends Helper {
   constructor(config) {
-    super(config);
-    this.aiAssistant = ai;
+    super(config)
+    this.aiAssistant = ai
 
     this.options = {
       chunkSize: 80000,
-    };
-    this.options = { ...this.options, ...config };
+    }
+    this.options = { ...this.options, ...config }
+    this.aiAssistant.enable(this.config)
   }
 
   _beforeSuite() {
-    const helpers = Container.helpers();
+    const helpers = Container.helpers()
 
     for (const helperName of standardActingHelpers) {
       if (Object.keys(helpers).indexOf(helperName) > -1) {
-        this.helper = helpers[helperName];
-        break;
+        this.helper = helpers[helperName]
+        break
       }
     }
   }
@@ -58,30 +63,34 @@ class AI extends Helper {
    * @returns {Promise<string>} - A Promise that resolves to the generated responses from the GPT model, joined by newlines.
    */
   async askGptOnPage(prompt) {
-    const html = await this.helper.grabSource();
+    const html = await this.helper.grabSource()
 
-    const htmlChunks = splitByChunks(html, this.options.chunkSize);
+    const htmlChunks = splitByChunks(html, this.options.chunkSize)
 
-    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`);
+    if (htmlChunks.length > 1) this.debug(`Splitting HTML into ${htmlChunks.length} chunks`)
 
-    const responses = [];
+    const responses = []
 
     for (const chunk of htmlChunks) {
       const messages = [
-        { role: 'user', content: prompt },
-        { role: 'user', content: `Within this HTML: ${minifyHtml(chunk)}` },
-      ];
+        { role: gtpRole.user, content: prompt },
+        { role: gtpRole.user, content: `Within this HTML: ${minifyHtml(chunk)}` },
+      ]
 
-      if (htmlChunks.length > 1) messages.push({ role: 'user', content: 'If action is not possible on this page, do not propose anything, I will send another HTML fragment' });
+      if (htmlChunks.length > 1)
+        messages.push({
+          role: 'user',
+          content: 'If action is not possible on this page, do not propose anything, I will send another HTML fragment',
+        })
 
-      const response = await this._processAIRequest(messages);
+      const response = await this._processAIRequest(messages)
 
-      output.print(response);
+      output.print(response)
 
-      responses.push(response);
+      responses.push(response)
     }
 
-    return responses.join('\n\n');
+    return responses.join('\n\n')
   }
 
   /**
@@ -97,18 +106,18 @@ class AI extends Helper {
    * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
    */
   async askGptOnPageFragment(prompt, locator) {
-    const html = await this.helper.grabHTMLFrom(locator);
+    const html = await this.helper.grabHTMLFrom(locator)
 
     const messages = [
-      { role: 'user', content: prompt },
-      { role: 'user', content: `Within this HTML: ${minifyHtml(html)}` },
-    ];
+      { role: gtpRole.user, content: prompt },
+      { role: gtpRole.user, content: `Within this HTML: ${minifyHtml(html)}` },
+    ]
 
-    const response = await this._processAIRequest(messages);
+    const response = await this._processAIRequest(messages)
 
-    output.print(response);
+    output.print(response)
 
-    return response;
+    return response
   }
 
   /**
@@ -117,15 +126,13 @@ class AI extends Helper {
    * @returns {Promise<string>} - A Promise that resolves to the generated response from the GPT model.
    */
   async askGptGeneralPrompt(prompt) {
-    const messages = [
-      { role: 'user', content: prompt },
-    ];
+    const messages = [{ role: gtpRole.user, content: prompt }]
 
-    const response = await this._processAIRequest(messages);
+    const response = await this._processAIRequest(messages)
 
-    output.print(response);
+    output.print(response)
 
-    return response;
+    return response
   }
 
   /**
@@ -154,48 +161,53 @@ class AI extends Helper {
    * @returns {Promise<Object>} A promise that resolves to the requested page object.
    */
   async askForPageObject(pageName, extraPrompt = null, locator = null) {
-    const html = locator ? await this.helper.grabHTMLFrom(locator) : await this.helper.grabSource();
+    const spinner = ora(' Processing AI request...').start()
 
-    const spinner = ora(' Processing AI request...').start();
-    await this.aiAssistant.setHtmlContext(html);
-    const response = await this.aiAssistant.generatePageObject(extraPrompt, locator);
-    spinner.stop();
+    try {
+      const html = locator ? await this.helper.grabHTMLFrom(locator) : await this.helper.grabSource()
+      await this.aiAssistant.setHtmlContext(html)
+      const response = await this.aiAssistant.generatePageObject(extraPrompt, locator)
+      spinner.stop()
+
+      if (!response[0]) {
+        output.error('No response from AI')
+        return ''
+      }
 
-    if (!response[0]) {
-      output.error('No response from AI');
-      return '';
-    }
+      const code = beautify(response[0])
 
-    const code = beautify(response[0]);
+      output.print('----- Generated PageObject ----')
+      output.print(code)
+      output.print('-------------------------------')
 
-    output.print('----- Generated PageObject ----');
-    output.print(code);
-    output.print('-------------------------------');
+      const fileName = path.join(output_dir, `${pageName}Page-${Date.now()}.js`)
 
-    const fileName = path.join(output_dir, `${pageName}Page-${Date.now()}.js`);
+      output.print(output.styles.bold(`Page object for ${pageName} is saved to ${output.styles.bold(fileName)}`))
+      fs.writeFileSync(fileName, code)
 
-    output.print(output.styles.bold(`Page object for ${pageName} is saved to ${output.styles.bold(fileName)}`));
-    fs.writeFileSync(fileName, code);
+      try {
+        registerVariable('page', require(fileName))
+        output.success('Page object registered for this session as `page` variable')
+        output.print('Use `=>page.methodName()` in shell to run methods of page object')
+        output.print('Use `click(page.locatorName)` to check locators of page object')
+      } catch (err) {
+        output.error('Error while registering page object')
+        output.error(err.message)
+      }
 
-    try {
-      registerVariable('page', require(fileName));
-      output.success('Page object registered for this session as `page` variable');
-      output.print('Use `=>page.methodName()` in shell to run methods of page object');
-      output.print('Use `click(page.locatorName)` to check locators of page object');
-    } catch (err) {
-      output.error('Error while registering page object');
-      output.error(err.message);
+      return code
+    } catch (e) {
+      spinner.stop()
+      throw Error(`Something went wrong! ${e.message}`)
     }
-
-    return code;
   }
 
   async _processAIRequest(messages) {
-    const spinner = ora(' Processing AI request...').start();
-    const response = await this.aiAssistant.createCompletion(messages);
-    spinner.stop();
-    return response;
+    const spinner = ora(' Processing AI request...').start()
+    const response = await this.aiAssistant.createCompletion(messages)
+    spinner.stop()
+    return response
   }
 }
 
-module.exports = AI;
+module.exports = AI
diff --git a/lib/helper/ApiDataFactory.js b/lib/helper/ApiDataFactory.js
index e8f9c5dd6..ece565636 100644
--- a/lib/helper/ApiDataFactory.js
+++ b/lib/helper/ApiDataFactory.js
@@ -1,7 +1,7 @@
-const path = require('path');
+const path = require('path')
 
-const Helper = require('@codeceptjs/helper');
-const REST = require('./REST');
+const Helper = require('@codeceptjs/helper')
+const REST = require('./REST')
 
 /**
  * Helper for managing remote data using REST API.
@@ -184,67 +184,67 @@ const REST = require('./REST');
  */
 class ApiDataFactory extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
     const defaultConfig = {
       cleanup: true,
       REST: {},
       factories: {},
       returnId: false,
-    };
-    this.config = Object.assign(defaultConfig, this.config);
+    }
+    this.config = Object.assign(defaultConfig, this.config)
 
-    if (this.config.headers) this.config.REST.defaultHeaders = this.config.headers;
-    if (this.config.onRequest) this.config.REST.onRequest = this.config.onRequest;
-    this.restHelper = new REST(Object.assign(this.config.REST, { endpoint: this.config.endpoint }));
-    this.factories = this.config.factories;
+    if (this.config.headers) this.config.REST.defaultHeaders = this.config.headers
+    if (this.config.onRequest) this.config.REST.onRequest = this.config.onRequest
+    this.restHelper = new REST(Object.assign(this.config.REST, { endpoint: this.config.endpoint }))
+    this.factories = this.config.factories
 
     for (const factory in this.factories) {
-      const factoryConfig = this.factories[factory];
+      const factoryConfig = this.factories[factory]
       if (!factoryConfig.uri && !factoryConfig.create) {
         throw new Error(`Uri for factory "${factory}" is not defined. Please set "uri" parameter:
 
           "factories": {
             "${factory}": {
             "uri": ...
-        `);
+        `)
       }
 
-      if (!factoryConfig.create) factoryConfig.create = { post: factoryConfig.uri };
-      if (!factoryConfig.delete) factoryConfig.delete = { delete: `${factoryConfig.uri}/{id}` };
+      if (!factoryConfig.create) factoryConfig.create = { post: factoryConfig.uri }
+      if (!factoryConfig.delete) factoryConfig.delete = { delete: `${factoryConfig.uri}/{id}` }
 
-      this.factories[factory] = factoryConfig;
+      this.factories[factory] = factoryConfig
     }
 
-    this.created = {};
-    Object.keys(this.factories).forEach(f => this.created[f] = []);
+    this.created = {}
+    Object.keys(this.factories).forEach((f) => (this.created[f] = []))
   }
 
   static _checkRequirements() {
     try {
-      require('axios');
-      require('rosie');
+      require('axios')
+      require('rosie')
     } catch (e) {
-      return ['axios', 'rosie'];
+      return ['axios', 'rosie']
     }
   }
 
   _after() {
     if (!this.config.cleanup || this.config.cleanup === false) {
-      return Promise.resolve();
+      return Promise.resolve()
     }
-    const promises = [];
+    const promises = []
 
     // clean up all created items
     for (const factoryName in this.created) {
-      const createdItems = this.created[factoryName];
-      if (!createdItems.length) continue;
-      this.debug(`Deleting ${createdItems.length} ${factoryName}(s)`);
+      const createdItems = this.created[factoryName]
+      if (!createdItems.length) continue
+      this.debug(`Deleting ${createdItems.length} ${factoryName}(s)`)
       for (const id in createdItems) {
-        promises.push(this._requestDelete(factoryName, createdItems[id]));
+        promises.push(this._requestDelete(factoryName, createdItems[id]))
       }
     }
-    return Promise.all(promises);
+    return Promise.all(promises)
   }
 
   /**
@@ -266,9 +266,9 @@ class ApiDataFactory extends Helper {
    * @returns {Promise<*>}
    */
   have(factory, params, options) {
-    const item = this._createItem(factory, params, options);
-    this.debug(`Creating ${factory} ${JSON.stringify(item)}`);
-    return this._requestCreate(factory, item);
+    const item = this._createItem(factory, params, options)
+    this.debug(`Creating ${factory} ${JSON.stringify(item)}`)
+    return this._requestCreate(factory, item)
   }
 
   /**
@@ -291,27 +291,27 @@ class ApiDataFactory extends Helper {
    * @param {*} [options]
    */
   haveMultiple(factory, times, params, options) {
-    const promises = [];
+    const promises = []
     for (let i = 0; i < times; i++) {
-      promises.push(this.have(factory, params, options));
+      promises.push(this.have(factory, params, options))
     }
-    return Promise.all(promises);
+    return Promise.all(promises)
   }
 
   _createItem(model, data, options) {
     if (!this.factories[model]) {
-      throw new Error(`Factory ${model} is not defined in config`);
+      throw new Error(`Factory ${model} is not defined in config`)
     }
-    let modulePath = this.factories[model].factory;
+    let modulePath = this.factories[model].factory
     try {
       try {
-        require.resolve(modulePath);
+        require.resolve(modulePath)
       } catch (e) {
-        modulePath = path.join(global.codecept_dir, modulePath);
+        modulePath = path.join(global.codecept_dir, modulePath)
       }
       // check if the new syntax `export default new Factory()` is used and loads the builder, otherwise loads the module that used old syntax `module.exports = new Factory()`.
-      const builder = require(modulePath).default || require(modulePath);
-      return builder.build(data, options);
+      const builder = require(modulePath).default || require(modulePath)
+      return builder.build(data, options)
     } catch (err) {
       throw new Error(`Couldn't load factory file from ${modulePath}, check that
 
@@ -322,17 +322,17 @@ class ApiDataFactory extends Helper {
 points to valid factory file.
 Factory file should export an object with build method.
 
-Current file error: ${err.message}`);
+Current file error: ${err.message}`)
     }
   }
 
   _fetchId(body, factory) {
     if (this.config.factories[factory].fetchId) {
-      return this.config.factories[factory].fetchId(body);
+      return this.config.factories[factory].fetchId(body)
     }
-    if (body.id) return body.id;
-    if (body[factory] && body[factory].id) return body[factory].id;
-    return null;
+    if (body.id) return body.id
+    if (body[factory] && body[factory].id) return body[factory].id
+    return null
   }
 
   /**
@@ -343,27 +343,27 @@ Current file error: ${err.message}`);
    * @param {*} data
    */
   _requestCreate(factory, data) {
-    let request = createRequestFromFunction(this.factories[factory].create, data);
+    let request = createRequestFromFunction(this.factories[factory].create, data)
 
     if (!request) {
-      const method = Object.keys(this.factories[factory].create)[0];
-      const url = this.factories[factory].create[method];
+      const method = Object.keys(this.factories[factory].create)[0]
+      const url = this.factories[factory].create[method]
       request = {
         method,
         url,
         data,
-      };
+      }
     }
 
-    request.baseURL = this.config.endpoint;
+    request.baseURL = this.config.endpoint
 
     return this.restHelper._executeRequest(request).then((resp) => {
-      const id = this._fetchId(resp.data, factory);
-      this.created[factory].push(id);
-      this.debugSection('Created', `Id: ${id}`);
-      if (this.config.returnId) return id;
-      return resp.data;
-    });
+      const id = this._fetchId(resp.data, factory)
+      this.created[factory].push(id)
+      this.debugSection('Created', `Id: ${id}`)
+      if (this.config.returnId) return id
+      return resp.data
+    })
   }
 
   /**
@@ -374,37 +374,40 @@ Current file error: ${err.message}`);
    * @param {*} id
    */
   _requestDelete(factory, id) {
-    if (!this.factories[factory].delete) return;
-    let request = createRequestFromFunction(this.factories[factory].delete, id);
+    if (!this.factories[factory].delete) return
+    let request = createRequestFromFunction(this.factories[factory].delete, id)
 
     if (!request) {
-      const method = Object.keys(this.factories[factory].delete)[0];
+      const method = Object.keys(this.factories[factory].delete)[0]
 
-      const url = this.factories[factory].delete[method].replace('{id}', id);
+      const url = this.factories[factory].delete[method].replace('{id}', id)
 
       request = {
         method,
         url,
-      };
+      }
     }
 
-    request.baseURL = this.config.endpoint;
+    request.baseURL = this.config.endpoint
 
     if (request.url.match(/^undefined/)) {
-      return this.debugSection('Please configure the delete request in your ApiDataFactory helper', 'delete: () => ({ method: \'DELETE\',  url: \'/api/users\' })');
+      return this.debugSection(
+        'Please configure the delete request in your ApiDataFactory helper',
+        "delete: () => ({ method: 'DELETE',  url: '/api/users' })",
+      )
     }
 
     return this.restHelper._executeRequest(request).then(() => {
-      const idx = this.created[factory].indexOf(id);
-      this.debugSection('Deleted Id', `Id: ${id}`);
-      this.created[factory].splice(idx, 1);
-    });
+      const idx = this.created[factory].indexOf(id)
+      this.debugSection('Deleted Id', `Id: ${id}`)
+      this.created[factory].splice(idx, 1)
+    })
   }
 }
 
-module.exports = ApiDataFactory;
+module.exports = ApiDataFactory
 
 function createRequestFromFunction(param, data) {
-  if (typeof param !== 'function') return;
-  return param(data);
+  if (typeof param !== 'function') return
+  return param(data)
 }
diff --git a/lib/helper/Appium.js b/lib/helper/Appium.js
index b6f2953c4..58b17335b 100644
--- a/lib/helper/Appium.js
+++ b/lib/helper/Appium.js
@@ -1,26 +1,26 @@
-let webdriverio;
+let webdriverio
 
-const fs = require('fs');
-const axios = require('axios').default;
-const { v4: uuidv4 } = require('uuid');
+const fs = require('fs')
+const axios = require('axios').default
+const { v4: uuidv4 } = require('uuid')
 
-const Webdriver = require('./WebDriver');
-const AssertionFailedError = require('../assert/error');
-const { truth } = require('../assert/truth');
-const recorder = require('../recorder');
-const Locator = require('../locator');
-const ConnectionRefused = require('./errors/ConnectionRefused');
+const Webdriver = require('./WebDriver')
+const AssertionFailedError = require('../assert/error')
+const { truth } = require('../assert/truth')
+const recorder = require('../recorder')
+const Locator = require('../locator')
+const ConnectionRefused = require('./errors/ConnectionRefused')
 
-const mobileRoot = '//*';
-const webRoot = 'body';
+const mobileRoot = '//*'
+const webRoot = 'body'
 const supportedPlatform = {
   android: 'Android',
   iOS: 'iOS',
-};
+}
 
 const vendorPrefix = {
   appium: 'appium',
-};
+}
 
 /**
  *  Appium helper extends [Webdriver](http://codecept.io/helpers/WebDriver/) helper.
@@ -175,19 +175,21 @@ class Appium extends Webdriver {
 
   // @ts-ignore
   constructor(config) {
-    super(config);
+    super(config)
 
-    this.isRunning = false;
+    this.isRunning = false
     if (config.appiumV2 === true) {
-      this.appiumV2 = true;
+      this.appiumV2 = true
     }
-    this.axios = axios.create();
+    this.axios = axios.create()
 
-    webdriverio = require('webdriverio');
+    webdriverio = require('webdriverio')
     if (!config.appiumV2) {
-      console.log('The Appium core team does not maintain Appium 1.x anymore since the 1st of January 2022. Please migrating to Appium 2.x by adding appiumV2: true to your config.');
-      console.log('More info: https://bit.ly/appium-v2-migration');
-      console.log('This Appium 1.x support will be removed in next major release.');
+      console.log(
+        'The Appium core team does not maintain Appium 1.x anymore since the 1st of January 2022. Please migrating to Appium 2.x by adding appiumV2: true to your config.',
+      )
+      console.log('More info: https://bit.ly/appium-v2-migration')
+      console.log('This Appium 1.x support will be removed in next major release.')
     }
   }
 
@@ -204,7 +206,7 @@ class Appium extends Webdriver {
               }
             }
           }
-      `);
+      `)
     }
 
     // set defaults
@@ -225,166 +227,174 @@ class Appium extends Webdriver {
       timeouts: {
         script: 0, // ms
       },
-    };
+    }
 
     // override defaults with config
-    config = Object.assign(defaults, config);
+    config = Object.assign(defaults, config)
 
-    config.baseUrl = config.url || config.baseUrl;
+    config.baseUrl = config.url || config.baseUrl
     if (config.desiredCapabilities && Object.keys(config.desiredCapabilities).length) {
-      config.capabilities = this.appiumV2 === true ? this._convertAppiumV2Caps(config.desiredCapabilities) : config.desiredCapabilities;
+      config.capabilities =
+        this.appiumV2 === true ? this._convertAppiumV2Caps(config.desiredCapabilities) : config.desiredCapabilities
     }
 
     if (this.appiumV2) {
-      config.capabilities[`${vendorPrefix.appium}:deviceName`] = config[`${vendorPrefix.appium}:device`] || config.capabilities[`${vendorPrefix.appium}:deviceName`];
-      config.capabilities[`${vendorPrefix.appium}:browserName`] = config[`${vendorPrefix.appium}:browser`] || config.capabilities[`${vendorPrefix.appium}:browserName`];
-      config.capabilities[`${vendorPrefix.appium}:app`] = config[`${vendorPrefix.appium}:app`] || config.capabilities[`${vendorPrefix.appium}:app`];
-      config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] = config[`${vendorPrefix.appium}:tunnelIdentifier`] || config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`]; // Adding the code to connect to sauce labs via sauce tunnel
+      config.capabilities[`${vendorPrefix.appium}:deviceName`] =
+        config[`${vendorPrefix.appium}:device`] || config.capabilities[`${vendorPrefix.appium}:deviceName`]
+      config.capabilities[`${vendorPrefix.appium}:browserName`] =
+        config[`${vendorPrefix.appium}:browser`] || config.capabilities[`${vendorPrefix.appium}:browserName`]
+      config.capabilities[`${vendorPrefix.appium}:app`] =
+        config[`${vendorPrefix.appium}:app`] || config.capabilities[`${vendorPrefix.appium}:app`]
+      config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] =
+        config[`${vendorPrefix.appium}:tunnelIdentifier`] ||
+        config.capabilities[`${vendorPrefix.appium}:tunnelIdentifier`] // Adding the code to connect to sauce labs via sauce tunnel
     } else {
-      config.capabilities.deviceName = config.device || config.capabilities.deviceName;
-      config.capabilities.browserName = config.browser || config.capabilities.browserName;
-      config.capabilities.app = config.app || config.capabilities.app;
-      config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier; // Adding the code to connect to sauce labs via sauce tunnel
+      config.capabilities.deviceName = config.device || config.capabilities.deviceName
+      config.capabilities.browserName = config.browser || config.capabilities.browserName
+      config.capabilities.app = config.app || config.capabilities.app
+      config.capabilities.tunnelIdentifier = config.tunnelIdentifier || config.capabilities.tunnelIdentifier // Adding the code to connect to sauce labs via sauce tunnel
     }
 
-    config.capabilities.platformName = config.platform || config.capabilities.platformName;
-    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000; // convert to seconds
+    config.capabilities.platformName = config.platform || config.capabilities.platformName
+    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000 // convert to seconds
 
     // [CodeceptJS compatible] transform host to hostname
-    config.hostname = config.host || config.hostname;
+    config.hostname = config.host || config.hostname
 
     if (!config.app && config.capabilities.browserName) {
-      this.isWeb = true;
-      this.root = webRoot;
+      this.isWeb = true
+      this.root = webRoot
     } else {
-      this.isWeb = false;
-      this.root = mobileRoot;
+      this.isWeb = false
+      this.root = mobileRoot
     }
 
-    this.platform = null;
+    this.platform = null
     if (config.capabilities[`${vendorPrefix.appium}:platformName`]) {
-      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase();
+      this.platform = config.capabilities[`${vendorPrefix.appium}:platformName`].toLowerCase()
     }
 
     if (config.capabilities.platformName) {
-      this.platform = config.capabilities.platformName.toLowerCase();
+      this.platform = config.capabilities.platformName.toLowerCase()
     }
 
-    return config;
+    return config
   }
 
   _convertAppiumV2Caps(capabilities) {
-    const _convertedCaps = {};
+    const _convertedCaps = {}
     for (const [key, value] of Object.entries(capabilities)) {
       if (!key.startsWith(vendorPrefix.appium)) {
         if (key !== 'platformName' && key !== 'bstack:options') {
-          _convertedCaps[`${vendorPrefix.appium}:${key}`] = value;
+          _convertedCaps[`${vendorPrefix.appium}:${key}`] = value
         } else {
-          _convertedCaps[`${key}`] = value;
+          _convertedCaps[`${key}`] = value
         }
       } else {
-        _convertedCaps[`${key}`] = value;
+        _convertedCaps[`${key}`] = value
       }
     }
-    return _convertedCaps;
+    return _convertedCaps
   }
 
   static _config() {
-    return [{
-      name: 'app',
-      message: 'Application package. Path to file or url',
-      default: 'http://localhost',
-    }, {
-      name: 'platform',
-      message: 'Mobile Platform',
-      type: 'list',
-      choices: ['iOS', supportedPlatform.android],
-      default: supportedPlatform.android,
-    }, {
-      name: 'device',
-      message: 'Device to run tests on',
-      default: 'emulator',
-    }];
+    return [
+      {
+        name: 'app',
+        message: 'Application package. Path to file or url',
+        default: 'http://localhost',
+      },
+      {
+        name: 'platform',
+        message: 'Mobile Platform',
+        type: 'list',
+        choices: ['iOS', supportedPlatform.android],
+        default: supportedPlatform.android,
+      },
+      {
+        name: 'device',
+        message: 'Device to run tests on',
+        default: 'emulator',
+      },
+    ]
   }
 
   async _startBrowser() {
     if (this.appiumV2 === true) {
-      this.options.capabilities = this._convertAppiumV2Caps(this.options.capabilities);
-      this.options.desiredCapabilities = this._convertAppiumV2Caps(this.options.desiredCapabilities);
+      this.options.capabilities = this._convertAppiumV2Caps(this.options.capabilities)
+      this.options.desiredCapabilities = this._convertAppiumV2Caps(this.options.desiredCapabilities)
     }
 
     try {
       if (this.options.multiremote) {
-        this.browser = await webdriverio.multiremote(this.options.multiremote);
+        this.browser = await webdriverio.multiremote(this.options.multiremote)
       } else {
-        this.browser = await webdriverio.remote(this.options);
+        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.$$ = this.browser.$$.bind(this.browser);
+    this.$$ = this.browser.$$.bind(this.browser)
 
-    this.isRunning = true;
+    this.isRunning = true
     if (this.options.timeouts && this.isWeb) {
-      await this.defineTimeout(this.options.timeouts);
+      await this.defineTimeout(this.options.timeouts)
     }
     if (this.options.windowSize === 'maximize' && !this.platform) {
-      const res = await this.browser.execute('return [screen.width, screen.height]');
+      const res = await this.browser.execute('return [screen.width, screen.height]')
       return this.browser.windowHandleSize({
         width: res.value[0],
         height: res.value[1],
-      });
+      })
     }
     if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0 && !this.platform) {
-      const dimensions = this.options.windowSize.split('x');
+      const dimensions = this.options.windowSize.split('x')
       await this.browser.windowHandleSize({
         width: dimensions[0],
         height: dimensions[1],
-      });
+      })
     }
   }
 
   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.isWeb && !this.platform) {
-      return super._after();
+      return super._after()
     }
   }
 
   async _withinBegin(context) {
     if (this.isWeb) {
-      return super._withinBegin(context);
+      return super._withinBegin(context)
     }
     if (context === 'webview') {
-      return this.switchToWeb();
+      return this.switchToWeb()
     }
     if (typeof context === 'object') {
-      if (context.web) return this.switchToWeb(context.web);
-      if (context.webview) return this.switchToWeb(context.webview);
+      if (context.web) return this.switchToWeb(context.web)
+      if (context.webview) return this.switchToWeb(context.webview)
     }
-    return this.switchToContext(context);
+    return this.switchToContext(context)
   }
 
   _withinEnd() {
     if (this.isWeb) {
-      return super._withinEnd();
+      return super._withinEnd()
     }
-    return this.switchToNative();
+    return this.switchToNative()
   }
 
   _buildAppiumEndpoint() {
-    const {
-      protocol, port, hostname, path,
-    } = this.browser.options;
+    const { protocol, port, hostname, path } = this.browser.options
     // Build path to Appium REST API endpoint
-    return `${protocol}://${hostname}:${port}${path}`;
+    return `${protocol}://${hostname}:${port}${path}`
   }
 
   /**
@@ -422,11 +432,11 @@ class Appium extends Webdriver {
    * @param {*} fn
    */
   async runOnIOS(caps, fn) {
-    if (this.platform !== 'ios') return;
-    recorder.session.start('iOS-only actions');
-    await this._runWithCaps(caps, fn);
-    await recorder.add('restore from iOS session', () => recorder.session.restore());
-    return recorder.promise();
+    if (this.platform !== 'ios') return
+    recorder.session.start('iOS-only actions')
+    await this._runWithCaps(caps, fn)
+    await recorder.add('restore from iOS session', () => recorder.session.restore())
+    return recorder.promise()
   }
 
   /**
@@ -464,11 +474,11 @@ class Appium extends Webdriver {
    * @param {*} fn
    */
   async runOnAndroid(caps, fn) {
-    if (this.platform !== 'android') return;
-    recorder.session.start('Android-only actions');
-    await this._runWithCaps(caps, fn);
-    await recorder.add('restore from Android session', () => recorder.session.restore());
-    return recorder.promise();
+    if (this.platform !== 'android') return
+    recorder.session.start('Android-only actions')
+    await this._runWithCaps(caps, fn)
+    await recorder.add('restore from Android session', () => recorder.session.restore())
+    return recorder.promise()
   }
 
   /**
@@ -485,11 +495,11 @@ class Appium extends Webdriver {
    */
   /* eslint-disable */
   async runInWeb(fn) {
-    if (!this.isWeb) return;
-    recorder.session.start('Web-only actions');
+    if (!this.isWeb) return
+    recorder.session.start('Web-only actions')
 
-    recorder.add('restore from Web session', () => recorder.session.restore(), true);
-    return recorder.promise();
+    recorder.add('restore from Web session', () => recorder.session.restore(), true)
+    return recorder.promise()
   }
   /* eslint-enable */
 
@@ -498,21 +508,21 @@ class Appium extends Webdriver {
       for (const key in caps) {
         // skip if capabilities do not match
         if (this.config.desiredCapabilities[key] !== caps[key]) {
-          return;
+          return
         }
       }
     }
     if (typeof caps === 'function') {
       if (!fn) {
-        fn = caps;
+        fn = caps
       } else {
         // skip if capabilities are checked inside a function
-        const enabled = caps(this.config.desiredCapabilities);
-        if (!enabled) return;
+        const enabled = caps(this.config.desiredCapabilities)
+        if (!enabled) return
       }
     }
 
-    fn();
+    fn()
   }
 
   /**
@@ -528,9 +538,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async checkIfAppIsInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
+    onlyForApps.call(this, supportedPlatform.android)
 
-    return this.browser.isAppInstalled(bundleId);
+    return this.browser.isAppInstalled(bundleId)
   }
 
   /**
@@ -546,9 +556,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeAppIsInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isAppInstalled(bundleId);
-    return truth(`app ${bundleId}`, 'to be installed').assert(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isAppInstalled(bundleId)
+    return truth(`app ${bundleId}`, 'to be installed').assert(res)
   }
 
   /**
@@ -564,9 +574,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeAppIsNotInstalled(bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isAppInstalled(bundleId);
-    return truth(`app ${bundleId}`, 'not to be installed').negate(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isAppInstalled(bundleId)
+    return truth(`app ${bundleId}`, 'not to be installed').negate(res)
   }
 
   /**
@@ -581,8 +591,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async installApp(path) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.installApp(path);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.installApp(path)
   }
 
   /**
@@ -598,13 +608,13 @@ class Appium extends Webdriver {
    * @param {string} [bundleId] ID of bundle
    */
   async removeApp(appId, bundleId) {
-    onlyForApps.call(this, supportedPlatform.android);
+    onlyForApps.call(this, supportedPlatform.android)
 
     return this.axios({
       method: 'post',
       url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/appium/device/remove_app`,
       data: { appId, bundleId },
-    });
+    })
   }
 
   /**
@@ -616,11 +626,11 @@ class Appium extends Webdriver {
    *
    */
   async resetApp() {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
     return this.axios({
       method: 'post',
       url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/appium/app/reset`,
-    });
+    })
   }
 
   /**
@@ -635,9 +645,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeCurrentActivityIs(currentActivity) {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.getCurrentActivity();
-    return truth('current activity', `to be ${currentActivity}`).assert(res === currentActivity);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.getCurrentActivity()
+    return truth('current activity', `to be ${currentActivity}`).assert(res === currentActivity)
   }
 
   /**
@@ -652,9 +662,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeDeviceIsLocked() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isLocked();
-    return truth('device', 'to be locked').assert(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isLocked()
+    return truth('device', 'to be locked').assert(res)
   }
 
   /**
@@ -669,9 +679,9 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async seeDeviceIsUnlocked() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.isLocked();
-    return truth('device', 'to be locked').negate(res);
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.isLocked()
+    return truth('device', 'to be locked').negate(res)
   }
 
   /**
@@ -689,15 +699,15 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async seeOrientationIs(orientation) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     const res = await this.axios({
       method: 'get',
       url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/orientation`,
-    });
+    })
 
-    const currentOrientation = res.data.value;
-    return truth('orientation', `to be ${orientation}`).assert(currentOrientation === orientation);
+    const currentOrientation = res.data.value
+    return truth('orientation', `to be ${orientation}`).assert(currentOrientation === orientation)
   }
 
   /**
@@ -713,13 +723,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async setOrientation(orientation) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     return this.axios({
       method: 'post',
       url: `${this._buildAppiumEndpoint()}/session/${this.browser.sessionId}/orientation`,
       data: { orientation },
-    });
+    })
   }
 
   /**
@@ -734,8 +744,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabAllContexts() {
-    onlyForApps.call(this);
-    return this.browser.getContexts();
+    onlyForApps.call(this)
+    return this.browser.getContexts()
   }
 
   /**
@@ -750,8 +760,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabContext() {
-    onlyForApps.call(this);
-    return this.browser.getContext();
+    onlyForApps.call(this)
+    return this.browser.getContext()
   }
 
   /**
@@ -766,8 +776,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async grabCurrentActivity() {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.getCurrentActivity();
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.getCurrentActivity()
   }
 
   /**
@@ -784,14 +794,14 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async grabNetworkConnection() {
-    onlyForApps.call(this, supportedPlatform.android);
-    const res = await this.browser.getNetworkConnection();
+    onlyForApps.call(this, supportedPlatform.android)
+    const res = await this.browser.getNetworkConnection()
     return {
       value: res,
       inAirplaneMode: res.inAirplaneMode,
       hasWifi: res.hasWifi,
       hasData: res.hasData,
-    };
+    }
   }
 
   /**
@@ -806,10 +816,10 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabOrientation() {
-    onlyForApps.call(this);
-    const res = await this.browser.orientation();
-    this.debugSection('Orientation', res);
-    return res;
+    onlyForApps.call(this)
+    const res = await this.browser.orientation()
+    this.debugSection('Orientation', res)
+    return res
   }
 
   /**
@@ -824,10 +834,10 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async grabSettings() {
-    onlyForApps.call(this);
-    const res = await this.browser.getSettings();
-    this.debugSection('Settings', JSON.stringify(res));
-    return res;
+    onlyForApps.call(this)
+    const res = await this.browser.getSettings()
+    this.debugSection('Settings', JSON.stringify(res))
+    return res
   }
 
   /**
@@ -836,7 +846,7 @@ class Appium extends Webdriver {
    * @param {*} context the context to switch to
    */
   async switchToContext(context) {
-    return this.browser.switchContext(context);
+    return this.browser.switchContext(context)
   }
 
   /**
@@ -856,17 +866,17 @@ class Appium extends Webdriver {
    * @param {string} [context]
    */
   async switchToWeb(context) {
-    this.isWeb = true;
-    this.defaultContext = 'body';
+    this.isWeb = true
+    this.defaultContext = 'body'
 
-    if (context) return this.switchToContext(context);
-    const contexts = await this.grabAllContexts();
-    this.debugSection('Contexts', contexts.toString());
+    if (context) return this.switchToContext(context)
+    const contexts = await this.grabAllContexts()
+    this.debugSection('Contexts', contexts.toString())
     for (const idx in contexts) {
-      if (contexts[idx].match(/^WEBVIEW/)) return this.switchToContext(contexts[idx]);
+      if (contexts[idx].match(/^WEBVIEW/)) return this.switchToContext(contexts[idx])
     }
 
-    throw new Error('No WEBVIEW could be guessed, please specify one in params');
+    throw new Error('No WEBVIEW could be guessed, please specify one in params')
   }
 
   /**
@@ -883,11 +893,11 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async switchToNative(context = null) {
-    this.isWeb = false;
-    this.defaultContext = '//*';
+    this.isWeb = false
+    this.defaultContext = '//*'
 
-    if (context) return this.switchToContext(context);
-    return this.switchToContext('NATIVE_APP');
+    if (context) return this.switchToContext(context)
+    return this.switchToContext('NATIVE_APP')
   }
 
   /**
@@ -904,8 +914,8 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async startActivity(appPackage, appActivity) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.startActivity(appPackage, appActivity);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.startActivity(appPackage, appActivity)
   }
 
   /**
@@ -930,8 +940,8 @@ class Appium extends Webdriver {
    * @return {Promise<number>}
    */
   async setNetworkConnection(value) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.setNetworkConnection(value);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.setNetworkConnection(value)
   }
 
   /**
@@ -946,8 +956,8 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async setSettings(settings) {
-    onlyForApps.call(this);
-    return this.browser.settings(settings);
+    onlyForApps.call(this)
+    return this.browser.settings(settings)
   }
 
   /**
@@ -968,9 +978,9 @@ class Appium extends Webdriver {
    * @param {string} [key] Optional key
    */
   async hideDeviceKeyboard(strategy, key) {
-    onlyForApps.call(this);
-    strategy = strategy || 'tapOutside';
-    return this.browser.hideKeyboard(strategy, key);
+    onlyForApps.call(this)
+    strategy = strategy || 'tapOutside'
+    return this.browser.hideKeyboard(strategy, key)
   }
 
   /**
@@ -987,8 +997,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async sendDeviceKeyEvent(keyValue) {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.pressKeyCode(keyValue);
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.pressKeyCode(keyValue)
   }
 
   /**
@@ -1003,8 +1013,8 @@ class Appium extends Webdriver {
    * Appium: support only Android
    */
   async openNotifications() {
-    onlyForApps.call(this, supportedPlatform.android);
-    return this.browser.openNotifications();
+    onlyForApps.call(this, supportedPlatform.android)
+    return this.browser.openNotifications()
   }
 
   /**
@@ -1023,13 +1033,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async makeTouchAction(locator, action) {
-    onlyForApps.call(this);
-    const element = await this.browser.$(parseLocator.call(this, locator));
+    onlyForApps.call(this)
+    const element = await this.browser.$(parseLocator.call(this, locator))
 
     return this.browser.touchAction({
       action,
       element,
-    });
+    })
   }
 
   /**
@@ -1046,7 +1056,7 @@ class Appium extends Webdriver {
    * @param {*} locator
    */
   async tap(locator) {
-    return this.makeTouchAction(locator, 'tap');
+    return this.makeTouchAction(locator, 'tap')
   }
 
   /**
@@ -1069,10 +1079,13 @@ class Appium extends Webdriver {
    */
   /* eslint-disable */
   async swipe(locator, xoffset, yoffset, speed = 1000) {
-    onlyForApps.call(this);
-    const res = await this.browser.$(parseLocator.call(this, locator));
+    onlyForApps.call(this)
+    const res = await this.browser.$(parseLocator.call(this, locator))
     // if (!res.length) throw new ElementNotFound(locator, 'was not found in UI');
-    return this.performSwipe(await res.getLocation(), { x: (await res.getLocation()).x + xoffset, y: (await res.getLocation()).y + yoffset });
+    return this.performSwipe(await res.getLocation(), {
+      x: (await res.getLocation()).x + xoffset,
+      y: (await res.getLocation()).y + yoffset,
+    })
   }
   /* eslint-enable */
 
@@ -1089,42 +1102,44 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async performSwipe(from, to) {
-    await this.browser.performActions([{
-      id: uuidv4(),
-      type: 'pointer',
-      parameters: {
-        pointerType: 'touch',
-      },
-      actions: [
-        {
-          duration: 0,
-          x: from.x,
-          y: from.y,
-          type: 'pointerMove',
-          origin: 'viewport',
-        },
-        {
-          button: 1,
-          type: 'pointerDown',
-        },
-        {
-          duration: 200,
-          type: 'pause',
-        },
-        {
-          duration: 600,
-          x: to.x,
-          y: to.y,
-          type: 'pointerMove',
-          origin: 'viewport',
-        },
-        {
-          button: 1,
-          type: 'pointerUp',
+    await this.browser.performActions([
+      {
+        id: uuidv4(),
+        type: 'pointer',
+        parameters: {
+          pointerType: 'touch',
         },
-      ],
-    }]);
-    await this.browser.pause(1000);
+        actions: [
+          {
+            duration: 0,
+            x: from.x,
+            y: from.y,
+            type: 'pointerMove',
+            origin: 'viewport',
+          },
+          {
+            button: 1,
+            type: 'pointerDown',
+          },
+          {
+            duration: 200,
+            type: 'pause',
+          },
+          {
+            duration: 600,
+            x: to.x,
+            y: to.y,
+            type: 'pointerMove',
+            origin: 'viewport',
+          },
+          {
+            button: 1,
+            type: 'pointerUp',
+          },
+        ],
+      },
+    ])
+    await this.browser.pause(1000)
   }
 
   /**
@@ -1145,14 +1160,14 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeDown(locator, yoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     if (!speed) {
-      speed = yoffset;
-      yoffset = 100;
+      speed = yoffset
+      yoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed);
+    return this.swipe(parseLocator.call(this, locator), 0, yoffset, speed)
   }
 
   /**
@@ -1174,13 +1189,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeLeft(locator, xoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
     if (!speed) {
-      speed = xoffset;
-      xoffset = 100;
+      speed = xoffset
+      xoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), -xoffset, 0, speed);
+    return this.swipe(parseLocator.call(this, locator), -xoffset, 0, speed)
   }
 
   /**
@@ -1201,13 +1216,13 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeRight(locator, xoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
     if (!speed) {
-      speed = xoffset;
-      xoffset = 100;
+      speed = xoffset
+      xoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), xoffset, 0, speed);
+    return this.swipe(parseLocator.call(this, locator), xoffset, 0, speed)
   }
 
   /**
@@ -1228,14 +1243,14 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeUp(locator, yoffset = 1000, speed) {
-    onlyForApps.call(this);
+    onlyForApps.call(this)
 
     if (!speed) {
-      speed = yoffset;
-      yoffset = 100;
+      speed = yoffset
+      yoffset = 100
     }
 
-    return this.swipe(parseLocator.call(this, locator), 0, -yoffset, speed);
+    return this.swipe(parseLocator.call(this, locator), 0, -yoffset, speed)
   }
 
   /**
@@ -1262,55 +1277,66 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async swipeTo(searchableLocator, scrollLocator, direction, timeout, offset, speed) {
-    onlyForApps.call(this);
-    direction = direction || 'down';
+    onlyForApps.call(this)
+    direction = direction || 'down'
     switch (direction) {
       case 'down':
-        direction = 'swipeDown';
-        break;
+        direction = 'swipeDown'
+        break
       case 'up':
-        direction = 'swipeUp';
-        break;
+        direction = 'swipeUp'
+        break
       case 'left':
-        direction = 'swipeLeft';
-        break;
+        direction = 'swipeLeft'
+        break
       case 'right':
-        direction = 'swipeRight';
-        break;
+        direction = 'swipeRight'
+        break
     }
-    timeout = timeout || this.options.waitForTimeoutInSeconds;
-
-    const errorMsg = `element ("${searchableLocator}") still not visible after ${timeout}seconds`;
-    const browser = this.browser;
-    let err = false;
-    let currentSource;
-    return browser.waitUntil(() => {
-      if (err) {
-        return new Error(`Scroll to the end and element ${searchableLocator} was not found`);
-      }
-      return browser.$$(parseLocator.call(this, searchableLocator))
-        .then(els => els.length && els[0].isDisplayed())
-        .then((res) => {
-          if (res) {
-            return true;
+    timeout = timeout || this.options.waitForTimeoutInSeconds
+
+    const errorMsg = `element ("${searchableLocator}") still not visible after ${timeout}seconds`
+    const browser = this.browser
+    let err = false
+    let currentSource
+    return browser
+      .waitUntil(
+        () => {
+          if (err) {
+            return new Error(`Scroll to the end and element ${searchableLocator} was not found`)
           }
-          return this[direction](scrollLocator, offset, speed).getSource().then((source) => {
-            if (source === currentSource) {
-              err = true;
-            } else {
-              currentSource = source;
-              return false;
-            }
-          });
-        });
-    }, timeout * 1000, errorMsg)
+          return browser
+            .$$(parseLocator.call(this, searchableLocator))
+            .then((els) => els.length && els[0].isDisplayed())
+            .then((res) => {
+              if (res) {
+                return true
+              }
+              return this[direction](scrollLocator, offset, speed)
+                .getSource()
+                .then((source) => {
+                  if (source === currentSource) {
+                    err = true
+                  } else {
+                    currentSource = source
+                    return false
+                  }
+                })
+            })
+        },
+        timeout * 1000,
+        errorMsg,
+      )
       .catch((e) => {
         if (e.message.indexOf('timeout') && e.type !== 'NoSuchElement') {
-          throw new AssertionFailedError({ customMessage: `Scroll to the end and element ${searchableLocator} was not found` }, '');
+          throw new AssertionFailedError(
+            { customMessage: `Scroll to the end and element ${searchableLocator} was not found` },
+            '',
+          )
         } else {
-          throw e;
+          throw e
         }
-      });
+      })
   }
 
   /**
@@ -1342,8 +1368,8 @@ class Appium extends Webdriver {
    * @param {Array} actions Array of touch actions
    */
   async touchPerform(actions) {
-    onlyForApps.call(this);
-    return this.browser.touchPerform(actions);
+    onlyForApps.call(this)
+    return this.browser.touchPerform(actions)
   }
 
   /**
@@ -1362,13 +1388,15 @@ class Appium extends Webdriver {
    * Appium: support Android and iOS
    */
   async pullFile(path, dest) {
-    onlyForApps.call(this);
-    return this.browser.pullFile(path).then(res => fs.writeFile(dest, Buffer.from(res, 'base64'), (err) => {
-      if (err) {
-        return false;
-      }
-      return true;
-    }));
+    onlyForApps.call(this)
+    return this.browser.pullFile(path).then((res) =>
+      fs.writeFile(dest, Buffer.from(res, 'base64'), (err) => {
+        if (err) {
+          return false
+        }
+        return true
+      }),
+    )
   }
 
   /**
@@ -1383,8 +1411,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async shakeDevice() {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.shake();
+    onlyForApps.call(this, 'iOS')
+    return this.browser.shake()
   }
 
   /**
@@ -1401,8 +1429,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async rotate(x, y, duration, radius, rotation, touchCount) {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.rotate(x, y, duration, radius, rotation, touchCount);
+    onlyForApps.call(this, 'iOS')
+    return this.browser.rotate(x, y, duration, radius, rotation, touchCount)
   }
 
   /**
@@ -1415,8 +1443,8 @@ class Appium extends Webdriver {
    * Appium: support only iOS
    */
   async setImmediateValue(id, value) {
-    onlyForApps.call(this, 'iOS');
-    return this.browser.setImmediateValue(id, value);
+    onlyForApps.call(this, 'iOS')
+    return this.browser.setImmediateValue(id, value)
   }
 
   /**
@@ -1434,9 +1462,9 @@ class Appium extends Webdriver {
    * TODO: not tested
    */
   async simulateTouchId(match) {
-    onlyForApps.call(this, 'iOS');
-    match = match || true;
-    return this.browser.touchId(match);
+    onlyForApps.call(this, 'iOS')
+    match = match || true
+    return this.browser.touchId(match)
   }
 
   /**
@@ -1451,8 +1479,8 @@ class Appium extends Webdriver {
    * Appium: support both Android and iOS
    */
   async closeApp() {
-    onlyForApps.call(this);
-    return this.browser.closeApp();
+    onlyForApps.call(this)
+    return this.browser.closeApp()
   }
 
   /**
@@ -1460,8 +1488,8 @@ class Appium extends Webdriver {
    *
    */
   async appendField(field, value) {
-    if (this.isWeb) return super.appendField(field, value);
-    return super.appendField(parseLocator.call(this, field), value);
+    if (this.isWeb) return super.appendField(field, value)
+    return super.appendField(parseLocator.call(this, field), value)
   }
 
   /**
@@ -1469,8 +1497,8 @@ class Appium extends Webdriver {
    *
    */
   async checkOption(field) {
-    if (this.isWeb) return super.checkOption(field);
-    return super.checkOption(parseLocator.call(this, field));
+    if (this.isWeb) return super.checkOption(field)
+    return super.checkOption(parseLocator.call(this, field))
   }
 
   /**
@@ -1478,8 +1506,8 @@ class Appium extends Webdriver {
    *
    */
   async click(locator, context) {
-    if (this.isWeb) return super.click(locator, context);
-    return super.click(parseLocator.call(this, locator), parseLocator.call(this, context));
+    if (this.isWeb) return super.click(locator, context)
+    return super.click(parseLocator.call(this, locator), parseLocator.call(this, context))
   }
 
   /**
@@ -1487,16 +1515,16 @@ class Appium extends Webdriver {
    *
    */
   async dontSeeCheckboxIsChecked(field) {
-    if (this.isWeb) return super.dontSeeCheckboxIsChecked(field);
-    return super.dontSeeCheckboxIsChecked(parseLocator.call(this, field));
+    if (this.isWeb) return super.dontSeeCheckboxIsChecked(field)
+    return super.dontSeeCheckboxIsChecked(parseLocator.call(this, field))
   }
 
   /**
    * {{> dontSeeElement }}
    */
   async dontSeeElement(locator) {
-    if (this.isWeb) return super.dontSeeElement(locator);
-    return super.dontSeeElement(parseLocator.call(this, locator));
+    if (this.isWeb) return super.dontSeeElement(locator)
+    return super.dontSeeElement(parseLocator.call(this, locator))
   }
 
   /**
@@ -1504,17 +1532,17 @@ class Appium extends Webdriver {
    *
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    if (this.isWeb) return super.dontSeeInField(field, _value);
-    return super.dontSeeInField(parseLocator.call(this, field), _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    if (this.isWeb) return super.dontSeeInField(field, _value)
+    return super.dontSeeInField(parseLocator.call(this, field), _value)
   }
 
   /**
    * {{> dontSee }}
    */
   async dontSee(text, context = null) {
-    if (this.isWeb) return super.dontSee(text, context);
-    return super.dontSee(text, parseLocator.call(this, context));
+    if (this.isWeb) return super.dontSee(text, context)
+    return super.dontSee(text, parseLocator.call(this, context))
   }
 
   /**
@@ -1522,9 +1550,9 @@ class Appium extends Webdriver {
    *
    */
   async fillField(field, value) {
-    value = value.toString();
-    if (this.isWeb) return super.fillField(field, value);
-    return super.fillField(parseLocator.call(this, field), value);
+    value = value.toString()
+    if (this.isWeb) return super.fillField(field, value)
+    return super.fillField(parseLocator.call(this, field), value)
   }
 
   /**
@@ -1532,8 +1560,8 @@ class Appium extends Webdriver {
    *
    */
   async grabTextFromAll(locator) {
-    if (this.isWeb) return super.grabTextFromAll(locator);
-    return super.grabTextFromAll(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabTextFromAll(locator)
+    return super.grabTextFromAll(parseLocator.call(this, locator))
   }
 
   /**
@@ -1541,16 +1569,16 @@ class Appium extends Webdriver {
    *
    */
   async grabTextFrom(locator) {
-    if (this.isWeb) return super.grabTextFrom(locator);
-    return super.grabTextFrom(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabTextFrom(locator)
+    return super.grabTextFrom(parseLocator.call(this, locator))
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    if (this.isWeb) return super.grabNumberOfVisibleElements(locator);
-    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabNumberOfVisibleElements(locator)
+    return super.grabNumberOfVisibleElements(parseLocator.call(this, locator))
   }
 
   /**
@@ -1559,8 +1587,8 @@ class Appium extends Webdriver {
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFrom(locator, attr) {
-    if (this.isWeb) return super.grabAttributeFrom(locator, attr);
-    return super.grabAttributeFrom(parseLocator.call(this, locator), attr);
+    if (this.isWeb) return super.grabAttributeFrom(locator, attr)
+    return super.grabAttributeFrom(parseLocator.call(this, locator), attr)
   }
 
   /**
@@ -1568,8 +1596,8 @@ class Appium extends Webdriver {
    * {{> grabAttributeFromAll }}
    */
   async grabAttributeFromAll(locator, attr) {
-    if (this.isWeb) return super.grabAttributeFromAll(locator, attr);
-    return super.grabAttributeFromAll(parseLocator.call(this, locator), attr);
+    if (this.isWeb) return super.grabAttributeFromAll(locator, attr)
+    return super.grabAttributeFromAll(parseLocator.call(this, locator), attr)
   }
 
   /**
@@ -1577,8 +1605,8 @@ class Appium extends Webdriver {
    *
    */
   async grabValueFromAll(locator) {
-    if (this.isWeb) return super.grabValueFromAll(locator);
-    return super.grabValueFromAll(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabValueFromAll(locator)
+    return super.grabValueFromAll(parseLocator.call(this, locator))
   }
 
   /**
@@ -1586,8 +1614,8 @@ class Appium extends Webdriver {
    *
    */
   async grabValueFrom(locator) {
-    if (this.isWeb) return super.grabValueFrom(locator);
-    return super.grabValueFrom(parseLocator.call(this, locator));
+    if (this.isWeb) return super.grabValueFrom(locator)
+    return super.grabValueFrom(parseLocator.call(this, locator))
   }
 
   /**
@@ -1602,7 +1630,7 @@ class Appium extends Webdriver {
    * @return {Promise<void>}
    */
   async saveScreenshot(fileName) {
-    return super.saveScreenshot(fileName, false);
+    return super.saveScreenshot(fileName, false)
   }
 
   /**
@@ -1611,7 +1639,7 @@ class Appium extends Webdriver {
    * Supported only for web testing
    */
   async scrollIntoView(locator, scrollIntoViewOptions) {
-    if (this.isWeb) return super.scrollIntoView(locator, scrollIntoViewOptions);
+    if (this.isWeb) return super.scrollIntoView(locator, scrollIntoViewOptions)
   }
 
   /**
@@ -1619,8 +1647,8 @@ class Appium extends Webdriver {
    *
    */
   async seeCheckboxIsChecked(field) {
-    if (this.isWeb) return super.seeCheckboxIsChecked(field);
-    return super.seeCheckboxIsChecked(parseLocator.call(this, field));
+    if (this.isWeb) return super.seeCheckboxIsChecked(field)
+    return super.seeCheckboxIsChecked(parseLocator.call(this, field))
   }
 
   /**
@@ -1628,8 +1656,8 @@ class Appium extends Webdriver {
    *
    */
   async seeElement(locator) {
-    if (this.isWeb) return super.seeElement(locator);
-    return super.seeElement(parseLocator.call(this, locator));
+    if (this.isWeb) return super.seeElement(locator)
+    return super.seeElement(parseLocator.call(this, locator))
   }
 
   /**
@@ -1637,9 +1665,9 @@ class Appium extends Webdriver {
    *
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    if (this.isWeb) return super.seeInField(field, _value);
-    return super.seeInField(parseLocator.call(this, field), _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    if (this.isWeb) return super.seeInField(field, _value)
+    return super.seeInField(parseLocator.call(this, field), _value)
   }
 
   /**
@@ -1647,8 +1675,8 @@ class Appium extends Webdriver {
    *
    */
   async see(text, context) {
-    if (this.isWeb) return super.see(text, context);
-    return super.see(text, parseLocator.call(this, context));
+    if (this.isWeb) return super.see(text, context)
+    return super.see(text, parseLocator.call(this, context))
   }
 
   /**
@@ -1657,8 +1685,8 @@ class Appium extends Webdriver {
    * Supported only for web testing
    */
   async selectOption(select, option) {
-    if (this.isWeb) return super.selectOption(select, option);
-    throw new Error('Should be used only in Web context. In native context use \'click\' method instead');
+    if (this.isWeb) return super.selectOption(select, option)
+    throw new Error("Should be used only in Web context. In native context use 'click' method instead")
   }
 
   /**
@@ -1666,8 +1694,8 @@ class Appium extends Webdriver {
    *
    */
   async waitForElement(locator, sec = null) {
-    if (this.isWeb) return super.waitForElement(locator, sec);
-    return super.waitForElement(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForElement(locator, sec)
+    return super.waitForElement(parseLocator.call(this, locator), sec)
   }
 
   /**
@@ -1675,8 +1703,8 @@ class Appium extends Webdriver {
    *
    */
   async waitForVisible(locator, sec = null) {
-    if (this.isWeb) return super.waitForVisible(locator, sec);
-    return super.waitForVisible(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForVisible(locator, sec)
+    return super.waitForVisible(parseLocator.call(this, locator), sec)
   }
 
   /**
@@ -1684,8 +1712,8 @@ class Appium extends Webdriver {
    *
    */
   async waitForInvisible(locator, sec = null) {
-    if (this.isWeb) return super.waitForInvisible(locator, sec);
-    return super.waitForInvisible(parseLocator.call(this, locator), sec);
+    if (this.isWeb) return super.waitForInvisible(locator, sec)
+    return super.waitForInvisible(parseLocator.call(this, locator), sec)
   }
 
   /**
@@ -1693,74 +1721,76 @@ class Appium extends Webdriver {
    *
    */
   async waitForText(text, sec = null, context = null) {
-    if (this.isWeb) return super.waitForText(text, sec, context);
-    return super.waitForText(text, sec, parseLocator.call(this, context));
+    if (this.isWeb) return super.waitForText(text, sec, context)
+    return super.waitForText(text, sec, parseLocator.call(this, context))
   }
 }
 
 function parseLocator(locator) {
-  if (!locator) return null;
+  if (!locator) return null
 
   if (typeof locator === 'object') {
     if (locator.web && this.isWeb) {
-      return parseLocator.call(this, locator.web);
+      return parseLocator.call(this, locator.web)
     }
 
     if (locator.android && this.platform === 'android') {
       if (typeof locator.android === 'string') {
-        return parseLocator.call(this, locator.android);
+        return parseLocator.call(this, locator.android)
       }
       // The locator is an Android DataMatcher or ViewMatcher locator so return as is
-      return locator.android;
+      return locator.android
     }
 
     if (locator.ios && this.platform === 'ios') {
-      return parseLocator.call(this, locator.ios);
+      return parseLocator.call(this, locator.ios)
     }
   }
 
   if (typeof locator === 'string') {
-    if (locator[0] === '~') return locator;
-    if (locator.substr(0, 2) === '//') return locator;
+    if (locator[0] === '~') return locator
+    if (locator.substr(0, 2) === '//') return locator
     if (locator[0] === '#' && !this.isWeb) {
       // hook before webdriverio supports native # locators
-      return parseLocator.call(this, { id: locator.slice(1) });
+      return parseLocator.call(this, { id: locator.slice(1) })
     }
 
     if (this.platform === 'android' && !this.isWeb) {
-      const isNativeLocator = /^\-?android=?/.exec(locator);
-      return isNativeLocator
-        ? locator
-        : `android=new UiSelector().text("${locator}")`;
+      const isNativeLocator = /^\-?android=?/.exec(locator)
+      return isNativeLocator ? locator : `android=new UiSelector().text("${locator}")`
     }
   }
 
-  locator = new Locator(locator, 'xpath');
-  if (locator.type === 'css' && !this.isWeb) throw new Error('Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name or accessibility id');
-  if (locator.type === 'name' && !this.isWeb) throw new Error("Can't locate element by name in Native context. Use either ID, class name or accessibility id");
-  if (locator.type === 'id' && !this.isWeb && this.platform === 'android') return `//*[@resource-id='${locator.value}']`;
-  return locator.simplify();
+  locator = new Locator(locator, 'xpath')
+  if (locator.type === 'css' && !this.isWeb)
+    throw new Error(
+      'Unable to use css locators in apps. Locator strategies for this request: xpath, id, class name or accessibility id',
+    )
+  if (locator.type === 'name' && !this.isWeb)
+    throw new Error("Can't locate element by name in Native context. Use either ID, class name or accessibility id")
+  if (locator.type === 'id' && !this.isWeb && this.platform === 'android') return `//*[@resource-id='${locator.value}']`
+  return locator.simplify()
 }
 
 // in the end of a file
 function onlyForApps(expectedPlatform) {
-  const stack = new Error().stack || '';
-  const re = /Appium.(\w+)/g;
-  const caller = stack.split('\n')[2].trim();
-  const m = re.exec(caller);
+  const stack = new Error().stack || ''
+  const re = /Appium.(\w+)/g
+  const caller = stack.split('\n')[2].trim()
+  const m = re.exec(caller)
 
   if (!m) {
-    throw new Error(`Invalid caller ${caller}`);
+    throw new Error(`Invalid caller ${caller}`)
   }
 
-  const callerName = m[1] || m[2];
+  const callerName = m[1] || m[2]
   if (!expectedPlatform) {
     if (!this.platform) {
-      throw new Error(`${callerName} method can be used only with apps`);
+      throw new Error(`${callerName} method can be used only with apps`)
     }
   } else if (this.platform !== expectedPlatform.toLowerCase()) {
-    throw new Error(`${callerName} method can be used only with ${expectedPlatform} apps`);
+    throw new Error(`${callerName} method can be used only with ${expectedPlatform} apps`)
   }
 }
 
-module.exports = Appium;
+module.exports = Appium
diff --git a/lib/helper/ExpectHelper.js b/lib/helper/ExpectHelper.js
index c6a9dd27d..8d891e0ac 100644
--- a/lib/helper/ExpectHelper.js
+++ b/lib/helper/ExpectHelper.js
@@ -1,15 +1,15 @@
-const output = require('../output');
+const output = require('../output')
 
-let expect;
+let expect
 
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-string'));
+import('chai').then((chai) => {
+  expect = chai.expect
+  chai.use(require('chai-string'))
   // @ts-ignore
-  chai.use(require('chai-exclude'));
-  chai.use(require('chai-match-pattern'));
-  chai.use(require('chai-json-schema'));
-});
+  chai.use(require('chai-exclude'))
+  chai.use(require('chai-match-pattern'))
+  chai.use(require('chai-json-schema'))
+})
 
 /**
  * This helper allows performing assertions based on Chai.
@@ -32,27 +32,27 @@ import('chai').then(chai => {
  */
 class ExpectHelper {
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} [customErrorMsg]
+   */
   expectEqual(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return expect(actualValue, customErrorMsg).to.equal(expectedValue);
+    output.step(`I expect "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`)
+    return expect(actualValue, customErrorMsg).to.equal(expectedValue)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} [customErrorMsg]
+   */
   expectNotEqual(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not equal "${JSON.stringify(expectedValue)}"`);
-    return expect(actualValue, customErrorMsg).not.to.equal(expectedValue);
+    output.step(`I expect "${JSON.stringify(actualValue)}" to not equal "${JSON.stringify(expectedValue)}"`)
+    return expect(actualValue, customErrorMsg).not.to.equal(expectedValue)
   }
 
   /**
@@ -64,362 +64,328 @@ class ExpectHelper {
      */
   expectDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to deep equal "${JSON.stringify(expectedValue)}"`);
-    return expect(actualValue, customErrorMsg).to.deep.equal(expectedValue);
+    output.step(`I expect "${JSON.stringify(actualValue)}" to deep equal "${JSON.stringify(expectedValue)}"`)
+    return expect(actualValue, customErrorMsg).to.deep.equal(expectedValue)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} [customErrorMsg]
+   */
   expectNotDeepEqual(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not deep equal "${JSON.stringify(expectedValue)}"`);
-    return expect(actualValue, customErrorMsg).to.not.deep.equal(expectedValue);
+    output.step(`I expect "${JSON.stringify(actualValue)}" to not deep equal "${JSON.stringify(expectedValue)}"`)
+    return expect(actualValue, customErrorMsg).to.not.deep.equal(expectedValue)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToContain
-     * @param {*} [customErrorMsg]
-     */
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValueToContain
+   * @param {*} [customErrorMsg]
+   */
   expectContain(actualValue, expectedValueToContain, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to contain "${JSON.stringify(expectedValueToContain)}"`);
-    return expect(actualValue, customErrorMsg).to.contain(
-      expectedValueToContain,
-    );
+    output.step(`I expect "${JSON.stringify(actualValue)}" to contain "${JSON.stringify(expectedValueToContain)}"`)
+    return expect(actualValue, customErrorMsg).to.contain(expectedValueToContain)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotContain
-     * @param {*} [customErrorMsg]
-     */
-  expectNotContain(
-    actualValue,
-    expectedValueToNotContain,
-    customErrorMsg = '',
-  ) {
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValueToNotContain
+   * @param {*} [customErrorMsg]
+   */
+  expectNotContain(actualValue, expectedValueToNotContain, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not contain "${JSON.stringify(expectedValueToNotContain)}"`);
-    return expect(actualValue, customErrorMsg).not.to.contain(
-      expectedValueToNotContain,
-    );
+    output.step(
+      `I expect "${JSON.stringify(actualValue)}" to not contain "${JSON.stringify(expectedValueToNotContain)}"`,
+    )
+    return expect(actualValue, customErrorMsg).not.to.contain(expectedValueToNotContain)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToStartWith
-     * @param {*} [customErrorMsg]
-     */
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValueToStartWith
+   * @param {*} [customErrorMsg]
+   */
   expectStartsWith(actualValue, expectedValueToStartWith, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`);
-    return expect(actualValue, customErrorMsg).to.startsWith(
-      expectedValueToStartWith,
-    );
+    output.step(`I expect "${JSON.stringify(actualValue)}" to start with "${JSON.stringify(expectedValueToStartWith)}"`)
+    return expect(actualValue, customErrorMsg).to.startsWith(expectedValueToStartWith)
   }
 
   /**
-     *
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotStartWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotStartsWith(
-    actualValue,
-    expectedValueToNotStartWith,
-    customErrorMsg = '',
-  ) {
+   *
+   * @param {*} actualValue
+   * @param {*} expectedValueToNotStartWith
+   * @param {*} [customErrorMsg]
+   */
+  expectNotStartsWith(actualValue, expectedValueToNotStartWith, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`);
-    return expect(actualValue, customErrorMsg).not.to.startsWith(
-      expectedValueToNotStartWith,
-    );
+    output.step(
+      `I expect "${JSON.stringify(actualValue)}" to not start with "${JSON.stringify(expectedValueToNotStartWith)}"`,
+    )
+    return expect(actualValue, customErrorMsg).not.to.startsWith(expectedValueToNotStartWith)
   }
 
   /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToEndWith
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} actualValue
+   * @param {*} expectedValueToEndWith
+   * @param {*} [customErrorMsg]
+   */
   expectEndsWith(actualValue, expectedValueToEndWith, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to end with "${JSON.stringify(expectedValueToEndWith)}"`);
-    return expect(actualValue, customErrorMsg).to.endsWith(
-      expectedValueToEndWith,
-    );
+    output.step(`I expect "${JSON.stringify(actualValue)}" to end with "${JSON.stringify(expectedValueToEndWith)}"`)
+    return expect(actualValue, customErrorMsg).to.endsWith(expectedValueToEndWith)
   }
 
   /**
-     * @param {*} actualValue
-     * @param {*} expectedValueToNotEndWith
-     * @param {*} [customErrorMsg]
-     */
-  expectNotEndsWith(
-    actualValue,
-    expectedValueToNotEndWith,
-    customErrorMsg = '',
-  ) {
+   * @param {*} actualValue
+   * @param {*} expectedValueToNotEndWith
+   * @param {*} [customErrorMsg]
+   */
+  expectNotEndsWith(actualValue, expectedValueToNotEndWith, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to not end with "${JSON.stringify(expectedValueToNotEndWith)}"`);
-    return expect(actualValue, customErrorMsg).not.to.endsWith(
-      expectedValueToNotEndWith,
-    );
+    output.step(
+      `I expect "${JSON.stringify(actualValue)}" to not end with "${JSON.stringify(expectedValueToNotEndWith)}"`,
+    )
+    return expect(actualValue, customErrorMsg).not.to.endsWith(expectedValueToNotEndWith)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} jsonSchema
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} jsonSchema
+   * @param {*} [customErrorMsg]
+   */
   expectJsonSchema(targetData, jsonSchema, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`);
+    output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema "${JSON.stringify(jsonSchema)}"`)
 
-    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
+    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} jsonSchema
-     * @param {*} [customErrorMsg]
-     * @param {*} [ajvOptions] Pass AJV options
-     */
-  expectJsonSchemaUsingAJV(
-    targetData,
-    jsonSchema,
-    customErrorMsg = '',
-    ajvOptions = { allErrors: true },
-  ) {
+   * @param {*} targetData
+   * @param {*} jsonSchema
+   * @param {*} [customErrorMsg]
+   * @param {*} [ajvOptions] Pass AJV options
+   */
+  expectJsonSchemaUsingAJV(targetData, jsonSchema, customErrorMsg = '', ajvOptions = { allErrors: true }) {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to match this JSON schema using AJV "${JSON.stringify(jsonSchema)}"`);
-    chai.use(require('chai-json-schema-ajv').create(ajvOptions));
-    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema);
+    output.step(
+      `I expect "${JSON.stringify(targetData)}" to match this JSON schema using AJV "${JSON.stringify(jsonSchema)}"`,
+    )
+    chai.use(require('chai-json-schema-ajv').create(ajvOptions))
+    return expect(targetData, customErrorMsg).to.be.jsonSchema(jsonSchema)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} propertyName
+   * @param {*} [customErrorMsg]
+   */
   expectHasProperty(targetData, propertyName, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have property: "${JSON.stringify(propertyName)}"`);
-    return expect(targetData, customErrorMsg).to.have.property(propertyName);
+    output.step(`I expect "${JSON.stringify(targetData)}" to have property: "${JSON.stringify(propertyName)}"`)
+    return expect(targetData, customErrorMsg).to.have.property(propertyName)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} propertyName
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} propertyName
+   * @param {*} [customErrorMsg]
+   */
   expectHasAProperty(targetData, propertyName, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have a property: "${JSON.stringify(propertyName)}"`);
-    return expect(targetData, customErrorMsg).to.have.a.property(propertyName);
+    output.step(`I expect "${JSON.stringify(targetData)}" to have a property: "${JSON.stringify(propertyName)}"`)
+    return expect(targetData, customErrorMsg).to.have.a.property(propertyName)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} type
+   * @param {*} [customErrorMsg]
+   */
   expectToBeA(targetData, type, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be a "${JSON.stringify(type)}"`);
-    return expect(targetData, customErrorMsg).to.be.a(type);
+    output.step(`I expect "${JSON.stringify(targetData)}" to be a "${JSON.stringify(type)}"`)
+    return expect(targetData, customErrorMsg).to.be.a(type)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} type
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} type
+   * @param {*} [customErrorMsg]
+   */
   expectToBeAn(targetData, type, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be an "${JSON.stringify(type)}"`);
-    return expect(targetData, customErrorMsg).to.be.an(type);
+    output.step(`I expect "${JSON.stringify(targetData)}" to be an "${JSON.stringify(type)}"`)
+    return expect(targetData, customErrorMsg).to.be.an(type)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} regex
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} regex
+   * @param {*} [customErrorMsg]
+   */
   expectMatchRegex(targetData, regex, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to match the regex "${JSON.stringify(regex)}"`);
-    return expect(targetData, customErrorMsg).to.match(regex);
+    output.step(`I expect "${JSON.stringify(targetData)}" to match the regex "${JSON.stringify(regex)}"`)
+    return expect(targetData, customErrorMsg).to.match(regex)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} length
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} length
+   * @param {*} [customErrorMsg]
+   */
   expectLengthOf(targetData, length, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of "${JSON.stringify(length)}"`);
-    return expect(targetData, customErrorMsg).to.have.lengthOf(length);
+    output.step(`I expect "${JSON.stringify(targetData)}" to have length of "${JSON.stringify(length)}"`)
+    return expect(targetData, customErrorMsg).to.have.lengthOf(length)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} [customErrorMsg]
+   */
   expectEmpty(targetData, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be empty`);
-    return expect(targetData, customErrorMsg).to.be.empty;
+    output.step(`I expect "${JSON.stringify(targetData)}" to be empty`)
+    return expect(targetData, customErrorMsg).to.be.empty
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} [customErrorMsg]
+   */
   expectTrue(targetData, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be true`);
-    return expect(targetData, customErrorMsg).to.be.true;
+    output.step(`I expect "${JSON.stringify(targetData)}" to be true`)
+    return expect(targetData, customErrorMsg).to.be.true
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} [customErrorMsg]
+   */
   expectFalse(targetData, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be false`);
-    return expect(targetData, customErrorMsg).to.be.false;
+    output.step(`I expect "${JSON.stringify(targetData)}" to be false`)
+    return expect(targetData, customErrorMsg).to.be.false
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} aboveThan
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} aboveThan
+   * @param {*} [customErrorMsg]
+   */
   expectAbove(targetData, aboveThan, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be above ${JSON.stringify(aboveThan)}`);
-    return expect(targetData, customErrorMsg).to.be.above(aboveThan);
+    output.step(`I expect "${JSON.stringify(targetData)}" to be above ${JSON.stringify(aboveThan)}`)
+    return expect(targetData, customErrorMsg).to.be.above(aboveThan)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} belowThan
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} belowThan
+   * @param {*} [customErrorMsg]
+   */
   expectBelow(targetData, belowThan, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to be below ${JSON.stringify(belowThan)}`);
-    return expect(targetData, customErrorMsg).to.be.below(belowThan);
+    output.step(`I expect "${JSON.stringify(targetData)}" to be below ${JSON.stringify(belowThan)}`)
+    return expect(targetData, customErrorMsg).to.be.below(belowThan)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} lengthAboveThan
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} lengthAboveThan
+   * @param {*} [customErrorMsg]
+   */
   expectLengthAboveThan(targetData, lengthAboveThan, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of above ${JSON.stringify(lengthAboveThan)}`);
-    return expect(targetData, customErrorMsg).to.have.lengthOf.above(
-      lengthAboveThan,
-    );
+    output.step(`I expect "${JSON.stringify(targetData)}" to have length of above ${JSON.stringify(lengthAboveThan)}`)
+    return expect(targetData, customErrorMsg).to.have.lengthOf.above(lengthAboveThan)
   }
 
   /**
-     * @param {*} targetData
-     * @param {*} lengthBelowThan
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} targetData
+   * @param {*} lengthBelowThan
+   * @param {*} [customErrorMsg]
+   */
   expectLengthBelowThan(targetData, lengthBelowThan, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(targetData)}" to have length of below ${JSON.stringify(lengthBelowThan)}`);
-    return expect(targetData, customErrorMsg).to.have.lengthOf.below(
-      lengthBelowThan,
-    );
+    output.step(`I expect "${JSON.stringify(targetData)}" to have length of below ${JSON.stringify(lengthBelowThan)}`)
+    return expect(targetData, customErrorMsg).to.have.lengthOf.below(lengthBelowThan)
   }
 
   /**
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} [customErrorMsg]
+   */
   expectEqualIgnoreCase(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect and ingore case "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`);
-    return expect(actualValue, customErrorMsg).to.equalIgnoreCase(
-      expectedValue,
-    );
+    output.step(`I expect and ingore case "${JSON.stringify(actualValue)}" to equal "${JSON.stringify(expectedValue)}"`)
+    return expect(actualValue, customErrorMsg).to.equalIgnoreCase(expectedValue)
   }
 
   /**
-     * expects members of two arrays are deeply equal
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} [customErrorMsg]
-     */
+   * expects members of two arrays are deeply equal
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} [customErrorMsg]
+   */
   expectDeepMembers(actualValue, expectedValue, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" arrays are deeply equal`);
-    return expect(actualValue, customErrorMsg).to.have.deep.members(
-      expectedValue,
-    );
+    output.step(
+      `I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" arrays are deeply equal`,
+    )
+    return expect(actualValue, customErrorMsg).to.have.deep.members(expectedValue)
   }
 
   /**
-     * expects an array to be a superset of another array
-     * @param {*} superset
-     * @param {*} set
-     * @param {*} [customErrorMsg]
-     */
+   * expects an array to be a superset of another array
+   * @param {*} superset
+   * @param {*} set
+   * @param {*} [customErrorMsg]
+   */
   expectDeepIncludeMembers(superset, set, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(superset)}" array to be a superset of "${JSON.stringify(set)}" array`);
-    return expect(superset, customErrorMsg).to.deep.include.members(
-      set,
-    );
+    output.step(`I expect "${JSON.stringify(superset)}" array to be a superset of "${JSON.stringify(set)}" array`)
+    return expect(superset, customErrorMsg).to.deep.include.members(set)
   }
 
   /**
-     * expects members of two JSON objects are deeply equal excluding some properties
-     * @param {*} actualValue
-     * @param {*} expectedValue
-     * @param {*} fieldsToExclude
-     * @param {*} [customErrorMsg]
-     */
-  expectDeepEqualExcluding(
-    actualValue,
-    expectedValue,
-    fieldsToExclude,
-    customErrorMsg = '',
-  ) {
+   * expects members of two JSON objects are deeply equal excluding some properties
+   * @param {*} actualValue
+   * @param {*} expectedValue
+   * @param {*} fieldsToExclude
+   * @param {*} [customErrorMsg]
+   */
+  expectDeepEqualExcluding(actualValue, expectedValue, fieldsToExclude, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" JSON objects are deeply equal excluding properties: ${JSON.stringify(fieldsToExclude)}`);
-    return expect(actualValue, customErrorMsg)
-      .excludingEvery(fieldsToExclude)
-      .to.deep.equal(expectedValue);
+    output.step(
+      `I expect members of "${JSON.stringify(actualValue)}" and "${JSON.stringify(expectedValue)}" JSON objects are deeply equal excluding properties: ${JSON.stringify(fieldsToExclude)}`,
+    )
+    return expect(actualValue, customErrorMsg).excludingEvery(fieldsToExclude).to.deep.equal(expectedValue)
   }
 
   /**
-     * expects a JSON object matches a provided pattern
-     * @param {*} actualValue
-     * @param {*} expectedPattern
-     * @param {*} [customErrorMsg]
-     */
+   * expects a JSON object matches a provided pattern
+   * @param {*} actualValue
+   * @param {*} expectedPattern
+   * @param {*} [customErrorMsg]
+   */
   expectMatchesPattern(actualValue, expectedPattern, customErrorMsg = '') {
     // @ts-ignore
-    output.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`);
-    return expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern);
+    output.step(`I expect "${JSON.stringify(actualValue)}" to match the ${JSON.stringify(expectedPattern)} pattern`)
+    return expect(actualValue, customErrorMsg).to.matchPattern(expectedPattern)
   }
 }
 
-module.exports = ExpectHelper;
+module.exports = ExpectHelper
diff --git a/lib/helper/FileSystem.js b/lib/helper/FileSystem.js
index 830936c7d..68d6d645d 100644
--- a/lib/helper/FileSystem.js
+++ b/lib/helper/FileSystem.js
@@ -1,11 +1,11 @@
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
+const assert = require('assert')
+const path = require('path')
+const fs = require('fs')
 
-const Helper = require('@codeceptjs/helper');
-const { fileExists } = require('../utils');
-const { fileIncludes } = require('../assert/include');
-const { fileEquals } = require('../assert/equal');
+const Helper = require('@codeceptjs/helper')
+const { fileExists } = require('../utils')
+const { fileIncludes } = require('../assert/include')
+const { fileEquals } = require('../assert/equal')
 
 /**
  * Helper for testing filesystem.
@@ -32,13 +32,13 @@ const { fileEquals } = require('../assert/equal');
  */
 class FileSystem extends Helper {
   constructor() {
-    super();
-    this.dir = global.codecept_dir;
-    this.file = '';
+    super()
+    this.dir = global.codecept_dir
+    this.file = ''
   }
 
   _before() {
-    this.debugSection('Dir', this.dir);
+    this.debugSection('Dir', this.dir)
   }
 
   /**
@@ -47,8 +47,8 @@ class FileSystem extends Helper {
    * @param {string} openPath
    */
   amInPath(openPath) {
-    this.dir = path.join(global.codecept_dir, openPath);
-    this.debugSection('Dir', this.dir);
+    this.dir = path.join(global.codecept_dir, openPath)
+    this.debugSection('Dir', this.dir)
   }
 
   /**
@@ -57,7 +57,7 @@ class FileSystem extends Helper {
    * @param {string} text
    */
   writeToFile(name, text) {
-    fs.writeFileSync(path.join(this.dir, name), text);
+    fs.writeFileSync(path.join(this.dir, name), text)
   }
 
   /**
@@ -65,9 +65,9 @@ class FileSystem extends Helper {
    * @param {string} name
    */
   seeFile(name) {
-    this.file = path.join(this.dir, name);
-    this.debugSection('File', this.file);
-    assert.ok(fileExists(this.file), `File ${name} not found in ${this.dir}`);
+    this.file = path.join(this.dir, name)
+    this.debugSection('File', this.file)
+    assert.ok(fileExists(this.file), `File ${name} not found in ${this.dir}`)
   }
 
   /**
@@ -83,31 +83,31 @@ class FileSystem extends Helper {
    * @param {number} [sec=1] seconds to wait
    */
   async waitForFile(name, sec = 1) {
-    if (sec === 0) assert.fail('Use `seeFile` instead of waiting 0 seconds!');
-    const waitTimeout = sec * 1000;
-    this.file = path.join(this.dir, name);
-    this.debugSection('File', this.file);
+    if (sec === 0) assert.fail('Use `seeFile` instead of waiting 0 seconds!')
+    const waitTimeout = sec * 1000
+    this.file = path.join(this.dir, name)
+    this.debugSection('File', this.file)
     return isFileExists(this.file, waitTimeout).catch(() => {
-      throw new Error(`file (${name}) still not present in directory ${this.dir} after ${waitTimeout / 1000} sec`);
-    });
+      throw new Error(`file (${name}) still not present in directory ${this.dir} after ${waitTimeout / 1000} sec`)
+    })
   }
 
   /**
-  * Checks that file with a name including given text exists in the current directory.
-  *
-  *```js
-  * I.handleDownloads();
-  * I.click('Download as PDF');
-  * I.amInPath('output/downloads');
-  * I.seeFileNameMatching('.pdf');
-  * ```
-  * @param {string} text
-  */
+   * Checks that file with a name including given text exists in the current directory.
+   *
+   *```js
+   * I.handleDownloads();
+   * I.click('Download as PDF');
+   * I.amInPath('output/downloads');
+   * I.seeFileNameMatching('.pdf');
+   * ```
+   * @param {string} text
+   */
   seeFileNameMatching(text) {
     assert.ok(
-      this.grabFileNames().some(file => file.includes(text)),
+      this.grabFileNames().some((file) => file.includes(text)),
       `File name which contains ${text} not found in ${this.dir}`,
-    );
+    )
   }
 
   /**
@@ -116,8 +116,8 @@ class FileSystem extends Helper {
    * @param {string} [encoding='utf8']
    */
   seeInThisFile(text, encoding = 'utf8') {
-    const content = getFileContents(this.file, encoding);
-    fileIncludes(this.file).assert(text, content);
+    const content = getFileContents(this.file, encoding)
+    fileIncludes(this.file).assert(text, content)
   }
 
   /**
@@ -126,8 +126,8 @@ class FileSystem extends Helper {
    * @param {string} [encoding='utf8']
    */
   dontSeeInThisFile(text, encoding = 'utf8') {
-    const content = getFileContents(this.file, encoding);
-    fileIncludes(this.file).negate(text, content);
+    const content = getFileContents(this.file, encoding)
+    fileIncludes(this.file).negate(text, content)
   }
 
   /**
@@ -136,8 +136,8 @@ class FileSystem extends Helper {
    * @param {string} [encoding='utf8']
    */
   seeFileContentsEqual(text, encoding = 'utf8') {
-    const content = getFileContents(this.file, encoding);
-    fileEquals(this.file).assert(text, content);
+    const content = getFileContents(this.file, encoding)
+    fileEquals(this.file).assert(text, content)
   }
 
   /**
@@ -147,11 +147,11 @@ class FileSystem extends Helper {
    * @param {string} [encodingReference='utf8']
    */
   seeFileContentsEqualReferenceFile(pathToReferenceFile, encoding = 'utf8', encodingReference = '') {
-    const content = getFileContents(this.file, encoding);
-    assert.ok(fileExists(pathToReferenceFile), `Reference file ${pathToReferenceFile} not found.`);
-    encodingReference = encodingReference || encoding;
-    const expectedContent = getFileContents(pathToReferenceFile, encodingReference);
-    fileEquals(this.file).assert(expectedContent, content);
+    const content = getFileContents(this.file, encoding)
+    assert.ok(fileExists(pathToReferenceFile), `Reference file ${pathToReferenceFile} not found.`)
+    encodingReference = encodingReference || encoding
+    const expectedContent = getFileContents(pathToReferenceFile, encodingReference)
+    fileEquals(this.file).assert(expectedContent, content)
   }
 
   /**
@@ -160,27 +160,26 @@ class FileSystem extends Helper {
    * @param {string} [encoding='utf8']
    */
   dontSeeFileContentsEqual(text, encoding = 'utf8') {
-    const content = getFileContents(this.file, encoding);
-    fileEquals(this.file).negate(text, content);
+    const content = getFileContents(this.file, encoding)
+    fileEquals(this.file).negate(text, content)
   }
 
   /**
-  * Returns file names in current directory.
-  *
-  * ```js
-  * I.handleDownloads();
-  * I.click('Download Files');
-  * I.amInPath('output/downloads');
-  * const downloadedFileNames = I.grabFileNames();
-  * ```
-  */
+   * Returns file names in current directory.
+   *
+   * ```js
+   * I.handleDownloads();
+   * I.click('Download Files');
+   * I.amInPath('output/downloads');
+   * const downloadedFileNames = I.grabFileNames();
+   * ```
+   */
   grabFileNames() {
-    return fs.readdirSync(this.dir)
-      .filter(item => !fs.lstatSync(path.join(this.dir, item)).isDirectory());
+    return fs.readdirSync(this.dir).filter((item) => !fs.lstatSync(path.join(this.dir, item)).isDirectory())
   }
 }
 
-module.exports = FileSystem;
+module.exports = FileSystem
 
 /**
  * @param {string} file
@@ -189,9 +188,9 @@ module.exports = FileSystem;
  * @returns {string}
  */
 function getFileContents(file, encoding = 'utf8') {
-  if (!file) assert.fail('No files were opened, please use seeFile action');
-  if (encoding === '') assert.fail('Encoding is an empty string, please set a valid encoding');
-  return fs.readFileSync(file, encoding);
+  if (!file) assert.fail('No files were opened, please use seeFile action')
+  if (encoding === '') assert.fail('Encoding is an empty string, please set a valid encoding')
+  return fs.readFileSync(file, encoding)
 }
 
 /**
@@ -201,28 +200,28 @@ function getFileContents(file, encoding = 'utf8') {
  * @returns {Promise<any>}
  */
 function isFileExists(file, timeout) {
-  return new Promise(((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      watcher.close();
-      reject(new Error('File did not exists and was not created during the timeout.'));
-    }, timeout);
+      watcher.close()
+      reject(new Error('File did not exists and was not created during the timeout.'))
+    }, timeout)
 
-    const dir = path.dirname(file);
-    const basename = path.basename(file);
+    const dir = path.dirname(file)
+    const basename = path.basename(file)
     const watcher = fs.watch(dir, (eventType, filename) => {
       if (eventType === 'rename' && filename === basename) {
-        clearTimeout(timer);
-        watcher.close();
-        resolve();
+        clearTimeout(timer)
+        watcher.close()
+        resolve()
       }
-    });
+    })
 
     fs.access(file, fs.constants.R_OK, (err) => {
       if (!err) {
-        clearTimeout(timer);
-        watcher.close();
-        resolve();
+        clearTimeout(timer)
+        watcher.close()
+        resolve()
       }
-    });
-  }));
+    })
+  })
 }
diff --git a/lib/helper/GraphQL.js b/lib/helper/GraphQL.js
index fb87f16a2..4a5f39c29 100644
--- a/lib/helper/GraphQL.js
+++ b/lib/helper/GraphQL.js
@@ -1,5 +1,5 @@
-const axios = require('axios').default;
-const Helper = require('@codeceptjs/helper');
+const axios = require('axios').default
+const Helper = require('@codeceptjs/helper')
 
 /**
  * GraphQL helper allows to send additional requests to a GraphQl endpoint during acceptance tests.
@@ -38,31 +38,35 @@ const Helper = require('@codeceptjs/helper');
  */
 class GraphQL extends Helper {
   constructor(config) {
-    super(config);
-    this.axios = axios.create();
-    this.headers = {};
+    super(config)
+    this.axios = axios.create()
+    this.headers = {}
     this.options = {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
-    };
-    this.options = Object.assign(this.options, config);
-    this.headers = { ...this.options.defaultHeaders };
-    this.axios.defaults.headers = this.options.defaultHeaders;
+    }
+    this.options = Object.assign(this.options, config)
+    this.headers = { ...this.options.defaultHeaders }
+    this.axios.defaults.headers = this.options.defaultHeaders
   }
 
   static _checkRequirements() {
     try {
-      require('axios');
+      require('axios')
     } catch (e) {
-      return ['axios'];
+      return ['axios']
     }
   }
 
   static _config() {
     return [
-      { name: 'endpoint', message: 'Endpoint of API you are going to test', default: 'http://localhost:3000/graphql' },
-    ];
+      {
+        name: 'endpoint',
+        message: 'Endpoint of API you are going to test',
+        default: 'http://localhost:3000/graphql',
+      },
+    ]
   }
 
   /**
@@ -71,42 +75,39 @@ class GraphQL extends Helper {
    * @param {object} request
    */
   async _executeQuery(request) {
-    this.axios.defaults.timeout = request.timeout || this.options.timeout;
+    this.axios.defaults.timeout = request.timeout || this.options.timeout
 
     if (this.headers && this.headers.auth) {
-      request.auth = this.headers.auth;
+      request.auth = this.headers.auth
     }
 
     request.headers = Object.assign(request.headers, {
       'Content-Type': 'application/json',
-    });
+    })
 
-    request.headers = { ...this.headers, ...request.headers };
+    request.headers = { ...this.headers, ...request.headers }
 
     if (this.config.onRequest) {
-      await this.config.onRequest(request);
+      await this.config.onRequest(request)
     }
 
-    this.debugSection('Request', JSON.stringify(request));
+    this.debugSection('Request', JSON.stringify(request))
 
-    let response;
+    let response
     try {
-      response = await this.axios(request);
+      response = await this.axios(request)
     } catch (err) {
-      if (!err.response) throw err;
-      this.debugSection(
-        'Response',
-        `Response error. Status code: ${err.response.status}`,
-      );
-      response = err.response;
+      if (!err.response) throw err
+      this.debugSection('Response', `Response error. Status code: ${err.response.status}`)
+      response = err.response
     }
 
     if (this.config.onResponse) {
-      await this.config.onResponse(response);
+      await this.config.onResponse(response)
     }
 
-    this.debugSection('Response', JSON.stringify(response.data));
-    return response;
+    this.debugSection('Response', JSON.stringify(response.data))
+    return response
   }
 
   /**
@@ -122,7 +123,7 @@ class GraphQL extends Helper {
       method: 'POST',
       data: operation,
       headers,
-    };
+    }
   }
 
   /**
@@ -148,15 +149,15 @@ class GraphQL extends Helper {
    */
   async sendQuery(query, variables, options = {}, headers = {}) {
     if (typeof query !== 'string') {
-      throw new Error(`query expected to be a String, instead received ${typeof query}`);
+      throw new Error(`query expected to be a String, instead received ${typeof query}`)
     }
     const operation = {
       query,
       variables,
       ...options,
-    };
-    const request = this._prepareGraphQLRequest(operation, headers);
-    return this._executeQuery(request);
+    }
+    const request = this._prepareGraphQLRequest(operation, headers)
+    return this._executeQuery(request)
   }
 
   /**
@@ -188,19 +189,19 @@ class GraphQL extends Helper {
    */
   async sendMutation(mutation, variables, options = {}, headers = {}) {
     if (typeof mutation !== 'string') {
-      throw new Error(`mutation expected to be a String, instead received ${typeof mutation}`);
+      throw new Error(`mutation expected to be a String, instead received ${typeof mutation}`)
     }
     const operation = {
       query: mutation,
       variables,
       ...options,
-    };
-    const request = this._prepareGraphQLRequest(operation, headers);
-    return this._executeQuery(request);
+    }
+    const request = this._prepareGraphQLRequest(operation, headers)
+    return this._executeQuery(request)
   }
 
   _setRequestTimeout(newTimeout) {
-    this.options.timeout = newTimeout;
+    this.options.timeout = newTimeout
   }
 
   /**
@@ -209,7 +210,7 @@ class GraphQL extends Helper {
    * @param {object} headers headers list
    */
   haveRequestHeaders(headers) {
-    this.headers = { ...this.headers, ...headers };
+    this.headers = { ...this.headers, ...headers }
   }
 
   /**
@@ -223,7 +224,7 @@ class GraphQL extends Helper {
    * @param {string | CodeceptJS.Secret} accessToken  Bearer access token
    */
   amBearerAuthenticated(accessToken) {
-    this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` });
+    this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` })
   }
 }
-module.exports = GraphQL;
+module.exports = GraphQL
diff --git a/lib/helper/GraphQLDataFactory.js b/lib/helper/GraphQLDataFactory.js
index 9a6d802e6..e45f7fe19 100644
--- a/lib/helper/GraphQLDataFactory.js
+++ b/lib/helper/GraphQLDataFactory.js
@@ -1,7 +1,7 @@
-const path = require('path');
+const path = require('path')
 
-const Helper = require('@codeceptjs/helper');
-const GraphQL = require('./GraphQL');
+const Helper = require('@codeceptjs/helper')
+const GraphQL = require('./GraphQL')
 
 /**
  * Helper for managing remote data using GraphQL queries.
@@ -151,52 +151,52 @@ const GraphQL = require('./GraphQL');
  */
 class GraphQLDataFactory extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
     const defaultConfig = {
       cleanup: true,
       GraphQL: {},
       factories: {},
-    };
-    this.config = Object.assign(defaultConfig, this.config);
+    }
+    this.config = Object.assign(defaultConfig, this.config)
 
     if (this.config.headers) {
-      this.config.GraphQL.defaultHeaders = this.config.headers;
+      this.config.GraphQL.defaultHeaders = this.config.headers
     }
     if (this.config.onRequest) {
-      this.config.GraphQL.onRequest = this.config.onRequest;
+      this.config.GraphQL.onRequest = this.config.onRequest
     }
-    this.graphqlHelper = new GraphQL(Object.assign(this.config.GraphQL, { endpoint: this.config.endpoint }));
-    this.factories = this.config.factories;
+    this.graphqlHelper = new GraphQL(Object.assign(this.config.GraphQL, { endpoint: this.config.endpoint }))
+    this.factories = this.config.factories
 
-    this.created = {};
-    Object.keys(this.factories).forEach(f => (this.created[f] = []));
+    this.created = {}
+    Object.keys(this.factories).forEach((f) => (this.created[f] = []))
   }
 
   static _checkRequirements() {
     try {
-      require('axios');
-      require('rosie');
+      require('axios')
+      require('rosie')
     } catch (e) {
-      return ['axios', 'rosie'];
+      return ['axios', 'rosie']
     }
   }
 
   _after() {
     if (!this.config.cleanup) {
-      return Promise.resolve();
+      return Promise.resolve()
     }
-    const promises = [];
+    const promises = []
     // clean up all created items
     for (const mutationName in this.created) {
-      const createdItems = this.created[mutationName];
-      if (!createdItems.length) continue;
-      this.debug(`Deleting ${createdItems.length} ${mutationName}(s)`);
+      const createdItems = this.created[mutationName]
+      if (!createdItems.length) continue
+      this.debug(`Deleting ${createdItems.length} ${mutationName}(s)`)
       for (const itemData of createdItems) {
-        promises.push(this._requestDelete(mutationName, itemData));
+        promises.push(this._requestDelete(mutationName, itemData))
       }
     }
-    return Promise.all(promises);
+    return Promise.all(promises)
   }
 
   /**
@@ -214,9 +214,9 @@ class GraphQLDataFactory extends Helper {
    * @param {*} params predefined parameters
    */
   mutateData(operation, params) {
-    const variables = this._createItem(operation, params);
-    this.debug(`Creating ${operation} ${JSON.stringify(variables)}`);
-    return this._requestCreate(operation, variables);
+    const variables = this._createItem(operation, params)
+    this.debug(`Creating ${operation} ${JSON.stringify(variables)}`)
+    return this._requestCreate(operation, variables)
   }
 
   /**
@@ -235,26 +235,26 @@ class GraphQLDataFactory extends Helper {
    * @param {*} params
    */
   mutateMultiple(operation, times, params) {
-    const promises = [];
+    const promises = []
     for (let i = 0; i < times; i++) {
-      promises.push(this.mutateData(operation, params));
+      promises.push(this.mutateData(operation, params))
     }
-    return Promise.all(promises);
+    return Promise.all(promises)
   }
 
   _createItem(operation, data) {
     if (!this.factories[operation]) {
-      throw new Error(`Mutation ${operation} is not defined in config.factories`);
+      throw new Error(`Mutation ${operation} is not defined in config.factories`)
     }
-    let modulePath = this.factories[operation].factory;
+    let modulePath = this.factories[operation].factory
     try {
       try {
-        require.resolve(modulePath);
+        require.resolve(modulePath)
       } catch (e) {
-        modulePath = path.join(global.codecept_dir, modulePath);
+        modulePath = path.join(global.codecept_dir, modulePath)
       }
-      const builder = require(modulePath);
-      return builder.build(data);
+      const builder = require(modulePath)
+      return builder.build(data)
     } catch (err) {
       throw new Error(`Couldn't load factory file from ${modulePath}, check that
 
@@ -265,7 +265,7 @@ class GraphQLDataFactory extends Helper {
         points to valid factory file.
         Factory file should export an object with build method.
 
-        Current file error: ${err.message}`);
+        Current file error: ${err.message}`)
     }
   }
 
@@ -277,13 +277,13 @@ class GraphQLDataFactory extends Helper {
    * @param {*} variables to be sent along with the query
    */
   _requestCreate(operation, variables) {
-    const { query } = this.factories[operation];
+    const { query } = this.factories[operation]
     return this.graphqlHelper.sendMutation(query, variables).then((response) => {
-      const data = response.data.data[operation];
-      this.created[operation].push(data);
-      this.debugSection('Created', `record: ${data}`);
-      return data;
-    });
+      const data = response.data.data[operation]
+      this.created[operation].push(data)
+      this.debugSection('Created', `record: ${data}`)
+      return data
+    })
   }
 
   /**
@@ -294,16 +294,15 @@ class GraphQLDataFactory extends Helper {
    * @param {*} data of the record to be deleted.
    */
   _requestDelete(operation, data) {
-    const deleteOperation = this.factories[operation].revert(data);
-    const { query, variables } = deleteOperation;
+    const deleteOperation = this.factories[operation].revert(data)
+    const { query, variables } = deleteOperation
 
-    return this.graphqlHelper.sendMutation(query, variables)
-      .then((response) => {
-        const idx = this.created[operation].indexOf(data);
-        this.debugSection('Deleted', `record: ${response.data.data}`);
-        this.created[operation].splice(idx, 1);
-      });
+    return this.graphqlHelper.sendMutation(query, variables).then((response) => {
+      const idx = this.created[operation].indexOf(data)
+      this.debugSection('Deleted', `record: ${response.data.data}`)
+      this.created[operation].splice(idx, 1)
+    })
   }
 }
 
-module.exports = GraphQLDataFactory;
+module.exports = GraphQLDataFactory
diff --git a/lib/helper/JSONResponse.js b/lib/helper/JSONResponse.js
index e651a6833..765b37fa9 100644
--- a/lib/helper/JSONResponse.js
+++ b/lib/helper/JSONResponse.js
@@ -1,13 +1,13 @@
-const Helper = require('@codeceptjs/helper');
+const Helper = require('@codeceptjs/helper')
 
-let expect;
+let expect
 
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-deep-match'));
-});
+import('chai').then((chai) => {
+  expect = chai.expect
+  chai.use(require('chai-deep-match'))
+})
 
-const joi = require('joi');
+const joi = require('joi')
 
 /**
  * This helper allows performing assertions on JSON responses paired with following helpers:
@@ -67,33 +67,35 @@ const joi = require('joi');
  */
 class JSONResponse extends Helper {
   constructor(config = {}) {
-    super(config);
+    super(config)
     this.options = {
       requestHelper: 'REST',
-    };
-    this.options = { ...this.options, ...config };
+    }
+    this.options = { ...this.options, ...config }
   }
 
   _beforeSuite() {
-    this.response = null;
+    this.response = null
     if (!this.helpers[this.options.requestHelper]) {
-      throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`);
+      throw new Error(
+        `Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`,
+      )
     }
     // connect to REST helper
     this.helpers[this.options.requestHelper].config.onResponse = (response) => {
-      this.response = response;
-    };
+      this.response = response
+    }
   }
 
   _before() {
-    this.response = null;
+    this.response = null
   }
 
   static _checkRequirements() {
     try {
-      require('joi');
+      require('joi')
     } catch (e) {
-      return ['joi'];
+      return ['joi']
     }
   }
 
@@ -107,8 +109,8 @@ class JSONResponse extends Helper {
    * @param {number} code
    */
   seeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).to.eql(code, 'Response code is not the same as expected');
+    this._checkResponseReady()
+    expect(this.response.status).to.eql(code, 'Response code is not the same as expected')
   }
 
   /**
@@ -121,35 +123,35 @@ class JSONResponse extends Helper {
    * @param {number} code
    */
   dontSeeResponseCodeIs(code) {
-    this._checkResponseReady();
-    expect(this.response.status).not.to.eql(code);
+    this._checkResponseReady()
+    expect(this.response.status).not.to.eql(code)
   }
 
   /**
    * Checks that the response code is 4xx
    */
   seeResponseCodeIsClientError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(400);
-    expect(this.response.status).to.be.lt(500);
+    this._checkResponseReady()
+    expect(this.response.status).to.be.gte(400)
+    expect(this.response.status).to.be.lt(500)
   }
 
   /**
    * Checks that the response code is 3xx
    */
   seeResponseCodeIsRedirection() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(300);
-    expect(this.response.status).to.be.lt(400);
+    this._checkResponseReady()
+    expect(this.response.status).to.be.gte(300)
+    expect(this.response.status).to.be.lt(400)
   }
 
   /**
    * Checks that the response code is 5xx
    */
   seeResponseCodeIsServerError() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(500);
-    expect(this.response.status).to.be.lt(600);
+    this._checkResponseReady()
+    expect(this.response.status).to.be.gte(500)
+    expect(this.response.status).to.be.lt(600)
   }
 
   /**
@@ -161,9 +163,9 @@ class JSONResponse extends Helper {
    * ```
    */
   seeResponseCodeIsSuccessful() {
-    this._checkResponseReady();
-    expect(this.response.status).to.be.gte(200);
-    expect(this.response.status).to.be.lt(300);
+    this._checkResponseReady()
+    expect(this.response.status).to.be.gte(200)
+    expect(this.response.status).to.be.lt(300)
   }
 
   /**
@@ -184,19 +186,19 @@ class JSONResponse extends Helper {
    * @param {object} json
    */
   seeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      let fails = 0;
+      let fails = 0
       for (const el of this.response.data) {
         try {
-          expect(el).to.deep.match(json);
+          expect(el).to.deep.match(json)
         } catch (err) {
-          fails++;
+          fails++
         }
       }
-      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true;
+      expect(fails < this.response.data.length, `No elements in array matched ${JSON.stringify(json)}`).to.be.true
     } else {
-      expect(this.response.data).to.deep.match(json);
+      expect(this.response.data).to.deep.match(json)
     }
   }
 
@@ -218,11 +220,11 @@ class JSONResponse extends Helper {
    * @param {object} json
    */
   dontSeeResponseContainsJson(json = {}) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).not.to.deep.match(json));
+      this.response.data.forEach((data) => expect(data).not.to.deep.match(json))
     } else {
-      expect(this.response.data).not.to.deep.match(json);
+      expect(this.response.data).not.to.deep.match(json)
     }
   }
 
@@ -246,11 +248,11 @@ class JSONResponse extends Helper {
    * @param {array} keys
    */
   seeResponseContainsKeys(keys = []) {
-    this._checkResponseReady();
+    this._checkResponseReady()
     if (Array.isArray(this.response.data)) {
-      this.response.data.forEach(data => expect(data).to.include.keys(keys));
+      this.response.data.forEach((data) => expect(data).to.include.keys(keys))
     } else {
-      expect(this.response.data).to.include.keys(keys);
+      expect(this.response.data).to.include.keys(keys)
     }
   }
 
@@ -268,10 +270,10 @@ class JSONResponse extends Helper {
    * @param {function} fn
    */
   seeResponseValidByCallback(fn) {
-    this._checkResponseReady();
-    fn({ ...this.response, expect });
-    const body = fn.toString();
-    fn.toString = () => `${body.split('\n')[1]}...`;
+    this._checkResponseReady()
+    fn({ ...this.response, expect })
+    const body = fn.toString()
+    fn.toString = () => `${body.split('\n')[1]}...`
   }
 
   /**
@@ -285,8 +287,8 @@ class JSONResponse extends Helper {
    * @param {object} resp
    */
   seeResponseEquals(resp) {
-    this._checkResponseReady();
-    expect(this.response.data).to.deep.equal(resp);
+    this._checkResponseReady()
+    expect(this.response.data).to.deep.equal(resp)
   }
 
   /**
@@ -317,22 +319,22 @@ class JSONResponse extends Helper {
    * @param {any} fnOrSchema
    */
   seeResponseMatchesJsonSchema(fnOrSchema) {
-    this._checkResponseReady();
-    let schema = fnOrSchema;
+    this._checkResponseReady()
+    let schema = fnOrSchema
     if (typeof fnOrSchema === 'function') {
-      schema = fnOrSchema(joi);
-      const body = fnOrSchema.toString();
-      fnOrSchema.toString = () => `${body.split('\n')[1]}...`;
+      schema = fnOrSchema(joi)
+      const body = fnOrSchema.toString()
+      fnOrSchema.toString = () => `${body.split('\n')[1]}...`
     }
-    if (!schema) throw new Error('Empty Joi schema provided, see https://joi.dev/ for details');
-    if (!joi.isSchema(schema)) throw new Error('Invalid Joi schema provided, see https://joi.dev/ for details');
-    schema.toString = () => schema.describe();
-    joi.assert(this.response.data, schema);
+    if (!schema) throw new Error('Empty Joi schema provided, see https://joi.dev/ for details')
+    if (!joi.isSchema(schema)) throw new Error('Invalid Joi schema provided, see https://joi.dev/ for details')
+    schema.toString = () => schema.describe()
+    joi.assert(this.response.data, schema)
   }
 
   _checkResponseReady() {
-    if (!this.response) throw new Error('Response is not available');
+    if (!this.response) throw new Error('Response is not available')
   }
 }
 
-module.exports = JSONResponse;
+module.exports = JSONResponse
diff --git a/lib/helper/Mochawesome.js b/lib/helper/Mochawesome.js
index 826b2f232..abc143af4 100644
--- a/lib/helper/Mochawesome.js
+++ b/lib/helper/Mochawesome.js
@@ -1,71 +1,71 @@
-let addMochawesomeContext;
-let currentTest;
-let currentSuite;
+let addMochawesomeContext
+let currentTest
+let currentSuite
 
-const Helper = require('@codeceptjs/helper');
-const { clearString } = require('../utils');
+const Helper = require('@codeceptjs/helper')
+const { clearString } = require('../utils')
 
 class Mochawesome extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
     // set defaults
     this.options = {
       uniqueScreenshotNames: false,
       disableScreenshots: false,
-    };
+    }
 
-    addMochawesomeContext = require('mochawesome/addContext');
-    this._createConfig(config);
+    addMochawesomeContext = require('mochawesome/addContext')
+    this._createConfig(config)
   }
 
   _createConfig(config) {
     // override defaults with config
-    Object.assign(this.options, config);
+    Object.assign(this.options, config)
   }
 
   _beforeSuite(suite) {
-    currentSuite = suite;
-    currentTest = '';
+    currentSuite = suite
+    currentTest = ''
   }
 
   _before() {
     if (currentSuite && currentSuite.ctx) {
-      currentTest = { test: currentSuite.ctx.currentTest };
+      currentTest = { test: currentSuite.ctx.currentTest }
     }
   }
 
   _test(test) {
-    currentTest = { test };
+    currentTest = { test }
   }
 
   _failed(test) {
-    if (this.options.disableScreenshots) return;
-    let fileName;
+    if (this.options.disableScreenshots) return
+    let fileName
     // Get proper name if we are fail on hook
     if (test.ctx.test.type === 'hook') {
-      currentTest = { test: test.ctx.test };
+      currentTest = { test: test.ctx.test }
       // ignore retries if we are in hook
-      test._retries = -1;
-      fileName = clearString(`${test.title}_${currentTest.test.title}`);
+      test._retries = -1
+      fileName = clearString(`${test.title}_${currentTest.test.title}`)
     } else {
-      currentTest = { test };
-      fileName = clearString(test.title);
+      currentTest = { test }
+      fileName = clearString(test.title)
     }
     if (this.options.uniqueScreenshotNames) {
-      const uuid = test.uuid || test.ctx.test.uuid;
-      fileName = `${fileName.substring(0, 10)}_${uuid}`;
+      const uuid = test.uuid || test.ctx.test.uuid
+      fileName = `${fileName.substring(0, 10)}_${uuid}`
     }
     if (test._retries < 1 || test._retries === test.retryNum) {
-      fileName = `${fileName}.failed.png`;
-      return addMochawesomeContext(currentTest, fileName);
+      fileName = `${fileName}.failed.png`
+      return addMochawesomeContext(currentTest, fileName)
     }
   }
 
   addMochawesomeContext(context) {
-    if (currentTest === '') currentTest = { test: currentSuite.ctx.test };
-    return addMochawesomeContext(currentTest, context);
+    if (currentTest === '') currentTest = { test: currentSuite.ctx.test }
+    return addMochawesomeContext(currentTest, context)
   }
 }
 
-module.exports = Mochawesome;
+module.exports = Mochawesome
diff --git a/lib/helper/MockServer.js b/lib/helper/MockServer.js
index 9cb748808..7278c1021 100644
--- a/lib/helper/MockServer.js
+++ b/lib/helper/MockServer.js
@@ -1,4 +1,4 @@
-const { mock, settings } = require('pactum');
+const { mock, settings } = require('pactum')
 
 /**
  * ## Configuration
@@ -18,7 +18,7 @@ let config = {
     key: '',
     cert: '',
   },
-};
+}
 
 /**
  * MockServer
@@ -141,10 +141,10 @@ let config = {
  */
 class MockServer {
   constructor(passedConfig) {
-    settings.setLogLevel('SILENT');
-    config = { ...passedConfig };
+    settings.setLogLevel('SILENT')
+    config = { ...passedConfig }
     if (global.debugMode) {
-      settings.setLogLevel('VERBOSE');
+      settings.setLogLevel('VERBOSE')
     }
   }
 
@@ -155,10 +155,10 @@ class MockServer {
    * @returns void
    */
   async startMockServer(port) {
-    const _config = { ...config };
-    if (port) _config.port = port;
-    await mock.setDefaults(_config);
-    await mock.start();
+    const _config = { ...config }
+    if (port) _config.port = port
+    await mock.setDefaults(_config)
+    await mock.start()
   }
 
   /**
@@ -168,7 +168,7 @@ class MockServer {
    *
    */
   async stopMockServer() {
-    await mock.stop();
+    await mock.stop()
   }
 
   /**
@@ -214,8 +214,8 @@ class MockServer {
    *
    */
   async addInteractionToMockServer(interaction) {
-    await mock.addInteraction(interaction);
+    await mock.addInteraction(interaction)
   }
 }
 
-module.exports = MockServer;
+module.exports = MockServer
diff --git a/lib/helper/Nightmare.js b/lib/helper/Nightmare.js
index 59947bec6..d89fc520a 100644
--- a/lib/helper/Nightmare.js
+++ b/lib/helper/Nightmare.js
@@ -1,29 +1,24 @@
-const path = require('path');
-
-const urlResolve = require('url').resolve;
-
-const Helper = require('@codeceptjs/helper');
-const { includes: stringIncludes } = require('../assert/include');
-const { urlEquals } = require('../assert/equal');
-const { equals } = require('../assert/equal');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
-const Locator = require('../locator');
-const ElementNotFound = require('./errors/ElementNotFound');
-const {
-  xpathLocator,
-  fileExists,
-  screenshotOutputFolder,
-  toCamelCase,
-} = require('../utils');
+const path = require('path')
+
+const urlResolve = require('url').resolve
+
+const Helper = require('@codeceptjs/helper')
+const { includes: stringIncludes } = require('../assert/include')
+const { urlEquals } = require('../assert/equal')
+const { equals } = require('../assert/equal')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
+const Locator = require('../locator')
+const ElementNotFound = require('./errors/ElementNotFound')
+const { xpathLocator, fileExists, screenshotOutputFolder, toCamelCase } = require('../utils')
 
 const specialKeys = {
   Backspace: '\u0008',
   Enter: '\u000d',
   Delete: '\u007f',
-};
+}
 
-let withinStatus = false;
+let withinStatus = false
 
 /**
  * Nightmare helper wraps [Nightmare](https://github.com/segmentio/nightmare) library to provide
@@ -54,12 +49,12 @@ let withinStatus = false;
  */
 class Nightmare extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
-    this.isRunning = false;
+    this.isRunning = false
 
     // override defaults with config
-    this._setConfig(config);
+    this._setConfig(config)
   }
 
   _validateConfig(config) {
@@ -75,235 +70,268 @@ class Nightmare extends Helper {
       keepCookies: false,
       js_errors: null,
       enableHAR: false,
-    };
+    }
 
-    return Object.assign(defaults, config);
+    return Object.assign(defaults, config)
   }
 
   static _config() {
     return [
       { name: 'url', message: 'Base url of site to be tested', default: 'http://localhost' },
       {
-        name: 'show', message: 'Show browser window', default: true, type: 'confirm',
+        name: 'show',
+        message: 'Show browser window',
+        default: true,
+        type: 'confirm',
       },
-    ];
+    ]
   }
 
   static _checkRequirements() {
     try {
-      require('nightmare');
+      require('nightmare')
     } catch (e) {
-      return ['nightmare'];
+      return ['nightmare']
     }
   }
 
   async _init() {
-    this.Nightmare = require('nightmare');
+    this.Nightmare = require('nightmare')
 
     if (this.options.enableHAR) {
-      require('nightmare-har-plugin').install(this.Nightmare);
+      require('nightmare-har-plugin').install(this.Nightmare)
     }
 
     this.Nightmare.action('findElements', function (locator, contextEl, done) {
       if (!done) {
-        done = contextEl;
-        contextEl = null;
+        done = contextEl
+        contextEl = null
       }
 
-      const by = Object.keys(locator)[0];
-      const value = locator[by];
+      const by = Object.keys(locator)[0]
+      const value = locator[by]
 
-      this.evaluate_now((by, locator, contextEl) => window.codeceptjs.findAndStoreElements(by, locator, contextEl), done, by, value, contextEl);
-    });
+      this.evaluate_now(
+        (by, locator, contextEl) => window.codeceptjs.findAndStoreElements(by, locator, contextEl),
+        done,
+        by,
+        value,
+        contextEl,
+      )
+    })
 
     this.Nightmare.action('findElement', function (locator, contextEl, done) {
       if (!done) {
-        done = contextEl;
-        contextEl = null;
+        done = contextEl
+        contextEl = null
       }
 
-      const by = Object.keys(locator)[0];
-      const value = locator[by];
+      const by = Object.keys(locator)[0]
+      const value = locator[by]
 
-      this.evaluate_now((by, locator, contextEl) => {
-        const res = window.codeceptjs.findAndStoreElement(by, locator, contextEl);
-        if (res === null) {
-          throw new Error(`Element ${(new Locator(locator))} couldn't be located by ${by}`);
-        }
-        return res;
-      }, done, by, value, contextEl);
-    });
+      this.evaluate_now(
+        (by, locator, contextEl) => {
+          const res = window.codeceptjs.findAndStoreElement(by, locator, contextEl)
+          if (res === null) {
+            throw new Error(`Element ${new Locator(locator)} couldn't be located by ${by}`)
+          }
+          return res
+        },
+        done,
+        by,
+        value,
+        contextEl,
+      )
+    })
 
     this.Nightmare.action('asyncScript', function () {
-      let args = Array.prototype.slice.call(arguments);
-      const done = args.pop();
-      args = args.splice(1, 0, done);
-      this.evaluate_now.apply(this, args);
-    });
+      let args = Array.prototype.slice.call(arguments)
+      const done = args.pop()
+      args = args.splice(1, 0, done)
+      this.evaluate_now.apply(this, args)
+    })
 
     this.Nightmare.action('enterText', function (el, text, clean, done) {
-      const child = this.child;
-      const typeFn = () => child.call('type', text, done);
-
-      this.evaluate_now((el, clean) => {
-        const element = window.codeceptjs.fetchElement(el);
-        if (clean) element.value = '';
-        element.focus();
-      }, () => {
-        if (clean) return typeFn();
-        child.call('pressKey', 'End', typeFn); // type End before
-      }, el, clean);
-    });
-
-    this.Nightmare.action('pressKey', (ns, options, parent, win, renderer, done) => {
-      parent.respondTo('pressKey', (ch, done) => {
-        win.webContents.sendInputEvent({
-          type: 'keyDown',
-          keyCode: ch,
-        });
-
-        win.webContents.sendInputEvent({
-          type: 'char',
-          keyCode: ch,
-        });
-
-        win.webContents.sendInputEvent({
-          type: 'keyUp',
-          keyCode: ch,
-        });
-        done();
-      });
-      done();
-    }, function (key, done) {
-      this.child.call('pressKey', key, done);
-    });
-
-    this.Nightmare.action('triggerMouseEvent', (ns, options, parent, win, renderer, done) => {
-      parent.respondTo('triggerMouseEvent', (evt, done) => {
-        win.webContents.sendInputEvent(evt);
-        done();
-      });
-      done();
-    }, function (event, done) {
-      this.child.call('triggerMouseEvent', event, done);
-    });
+      const child = this.child
+      const typeFn = () => child.call('type', text, done)
+
+      this.evaluate_now(
+        (el, clean) => {
+          const element = window.codeceptjs.fetchElement(el)
+          if (clean) element.value = ''
+          element.focus()
+        },
+        () => {
+          if (clean) return typeFn()
+          child.call('pressKey', 'End', typeFn) // type End before
+        },
+        el,
+        clean,
+      )
+    })
+
+    this.Nightmare.action(
+      'pressKey',
+      (ns, options, parent, win, renderer, done) => {
+        parent.respondTo('pressKey', (ch, done) => {
+          win.webContents.sendInputEvent({
+            type: 'keyDown',
+            keyCode: ch,
+          })
+
+          win.webContents.sendInputEvent({
+            type: 'char',
+            keyCode: ch,
+          })
+
+          win.webContents.sendInputEvent({
+            type: 'keyUp',
+            keyCode: ch,
+          })
+          done()
+        })
+        done()
+      },
+      function (key, done) {
+        this.child.call('pressKey', key, done)
+      },
+    )
+
+    this.Nightmare.action(
+      'triggerMouseEvent',
+      (ns, options, parent, win, renderer, done) => {
+        parent.respondTo('triggerMouseEvent', (evt, done) => {
+          win.webContents.sendInputEvent(evt)
+          done()
+        })
+        done()
+      },
+      function (event, done) {
+        this.child.call('triggerMouseEvent', event, done)
+      },
+    )
 
     this.Nightmare.action(
       'upload',
       (ns, options, parent, win, renderer, done) => {
         parent.respondTo('upload', (selector, pathsToUpload, done) => {
-          parent.emit('log', 'paths', pathsToUpload);
+          parent.emit('log', 'paths', pathsToUpload)
           try {
-          // attach the debugger
-          // NOTE: this will fail if devtools is open
-            win.webContents.debugger.attach('1.1');
+            // attach the debugger
+            // NOTE: this will fail if devtools is open
+            win.webContents.debugger.attach('1.1')
           } catch (e) {
-            parent.emit('log', 'problem attaching', e);
-            return done(e);
+            parent.emit('log', 'problem attaching', e)
+            return done(e)
           }
 
           win.webContents.debugger.sendCommand('DOM.getDocument', {}, (err, domDocument) => {
-            win.webContents.debugger.sendCommand('DOM.querySelector', {
-              nodeId: domDocument.root.nodeId,
-              selector,
-            }, (err, queryResult) => {
-            // HACK: chromium errors appear to be unpopulated objects?
-              if (Object.keys(err)
-                .length > 0) {
-                parent.emit('log', 'problem selecting', err);
-                return done(err);
-              }
-              win.webContents.debugger.sendCommand('DOM.setFileInputFiles', {
-                nodeId: queryResult.nodeId,
-                files: pathsToUpload,
-              }, (err) => {
-                if (Object.keys(err)
-                  .length > 0) {
-                  parent.emit('log', 'problem setting input', err);
-                  return done(err);
+            win.webContents.debugger.sendCommand(
+              'DOM.querySelector',
+              {
+                nodeId: domDocument.root.nodeId,
+                selector,
+              },
+              (err, queryResult) => {
+                // HACK: chromium errors appear to be unpopulated objects?
+                if (Object.keys(err).length > 0) {
+                  parent.emit('log', 'problem selecting', err)
+                  return done(err)
                 }
-                win.webContents.debugger.detach();
-                done(null, pathsToUpload);
-              });
-            });
-          });
-        });
-        done();
+                win.webContents.debugger.sendCommand(
+                  'DOM.setFileInputFiles',
+                  {
+                    nodeId: queryResult.nodeId,
+                    files: pathsToUpload,
+                  },
+                  (err) => {
+                    if (Object.keys(err).length > 0) {
+                      parent.emit('log', 'problem setting input', err)
+                      return done(err)
+                    }
+                    win.webContents.debugger.detach()
+                    done(null, pathsToUpload)
+                  },
+                )
+              },
+            )
+          })
+        })
+        done()
       },
       function (selector, pathsToUpload, done) {
         if (!Array.isArray(pathsToUpload)) {
-          pathsToUpload = [pathsToUpload];
+          pathsToUpload = [pathsToUpload]
         }
         this.child.call('upload', selector, pathsToUpload, (err, stuff) => {
-          done(err, stuff);
-        });
+          done(err, stuff)
+        })
       },
-    );
+    )
 
-    return Promise.resolve();
+    return Promise.resolve()
   }
 
   async _beforeSuite() {
     if (!this.options.restart && !this.isRunning) {
-      this.debugSection('Session', 'Starting singleton browser session');
-      return this._startBrowser();
+      this.debugSection('Session', 'Starting singleton browser session')
+      return this._startBrowser()
     }
   }
 
   async _before() {
-    if (this.options.restart) return this._startBrowser();
-    if (!this.isRunning) return this._startBrowser();
-    return this.browser;
+    if (this.options.restart) return this._startBrowser()
+    if (!this.isRunning) return this._startBrowser()
+    return this.browser
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
     if (this.options.restart) {
-      this.isRunning = false;
-      return this._stopBrowser();
+      this.isRunning = false
+      return this._stopBrowser()
     }
     if (this.options.enableHAR) {
-      await this.browser.resetHAR();
+      await this.browser.resetHAR()
     }
-    if (this.options.keepBrowserState) return;
+    if (this.options.keepBrowserState) return
     if (this.options.keepCookies) {
-      await this.browser.cookies.clearAll();
+      await this.browser.cookies.clearAll()
     }
-    this.debugSection('Session', 'cleaning up');
-    return this.executeScript(() => localStorage.clear());
+    this.debugSection('Session', 'cleaning up')
+    return this.executeScript(() => localStorage.clear())
   }
 
-  _afterSuite() {
-  }
+  _afterSuite() {}
 
   _finishTest() {
     if (!this.options.restart && this.isRunning) {
-      this._stopBrowser();
+      this._stopBrowser()
     }
   }
 
   async _startBrowser() {
-    this.context = this.options.rootElement;
+    this.context = this.options.rootElement
     if (this.options.enableHAR) {
-      this.browser = this.Nightmare(Object.assign(require('nightmare-har-plugin').getDevtoolsOptions(), this.options));
-      await this.browser;
-      await this.browser.waitForDevtools();
+      this.browser = this.Nightmare(Object.assign(require('nightmare-har-plugin').getDevtoolsOptions(), this.options))
+      await this.browser
+      await this.browser.waitForDevtools()
     } else {
-      this.browser = this.Nightmare(this.options);
-      await this.browser;
+      this.browser = this.Nightmare(this.options)
+      await this.browser
     }
-    await this.browser.goto('about:blank'); // Load a blank page so .saveScreenshot (/evaluate) will work
-    this.isRunning = true;
-    this.browser.on('dom-ready', () => this._injectClientScripts());
-    this.browser.on('did-start-loading', () => this._injectClientScripts());
-    this.browser.on('will-navigate', () => this._injectClientScripts());
+    await this.browser.goto('about:blank') // Load a blank page so .saveScreenshot (/evaluate) will work
+    this.isRunning = true
+    this.browser.on('dom-ready', () => this._injectClientScripts())
+    this.browser.on('did-start-loading', () => this._injectClientScripts())
+    this.browser.on('will-navigate', () => this._injectClientScripts())
     this.browser.on('console', (type, message) => {
-      this.debug(`${type}: ${message}`);
-    });
+      this.debug(`${type}: ${message}`)
+    })
 
     if (this.options.windowSize) {
-      const size = this.options.windowSize.split('x');
-      return this.browser.viewport(parseInt(size[0], 10), parseInt(size[1], 10));
+      const size = this.options.windowSize.split('x')
+      return this.browser.viewport(parseInt(size[0], 10), parseInt(size[1], 10))
     }
   }
 
@@ -316,45 +344,49 @@ class Nightmare extends Helper {
    * ```
    */
   async grabHAR() {
-    return this.browser.getHAR();
+    return this.browser.getHAR()
   }
 
   async saveHAR(fileName) {
-    const outputFile = path.join(global.output_dir, fileName);
-    this.debug(`HAR is saving to ${outputFile}`);
+    const outputFile = path.join(global.output_dir, fileName)
+    this.debug(`HAR is saving to ${outputFile}`)
 
     await this.browser.getHAR().then((har) => {
-      require('fs').writeFileSync(outputFile, JSON.stringify({ log: har }));
-    });
+      require('fs').writeFileSync(outputFile, JSON.stringify({ log: har }))
+    })
   }
 
   async resetHAR() {
-    await this.browser.resetHAR();
+    await this.browser.resetHAR()
   }
 
   async _stopBrowser() {
     return this.browser.end().catch((error) => {
-      this.debugSection('Error on End', error);
-    });
+      this.debugSection('Error on End', error)
+    })
   }
 
   async _withinBegin(locator) {
-    this.context = locator;
-    locator = new Locator(locator, 'css');
-    withinStatus = true;
-    return this.browser.evaluate((by, locator) => {
-      const el = window.codeceptjs.findElement(by, locator);
-      if (!el) throw new Error(`Element by ${by}: ${locator} not found`);
-      window.codeceptjs.within = el;
-    }, locator.type, locator.value);
+    this.context = locator
+    locator = new Locator(locator, 'css')
+    withinStatus = true
+    return this.browser.evaluate(
+      (by, locator) => {
+        const el = window.codeceptjs.findElement(by, locator)
+        if (!el) throw new Error(`Element by ${by}: ${locator} not found`)
+        window.codeceptjs.within = el
+      },
+      locator.type,
+      locator.value,
+    )
   }
 
   _withinEnd() {
-    this.context = this.options.rootElement;
-    withinStatus = false;
+    this.context = this.options.rootElement
+    withinStatus = false
     return this.browser.evaluate(() => {
-      window.codeceptjs.within = null;
-    });
+      window.codeceptjs.within = null
+    })
   }
 
   /**
@@ -377,10 +409,14 @@ class Nightmare extends Helper {
    * ```
    */
   _locate(locator) {
-    locator = new Locator(locator, 'css');
-    return this.browser.evaluate((by, locator) => {
-      return window.codeceptjs.findAndStoreElements(by, locator);
-    }, locator.type, locator.value);
+    locator = new Locator(locator, 'css')
+    return this.browser.evaluate(
+      (by, locator) => {
+        return window.codeceptjs.findAndStoreElements(by, locator)
+      },
+      locator.type,
+      locator.value,
+    )
   }
 
   /**
@@ -392,7 +428,7 @@ class Nightmare extends Helper {
    * ```
    */
   haveHeader(header, value) {
-    return this.browser.header(header, value);
+    return this.browser.header(header, value)
   }
 
   /**
@@ -401,223 +437,237 @@ class Nightmare extends Helper {
    *
    */
   async amOnPage(url, headers = null) {
-    if (!(/^\w+\:\/\//.test(url))) {
-      url = urlResolve(this.options.url, url);
+    if (!/^\w+\:\/\//.test(url)) {
+      url = urlResolve(this.options.url, url)
     }
-    const currentUrl = await this.browser.url();
+    const currentUrl = await this.browser.url()
     if (url === currentUrl) {
       // navigating to the same url will cause an error in nightmare, so don't do it
-      return;
+      return
     }
     return this.browser.goto(url, headers).then((res) => {
-      this.debugSection('URL', res.url);
-      this.debugSection('Code', res.code);
-      this.debugSection('Headers', JSON.stringify(res.headers));
-    });
+      this.debugSection('URL', res.url)
+      this.debugSection('Code', res.code)
+      this.debugSection('Headers', JSON.stringify(res.headers))
+    })
   }
 
   /**
    * {{> seeInTitle }}
    */
   async seeInTitle(text) {
-    const title = await this.browser.title();
-    stringIncludes('web page title').assert(text, title);
+    const title = await this.browser.title()
+    stringIncludes('web page title').assert(text, title)
   }
 
   /**
    * {{> dontSeeInTitle }}
    */
   async dontSeeInTitle(text) {
-    const title = await this.browser.title();
-    stringIncludes('web page title').negate(text, title);
+    const title = await this.browser.title()
+    stringIncludes('web page title').negate(text, title)
   }
 
   /**
    * {{> grabTitle }}
    */
   async grabTitle() {
-    return this.browser.title();
+    return this.browser.title()
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    return this.browser.url();
+    return this.browser.url()
   }
 
   /**
    * {{> seeInCurrentUrl }}
    */
   async seeInCurrentUrl(url) {
-    const currentUrl = await this.browser.url();
-    stringIncludes('url').assert(url, currentUrl);
+    const currentUrl = await this.browser.url()
+    stringIncludes('url').assert(url, currentUrl)
   }
 
   /**
    * {{> dontSeeInCurrentUrl }}
    */
   async dontSeeInCurrentUrl(url) {
-    const currentUrl = await this.browser.url();
-    stringIncludes('url').negate(url, currentUrl);
+    const currentUrl = await this.browser.url()
+    stringIncludes('url').negate(url, currentUrl)
   }
 
   /**
    * {{> seeCurrentUrlEquals }}
    */
   async seeCurrentUrlEquals(url) {
-    const currentUrl = await this.browser.url();
-    urlEquals(this.options.url).assert(url, currentUrl);
+    const currentUrl = await this.browser.url()
+    urlEquals(this.options.url).assert(url, currentUrl)
   }
 
   /**
    * {{> dontSeeCurrentUrlEquals }}
    */
   async dontSeeCurrentUrlEquals(url) {
-    const currentUrl = await this.browser.url();
-    urlEquals(this.options.url).negate(url, currentUrl);
+    const currentUrl = await this.browser.url()
+    urlEquals(this.options.url).negate(url, currentUrl)
   }
 
   /**
    * {{> see }}
    */
   async see(text, context = null) {
-    return proceedSee.call(this, 'assert', text, context);
+    return proceedSee.call(this, 'assert', text, context)
   }
 
   /**
    * {{> dontSee }}
    */
   dontSee(text, context = null) {
-    return proceedSee.call(this, 'negate', text, context);
+    return proceedSee.call(this, 'negate', text, context)
   }
 
   /**
    * {{> seeElement }}
    */
   async seeElement(locator) {
-    locator = new Locator(locator, 'css');
-    const num = await this.browser.evaluate((by, locator) => {
-      return window.codeceptjs.findElements(by, locator).filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length;
-    }, locator.type, locator.value);
-    equals('number of elements on a page').negate(0, num);
+    locator = new Locator(locator, 'css')
+    const num = await this.browser.evaluate(
+      (by, locator) => {
+        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+      },
+      locator.type,
+      locator.value,
+    )
+    equals('number of elements on a page').negate(0, num)
   }
 
   /**
    * {{> dontSeeElement }}
    */
   async dontSeeElement(locator) {
-    locator = new Locator(locator, 'css');
-    locator = new Locator(locator, 'css');
-    const num = await this.browser.evaluate((by, locator) => {
-      return window.codeceptjs.findElements(by, locator).filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length;
-    }, locator.type, locator.value);
-    equals('number of elements on a page').assert(0, num);
+    locator = new Locator(locator, 'css')
+    locator = new Locator(locator, 'css')
+    const num = await this.browser.evaluate(
+      (by, locator) => {
+        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+      },
+      locator.type,
+      locator.value,
+    )
+    equals('number of elements on a page').assert(0, num)
   }
 
   /**
    * {{> seeElementInDOM }}
    */
   async seeElementInDOM(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    empty('elements').negate(els.fill('ELEMENT'));
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    empty('elements').negate(els.fill('ELEMENT'))
   }
 
   /**
    * {{> dontSeeElementInDOM }}
    */
   async dontSeeElementInDOM(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    empty('elements').assert(els.fill('ELEMENT'));
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    empty('elements').assert(els.fill('ELEMENT'))
   }
 
   /**
    * {{> seeInSource }}
    */
   async seeInSource(text) {
-    const source = await this.browser.evaluate(() => document.documentElement.outerHTML);
-    stringIncludes('HTML source of a page').assert(text, source);
+    const source = await this.browser.evaluate(() => document.documentElement.outerHTML)
+    stringIncludes('HTML source of a page').assert(text, source)
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    const source = await this.browser.evaluate(() => document.documentElement.outerHTML);
-    stringIncludes('HTML source of a page').negate(text, source);
+    const source = await this.browser.evaluate(() => document.documentElement.outerHTML)
+    stringIncludes('HTML source of a page').negate(text, source)
   }
 
   /**
    * {{> seeNumberOfElements }}
    */
   async seeNumberOfElements(locator, num) {
-    const elements = await this._locate(locator);
-    return equals(`expected number of elements (${(new Locator(locator))}) is ${num}, but found ${elements.length}`).assert(elements.length, num);
+    const elements = await this._locate(locator)
+    return equals(
+      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
+    ).assert(elements.length, num)
   }
 
   /**
    * {{> seeNumberOfVisibleElements }}
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const res = await this.grabNumberOfVisibleElements(locator);
-    return equals(`expected number of visible elements (${(new Locator(locator))}) is ${num}, but found ${res}`).assert(res, num);
+    const res = await this.grabNumberOfVisibleElements(locator)
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
+      res,
+      num,
+    )
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    locator = new Locator(locator, 'css');
+    locator = new Locator(locator, 'css')
 
-    const num = await this.browser.evaluate((by, locator) => {
-      return window.codeceptjs.findElements(by, locator)
-        .filter(e => e.offsetWidth > 0 && e.offsetHeight > 0).length;
-    }, locator.type, locator.value);
+    const num = await this.browser.evaluate(
+      (by, locator) => {
+        return window.codeceptjs.findElements(by, locator).filter((e) => e.offsetWidth > 0 && e.offsetHeight > 0).length
+      },
+      locator.type,
+      locator.value,
+    )
 
-    return num;
+    return num
   }
 
   /**
    * {{> click }}
    */
   async click(locator, context = null) {
-    const el = await findClickable.call(this, locator, context);
-    assertElementExists(el, locator, 'Clickable');
-    return this.browser.evaluate(el => window.codeceptjs.clickEl(el), el)
-      .wait(this.options.waitForAction);
+    const el = await findClickable.call(this, locator, context)
+    assertElementExists(el, locator, 'Clickable')
+    return this.browser.evaluate((el) => window.codeceptjs.clickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
    * {{> doubleClick }}
    */
   async doubleClick(locator, context = null) {
-    const el = await findClickable.call(this, locator, context);
-    assertElementExists(el, locator, 'Clickable');
-    return this.browser.evaluate(el => window.codeceptjs.doubleClickEl(el), el)
-      .wait(this.options.waitForAction);
+    const el = await findClickable.call(this, locator, context)
+    assertElementExists(el, locator, 'Clickable')
+    return this.browser.evaluate((el) => window.codeceptjs.doubleClickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
    * {{> rightClick }}
    */
   async rightClick(locator, context = null) {
-    const el = await findClickable.call(this, locator, context);
-    assertElementExists(el, locator, 'Clickable');
-    return this.browser.evaluate(el => window.codeceptjs.rightClickEl(el), el)
-      .wait(this.options.waitForAction);
+    const el = await findClickable.call(this, locator, context)
+    assertElementExists(el, locator, 'Clickable')
+    return this.browser.evaluate((el) => window.codeceptjs.rightClickEl(el), el).wait(this.options.waitForAction)
   }
 
   /**
    * {{> moveCursorTo }}
    */
   async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
-    locator = new Locator(locator, 'css');
-    const el = await this.browser.findElement(locator.toStrict());
-    assertElementExists(el, locator);
-    return this.browser.evaluate((el, x, y) => window.codeceptjs.hoverEl(el, x, y), el, offsetX, offsetY)
-      .wait(this.options.waitForAction); // wait for hover event to happen
+    locator = new Locator(locator, 'css')
+    const el = await this.browser.findElement(locator.toStrict())
+    assertElementExists(el, locator)
+    return this.browser
+      .evaluate((el, x, y) => window.codeceptjs.hoverEl(el, x, y), el, offsetX, offsetY)
+      .wait(this.options.waitForAction) // wait for hover event to happen
   }
 
   /**
@@ -626,8 +676,7 @@ class Nightmare extends Helper {
    * Wrapper for synchronous [evaluate](https://github.com/segmentio/nightmare#evaluatefn-arg1-arg2)
    */
   async executeScript(...args) {
-    return this.browser.evaluate.apply(this.browser, args)
-      .catch(err => err); // Nightmare's first argument is error :(
+    return this.browser.evaluate.apply(this.browser, args).catch((err) => err) // Nightmare's first argument is error :(
   }
 
   /**
@@ -637,8 +686,7 @@ class Nightmare extends Helper {
    * Unlike NightmareJS implementation calling `done` will return its first argument.
    */
   async executeAsyncScript(...args) {
-    return this.browser.evaluate.apply(this.browser, args)
-      .catch(err => err); // Nightmare's first argument is error :(
+    return this.browser.evaluate.apply(this.browser, args).catch((err) => err) // Nightmare's first argument is error :(
   }
 
   /**
@@ -646,72 +694,68 @@ class Nightmare extends Helper {
    */
   async resizeWindow(width, height) {
     if (width === 'maximize') {
-      throw new Error('Nightmare doesn\'t support resizeWindow to maximum!');
+      throw new Error("Nightmare doesn't support resizeWindow to maximum!")
     }
-    return this.browser.viewport(width, height).wait(this.options.waitForAction);
+    return this.browser.viewport(width, height).wait(this.options.waitForAction)
   }
 
   /**
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const els = await findCheckable.call(this, field, context);
-    assertElementExists(els[0], field, 'Checkbox or radio');
-    return this.browser.evaluate(els => window.codeceptjs.checkEl(els[0]), els)
-      .wait(this.options.waitForAction);
+    const els = await findCheckable.call(this, field, context)
+    assertElementExists(els[0], field, 'Checkbox or radio')
+    return this.browser.evaluate((els) => window.codeceptjs.checkEl(els[0]), els).wait(this.options.waitForAction)
   }
 
   /**
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const els = await findCheckable.call(this, field, context);
-    assertElementExists(els[0], field, 'Checkbox or radio');
-    return this.browser.evaluate(els => window.codeceptjs.unCheckEl(els[0]), els)
-      .wait(this.options.waitForAction);
+    const els = await findCheckable.call(this, field, context)
+    assertElementExists(els[0], field, 'Checkbox or radio')
+    return this.browser.evaluate((els) => window.codeceptjs.unCheckEl(els[0]), els).wait(this.options.waitForAction)
   }
 
   /**
    * {{> fillField }}
    */
   async fillField(field, value) {
-    const el = await findField.call(this, field);
-    assertElementExists(el, field, 'Field');
-    return this.browser.enterText(el, value.toString(), true)
-      .wait(this.options.waitForAction);
+    const el = await findField.call(this, field)
+    assertElementExists(el, field, 'Field')
+    return this.browser.enterText(el, value.toString(), true).wait(this.options.waitForAction)
   }
 
   /**
    * {{> clearField }}
    */
   async clearField(field) {
-    return this.fillField(field, '');
+    return this.fillField(field, '')
   }
 
   /**
    * {{> appendField }}
    */
   async appendField(field, value) {
-    const el = await findField.call(this, field);
-    assertElementExists(el, field, 'Field');
-    return this.browser.enterText(el, value.toString(), false)
-      .wait(this.options.waitForAction);
+    const el = await findField.call(this, field)
+    assertElementExists(el, field, 'Field')
+    return this.browser.enterText(el, value.toString(), false).wait(this.options.waitForAction)
   }
 
   /**
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'assert', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'assert', field, _value)
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'negate', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'negate', field, _value)
   }
 
   /**
@@ -720,12 +764,12 @@ class Nightmare extends Helper {
    */
   async pressKey(key) {
     if (Array.isArray(key)) {
-      key = key.join('+'); // should work with accelerators...
+      key = key.join('+') // should work with accelerators...
     }
     if (Object.keys(specialKeys).indexOf(key) >= 0) {
-      key = specialKeys[key];
+      key = specialKeys[key]
     }
-    return this.browser.pressKey(key).wait(this.options.waitForAction);
+    return this.browser.pressKey(key).wait(this.options.waitForAction)
   }
 
   /**
@@ -739,21 +783,21 @@ class Nightmare extends Helper {
       }
    */
   async triggerMouseEvent(event) {
-    return this.browser.triggerMouseEvent(event).wait(this.options.waitForAction);
+    return this.browser.triggerMouseEvent(event).wait(this.options.waitForAction)
   }
 
   /**
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'assert', field);
+    return proceedIsChecked.call(this, 'assert', field)
   }
 
   /**
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'negate', field);
+    return proceedIsChecked.call(this, 'negate', field)
   }
 
   /**
@@ -762,167 +806,171 @@ class Nightmare extends Helper {
    * Doesn't work if the Chromium DevTools panel is open (as Chromium allows only one attachment to the debugger at a time. [See more](https://github.com/rosshinkley/nightmare-upload#important-note-about-setting-file-upload-inputs))
    */
   async attachFile(locator, pathToFile) {
-    const file = path.join(global.codecept_dir, pathToFile);
+    const file = path.join(global.codecept_dir, pathToFile)
 
-    locator = new Locator(locator, 'css');
+    locator = new Locator(locator, 'css')
     if (!locator.isCSS()) {
-      throw new Error('Only CSS locator allowed for attachFile in Nightmare helper');
+      throw new Error('Only CSS locator allowed for attachFile in Nightmare helper')
     }
 
     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`)
     }
-    return this.browser.upload(locator.value, file);
+    return this.browser.upload(locator.value, file)
   }
 
   /**
    * {{> grabTextFromAll }}
    */
   async grabTextFromAll(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    const texts = [];
-    const getText = el => window.codeceptjs.fetchElement(el).innerText;
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    const texts = []
+    const getText = (el) => window.codeceptjs.fetchElement(el).innerText
     for (const el of els) {
-      texts.push(await this.browser.evaluate(getText, el));
+      texts.push(await this.browser.evaluate(getText, el))
     }
-    return texts;
+    return texts
   }
 
   /**
    * {{> grabTextFrom }}
    */
   async grabTextFrom(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElement(locator.toStrict());
-    assertElementExists(els, locator);
-    const texts = await this.grabTextFromAll(locator);
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElement(locator.toStrict())
+    assertElementExists(els, locator)
+    const texts = await this.grabTextFromAll(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]
   }
 
   /**
    * {{> grabValueFromAll }}
    */
   async grabValueFromAll(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    const values = [];
-    const getValues = el => window.codeceptjs.fetchElement(el).value;
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    const values = []
+    const getValues = (el) => window.codeceptjs.fetchElement(el).value
     for (const el of els) {
-      values.push(await this.browser.evaluate(getValues, el));
+      values.push(await this.browser.evaluate(getValues, el))
     }
 
-    return values;
+    return values
   }
 
   /**
    * {{> grabValueFrom }}
    */
   async grabValueFrom(locator) {
-    const el = await findField.call(this, locator);
-    assertElementExists(el, locator, 'Field');
-    const values = await this.grabValueFromAll(locator);
+    const el = await findField.call(this, locator)
+    assertElementExists(el, locator, 'Field')
+    const values = await this.grabValueFromAll(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]
   }
 
   /**
    * {{> grabAttributeFromAll }}
    */
   async grabAttributeFromAll(locator, attr) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    const array = [];
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    const array = []
 
     for (let index = 0; index < els.length; index++) {
-      const el = els[index];
-      array.push(await this.browser.evaluate((el, attr) => window.codeceptjs.fetchElement(el).getAttribute(attr), el, attr));
+      const el = els[index]
+      array.push(
+        await this.browser.evaluate((el, attr) => window.codeceptjs.fetchElement(el).getAttribute(attr), el, attr),
+      )
     }
 
-    return array;
+    return array
   }
 
   /**
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFrom(locator, attr) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElement(locator.toStrict());
-    assertElementExists(els, locator);
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElement(locator.toStrict())
+    assertElementExists(els, locator)
 
-    const attrs = await this.grabAttributeFromAll(locator, attr);
+    const attrs = await this.grabAttributeFromAll(locator, attr)
     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]
   }
 
   /**
    * {{> grabHTMLFromAll }}
    */
   async grabHTMLFromAll(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    const array = [];
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    const array = []
 
     for (let index = 0; index < els.length; index++) {
-      const el = els[index];
-      array.push(await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).innerHTML, el));
+      const el = els[index]
+      array.push(await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).innerHTML, el))
     }
-    this.debugSection('GrabHTML', array);
+    this.debugSection('GrabHTML', array)
 
-    return array;
+    return array
   }
 
   /**
    * {{> grabHTMLFrom }}
    */
   async grabHTMLFrom(locator) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElement(locator.toStrict());
-    assertElementExists(els, locator);
-    const html = await this.grabHTMLFromAll(locator);
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElement(locator.toStrict())
+    assertElementExists(els, locator)
+    const html = await this.grabHTMLFromAll(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]
   }
 
   /**
    * {{> grabCssPropertyFrom }}
    */
   async grabCssPropertyFrom(locator, cssProperty) {
-    locator = new Locator(locator, 'css');
-    const els = await this.browser.findElements(locator.toStrict());
-    const array = [];
+    locator = new Locator(locator, 'css')
+    const els = await this.browser.findElements(locator.toStrict())
+    const array = []
 
     const getCssPropForElement = async (el, prop) => {
-      return (await this.browser.evaluate((el) => {
-        return window.getComputedStyle(window.codeceptjs.fetchElement(el));
-      }, el))[toCamelCase(prop)];
-    };
+      return (
+        await this.browser.evaluate((el) => {
+          return window.getComputedStyle(window.codeceptjs.fetchElement(el))
+        }, el)
+      )[toCamelCase(prop)]
+    }
 
     for (const el of els) {
-      assertElementExists(el, locator);
-      const cssValue = await getCssPropForElement(el, cssProperty);
-      array.push(cssValue);
+      assertElementExists(el, locator)
+      const cssValue = await getCssPropForElement(el, cssProperty)
+      array.push(cssValue)
     }
-    this.debugSection('HTML', array);
+    this.debugSection('HTML', array)
 
-    return array.length > 1 ? array : array[0];
+    return array.length > 1 ? array : array[0]
   }
 
   _injectClientScripts() {
-    return this.browser.inject('js', path.join(__dirname, 'clientscripts', 'nightmare.js'));
+    return this.browser.inject('js', path.join(__dirname, 'clientscripts', 'nightmare.js'))
   }
 
   /**
@@ -930,41 +978,41 @@ class Nightmare extends Helper {
    */
   async selectOption(select, option) {
     const fetchAndCheckOption = function (el, locator) {
-      el = window.codeceptjs.fetchElement(el);
-      const found = document.evaluate(locator, el, null, 5, null);
-      let current = null;
-      const items = [];
-      while (current = found.iterateNext()) {
-        items.push(current);
+      el = window.codeceptjs.fetchElement(el)
+      const found = document.evaluate(locator, el, null, 5, null)
+      let current = null
+      const items = []
+      while ((current = found.iterateNext())) {
+        items.push(current)
       }
       for (let i = 0; i < items.length; i++) {
-        current = items[i];
+        current = items[i]
         if (current instanceof HTMLOptionElement) {
-          current.selected = true;
-          if (!el.multiple) el.value = current.value;
+          current.selected = true
+          if (!el.multiple) el.value = current.value
         }
-        const event = document.createEvent('HTMLEvents');
-        event.initEvent('change', true, true);
-        el.dispatchEvent(event);
+        const event = document.createEvent('HTMLEvents')
+        event.initEvent('change', true, true)
+        el.dispatchEvent(event)
       }
-      return !!current;
-    };
+      return !!current
+    }
 
-    const el = await findField.call(this, select);
-    assertElementExists(el, select, 'Selectable field');
+    const el = await findField.call(this, select)
+    assertElementExists(el, select, 'Selectable field')
     if (!Array.isArray(option)) {
-      option = [option];
+      option = [option]
     }
 
     for (const key in option) {
-      const opt = xpathLocator.literal(option[key]);
-      const checked = await this.browser.evaluate(fetchAndCheckOption, el, Locator.select.byVisibleText(opt));
+      const opt = xpathLocator.literal(option[key])
+      const checked = await this.browser.evaluate(fetchAndCheckOption, el, Locator.select.byVisibleText(opt))
 
       if (!checked) {
-        await this.browser.evaluate(fetchAndCheckOption, el, Locator.select.byValue(opt));
+        await this.browser.evaluate(fetchAndCheckOption, el, Locator.select.byValue(opt))
       }
     }
-    return this.browser.wait(this.options.waitForAction);
+    return this.browser.wait(this.options.waitForAction)
   }
 
   /**
@@ -974,7 +1022,7 @@ class Nightmare extends Helper {
    * [See more](https://github.com/segmentio/nightmare/blob/master/Readme.md#cookiessetcookie)
    */
   async setCookie(cookie) {
-    return this.browser.cookies.set(cookie);
+    return this.browser.cookies.set(cookie)
   }
 
   /**
@@ -982,16 +1030,16 @@ class Nightmare extends Helper {
    *
    */
   async seeCookie(name) {
-    const res = await this.browser.cookies.get(name);
-    truth(`cookie ${name}`, 'to be set').assert(res);
+    const res = await this.browser.cookies.get(name)
+    truth(`cookie ${name}`, 'to be set').assert(res)
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    const res = await this.browser.cookies.get(name);
-    truth(`cookie ${name}`, 'to be set').negate(res);
+    const res = await this.browser.cookies.get(name)
+    truth(`cookie ${name}`, 'to be set').negate(res)
   }
 
   /**
@@ -1002,7 +1050,7 @@ class Nightmare extends Helper {
    * Multiple cookies can be received by passing query object `I.grabCookie({ secure: true});`. If you'd like get all cookies for all urls, use: `.grabCookie({ url: null }).`
    */
   async grabCookie(name) {
-    return this.browser.cookies.get(name);
+    return this.browser.cookies.get(name)
   }
 
   /**
@@ -1010,34 +1058,34 @@ class Nightmare extends Helper {
    */
   async clearCookie(cookie) {
     if (!cookie) {
-      return this.browser.cookies.clearAll();
+      return this.browser.cookies.clearAll()
     }
-    return this.browser.cookies.clear(cookie);
+    return this.browser.cookies.clear(cookie)
   }
 
   /**
    * {{> 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
       }
     }
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.browser.wait(fn, ...args);
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.browser.wait(fn, ...args)
   }
 
   /**
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise(((done) => {
-      setTimeout(done, sec * 1000);
-    }));
+    return new Promise((done) => {
+      setTimeout(done, sec * 1000)
+    })
   }
 
   /**
@@ -1045,113 +1093,136 @@ class Nightmare extends Helper {
    */
   async waitForText(text, sec, context = null) {
     if (!context) {
-      context = this.context;
+      context = this.context
     }
-    const locator = new Locator(context, 'css');
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.browser.wait((by, locator, text) => {
-      return window.codeceptjs.findElement(by, locator).innerText.indexOf(text) > -1;
-    }, locator.type, locator.value, text).catch((err) => {
-      if (err.message.indexOf('Cannot read property') > -1) {
-        throw new Error(`element (${JSON.stringify(context)}) is not in DOM. Unable to wait text.`);
-      } else if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
-        throw new Error(`there is no element(${JSON.stringify(context)}) with text "${text}" after ${sec} sec`);
-      } else throw err;
-    });
+    const locator = new Locator(context, 'css')
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.browser
+      .wait(
+        (by, locator, text) => {
+          return window.codeceptjs.findElement(by, locator).innerText.indexOf(text) > -1
+        },
+        locator.type,
+        locator.value,
+        text,
+      )
+      .catch((err) => {
+        if (err.message.indexOf('Cannot read property') > -1) {
+          throw new Error(`element (${JSON.stringify(context)}) is not in DOM. Unable to wait text.`)
+        } else if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
+          throw new Error(`there is no element(${JSON.stringify(context)}) with text "${text}" after ${sec} sec`)
+        } else throw err
+      })
   }
 
   /**
    * {{> waitForVisible }}
    */
   waitForVisible(locator, sec) {
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-
-    return this.browser.wait((by, locator) => {
-      const el = window.codeceptjs.findElement(by, locator);
-      if (!el) return false;
-      return el.offsetWidth > 0 && el.offsetHeight > 0;
-    }, locator.type, locator.value).catch((err) => {
-      if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
-        throw new Error(`element (${JSON.stringify(locator)}) still not visible on page after ${sec} sec`);
-      } else throw err;
-    });
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+
+    return this.browser
+      .wait(
+        (by, locator) => {
+          const el = window.codeceptjs.findElement(by, locator)
+          if (!el) return false
+          return el.offsetWidth > 0 && el.offsetHeight > 0
+        },
+        locator.type,
+        locator.value,
+      )
+      .catch((err) => {
+        if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
+          throw new Error(`element (${JSON.stringify(locator)}) still not visible on page after ${sec} sec`)
+        } else throw err
+      })
   }
 
   /**
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec = null) {
-    return this.waitForInvisible(locator, sec);
+    return this.waitForInvisible(locator, sec)
   }
 
   /**
    * {{> waitForInvisible }}
    */
   waitForInvisible(locator, sec) {
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-
-    return this.browser.wait((by, locator) => {
-      const el = window.codeceptjs.findElement(by, locator);
-      if (!el) return true;
-      return !(el.offsetWidth > 0 && el.offsetHeight > 0);
-    }, locator.type, locator.value).catch((err) => {
-      if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
-        throw new Error(`element (${JSON.stringify(locator)}) still visible after ${sec} sec`);
-      } else throw err;
-    });
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+
+    return this.browser
+      .wait(
+        (by, locator) => {
+          const el = window.codeceptjs.findElement(by, locator)
+          if (!el) return true
+          return !(el.offsetWidth > 0 && el.offsetHeight > 0)
+        },
+        locator.type,
+        locator.value,
+      )
+      .catch((err) => {
+        if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
+          throw new Error(`element (${JSON.stringify(locator)}) still visible after ${sec} sec`)
+        } else throw err
+      })
   }
 
   /**
    * {{> waitForElement }}
    */
   async waitForElement(locator, sec) {
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    return this.browser.wait((by, locator) => window.codeceptjs.findElement(by, locator) !== null, locator.type, locator.value).catch((err) => {
-      if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
-        throw new Error(`element (${JSON.stringify(locator)}) still not present on page after ${sec} sec`);
-      } else throw err;
-    });
+    return this.browser
+      .wait((by, locator) => window.codeceptjs.findElement(by, locator) !== null, locator.type, locator.value)
+      .catch((err) => {
+        if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
+          throw new Error(`element (${JSON.stringify(locator)}) still not present on page after ${sec} sec`)
+        } else throw err
+      })
   }
 
   async waitUntilExists(locator, sec) {
     console.log(`waitUntilExists deprecated:
     * use 'waitForElement' to wait for element to be attached
-    * use 'waitForDetached to wait for element to be removed'`);
-    return this.waitForDetached(locator, sec);
+    * use 'waitForDetached to wait for element to be removed'`)
+    return this.waitForDetached(locator, sec)
   }
 
   /**
    * {{> waitForDetached }}
    */
   async waitForDetached(locator, sec) {
-    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    sec = this.browser.options.waitForTimeout / 1000;
-    locator = new Locator(locator, 'css');
+    this.browser.options.waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    sec = this.browser.options.waitForTimeout / 1000
+    locator = new Locator(locator, 'css')
 
-    return this.browser.wait((by, locator) => window.codeceptjs.findElement(by, locator) === null, locator.type, locator.value).catch((err) => {
-      if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
-        throw new Error(`element (${JSON.stringify(locator)}) still on page after ${sec} sec`);
-      } else throw err;
-    });
+    return this.browser
+      .wait((by, locator) => window.codeceptjs.findElement(by, locator) === null, locator.type, locator.value)
+      .catch((err) => {
+        if (err.message && err.message.indexOf('.wait() timed out after') > -1) {
+          throw new Error(`element (${JSON.stringify(locator)}) still on page after ${sec} sec`)
+        } else throw err
+      })
   }
 
   /**
    * {{> refreshPage }}
    */
   async refreshPage() {
-    return this.browser.refresh();
+    return this.browser.refresh()
   }
 
   /**
    * Reload the page
    */
   refresh() {
-    console.log('Deprecated in favor of refreshPage');
-    return this.browser.refresh();
+    console.log('Deprecated in favor of refreshPage')
+    return this.browser.refresh()
   }
 
   /**
@@ -1159,70 +1230,74 @@ class Nightmare extends Helper {
    *
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
-    const rect = await this.grabElementBoundingRect(locator);
+    const rect = await this.grabElementBoundingRect(locator)
 
     const button_clip = {
       x: Math.floor(rect.x),
       y: Math.floor(rect.y),
       width: Math.floor(rect.width),
       height: Math.floor(rect.height),
-    };
+    }
 
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
     // take the screenshot
-    await this.browser.screenshot(outputFile, button_clip);
+    await this.browser.screenshot(outputFile, button_clip)
   }
 
   /**
    * {{> grabElementBoundingRect }}
    */
   async grabElementBoundingRect(locator, prop) {
-    locator = new Locator(locator, 'css');
+    locator = new Locator(locator, 'css')
 
-    const rect = await this.browser.evaluate(async (by, locator) => {
-      // store the button in a variable
+    const rect = await this.browser.evaluate(
+      async (by, locator) => {
+        // store the button in a variable
 
-      const build_cluster_btn = await window.codeceptjs.findElement(by, locator);
+        const build_cluster_btn = await window.codeceptjs.findElement(by, locator)
 
-      // use the getClientRects() function on the button to determine
-      // the size and location
-      const rect = build_cluster_btn.getBoundingClientRect();
+        // use the getClientRects() function on the button to determine
+        // the size and location
+        const rect = build_cluster_btn.getBoundingClientRect()
 
-      // convert the rectangle to a clip object and return it
-      return {
-        x: rect.left,
-        y: rect.top,
-        width: rect.width,
-        height: rect.height,
-      };
-    }, locator.type, locator.value);
+        // convert the rectangle to a clip object and return it
+        return {
+          x: rect.left,
+          y: rect.top,
+          width: rect.width,
+          height: rect.height,
+        }
+      },
+      locator.type,
+      locator.value,
+    )
 
-    if (prop) return rect[prop];
-    return rect;
+    if (prop) return rect[prop]
+    return rect
   }
 
   /**
    * {{> saveScreenshot }}
    */
   async saveScreenshot(fileName, fullPage = this.options.fullPageScreenshots) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
-    this.debug(`Screenshot is saving to ${outputFile}`);
+    this.debug(`Screenshot is saving to ${outputFile}`)
 
     if (!fullPage) {
-      return this.browser.screenshot(outputFile);
+      return this.browser.screenshot(outputFile)
     }
     const { height, width } = await this.browser.evaluate(() => {
-      return { height: document.body.scrollHeight, width: document.body.scrollWidth };
-    });
-    await this.browser.viewport(width, height);
-    return this.browser.screenshot(outputFile);
+      return { height: document.body.scrollHeight, width: document.body.scrollWidth }
+    })
+    await this.browser.viewport(width, height)
+    return this.browser.screenshot(outputFile)
   }
 
   async _failed() {
-    if (withinStatus !== false) await this._withinEnd();
+    if (withinStatus !== false) await this._withinEnd()
   }
 
   /**
@@ -1230,28 +1305,40 @@ class Nightmare 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) {
-      locator = new Locator(locator, 'css');
-      return this.browser.evaluate((by, locator, offsetX, offsetY) => {
-        const el = window.codeceptjs.findElement(by, locator);
-        if (!el) throw new Error(`Element not found ${by}: ${locator}`);
-        const rect = el.getBoundingClientRect();
-        window.scrollTo(rect.left + offsetX, rect.top + offsetY);
-      }, locator.type, locator.value, offsetX, offsetY);
+      locator = new Locator(locator, 'css')
+      return this.browser.evaluate(
+        (by, locator, offsetX, offsetY) => {
+          const el = window.codeceptjs.findElement(by, locator)
+          if (!el) throw new Error(`Element not found ${by}: ${locator}`)
+          const rect = el.getBoundingClientRect()
+          window.scrollTo(rect.left + offsetX, rect.top + offsetY)
+        },
+        locator.type,
+        locator.value,
+        offsetX,
+        offsetY,
+      )
     }
     // eslint-disable-next-line prefer-arrow-callback
-    return this.executeScript(function (x, y) { return window.scrollTo(x, y); }, offsetX, offsetY);
+    return this.executeScript(
+      function (x, y) {
+        return window.scrollTo(x, y)
+      },
+      offsetX,
+      offsetY,
+    )
   }
 
   /**
    * {{> scrollPageToTop }}
    */
   async scrollPageToTop() {
-    return this.executeScript(() => window.scrollTo(0, 0));
+    return this.executeScript(() => window.scrollTo(0, 0))
   }
 
   /**
@@ -1260,16 +1347,13 @@ class Nightmare extends Helper {
   async scrollPageToBottom() {
     /* eslint-disable prefer-arrow-callback, comma-dangle */
     return this.executeScript(function () {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight
-      ));
-    });
+      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 */
   }
 
@@ -1281,135 +1365,143 @@ class Nightmare extends Helper {
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
+        y: window.pageYOffset,
+      }
     }
     /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
+    return this.executeScript(getScrollPosition)
   }
 }
 
-module.exports = Nightmare;
+module.exports = Nightmare
 
 async function proceedSee(assertType, text, context) {
-  let description;
-  let locator;
+  let description
+  let locator
   if (!context) {
     if (this.context === this.options.rootElement) {
-      locator = new Locator(this.context, 'css');
-      description = 'web application';
+      locator = new Locator(this.context, 'css')
+      description = 'web application'
     } else {
-      description = `current context ${this.context}`;
-      locator = new Locator({ xpath: './/*' });
+      description = `current context ${this.context}`
+      locator = new Locator({ xpath: './/*' })
     }
   } else {
-    locator = new Locator(context, 'css');
-    description = `element ${locator.toString()}`;
-  }
-
-  const texts = await this.browser.evaluate((by, locator) => {
-    return window.codeceptjs.findElements(by, locator).map(el => el.innerText);
-  }, locator.type, locator.value);
-  const allText = texts.join(' | ');
-  return stringIncludes(description)[assertType](text, allText);
+    locator = new Locator(context, 'css')
+    description = `element ${locator.toString()}`
+  }
+
+  const texts = await this.browser.evaluate(
+    (by, locator) => {
+      return window.codeceptjs.findElements(by, locator).map((el) => el.innerText)
+    },
+    locator.type,
+    locator.value,
+  )
+  const allText = texts.join(' | ')
+  return stringIncludes(description)[assertType](text, allText)
 }
 
 async function proceedSeeInField(assertType, field, value) {
-  const el = await findField.call(this, field);
-  assertElementExists(el, field, 'Field');
-  const tag = await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).tagName, el);
-  const fieldVal = await this.browser.evaluate(el => window.codeceptjs.fetchElement(el).value, el);
+  const el = await findField.call(this, field)
+  assertElementExists(el, field, 'Field')
+  const tag = await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).tagName, el)
+  const fieldVal = await this.browser.evaluate((el) => window.codeceptjs.fetchElement(el).value, el)
   if (tag === 'select') {
     // locate option by values and check them
-    const text = await this.browser.evaluate((el, val) => {
-      return el.querySelector(`option[value="${val}"]`).innerText;
-    }, el, xpathLocator.literal(fieldVal));
-    return equals(`select option by ${field}`)[assertType](value, text);
+    const text = await this.browser.evaluate(
+      (el, val) => {
+        return el.querySelector(`option[value="${val}"]`).innerText
+      },
+      el,
+      xpathLocator.literal(fieldVal),
+    )
+    return equals(`select option by ${field}`)[assertType](value, text)
   }
-  return stringIncludes(`field by ${field}`)[assertType](value, fieldVal);
+  return stringIncludes(`field by ${field}`)[assertType](value, fieldVal)
 }
 
 async function proceedIsChecked(assertType, option) {
-  const els = await findCheckable.call(this, option);
-  assertElementExists(els, option, 'Checkable');
+  const els = await findCheckable.call(this, option)
+  assertElementExists(els, option, 'Checkable')
   const selected = await this.browser.evaluate((els) => {
-    return els.map(el => window.codeceptjs.fetchElement(el).checked).reduce((prev, cur) => prev || cur);
-  }, els);
-  return truth(`checkable ${option}`, 'to be checked')[assertType](selected);
+    return els.map((el) => window.codeceptjs.fetchElement(el).checked).reduce((prev, cur) => prev || cur)
+  }, els)
+  return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
 async function findCheckable(locator, context) {
-  let contextEl = null;
+  let contextEl = null
   if (context) {
-    contextEl = await this.browser.findElement((new Locator(context, 'css')).toStrict());
+    contextEl = await this.browser.findElement(new Locator(context, 'css').toStrict())
   }
 
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this.browser.findElements(matchedLocator.toStrict(), contextEl);
+    return this.browser.findElements(matchedLocator.toStrict(), contextEl)
   }
 
-  const literal = xpathLocator.literal(locator);
-  let els = await this.browser.findElements({ xpath: Locator.checkable.byText(literal) }, contextEl);
+  const literal = xpathLocator.literal(locator)
+  let els = await this.browser.findElements({ xpath: Locator.checkable.byText(literal) }, contextEl)
   if (els.length) {
-    return els;
+    return els
   }
-  els = await this.browser.findElements({ xpath: Locator.checkable.byName(literal) }, contextEl);
+  els = await this.browser.findElements({ xpath: Locator.checkable.byName(literal) }, contextEl)
   if (els.length) {
-    return els;
+    return els
   }
-  return this.browser.findElements({ css: locator }, contextEl);
+  return this.browser.findElements({ css: locator }, contextEl)
 }
 
 async function findClickable(locator, context) {
-  let contextEl = null;
+  let contextEl = null
   if (context) {
-    contextEl = await this.browser.findElement((new Locator(context, 'css')).toStrict());
+    contextEl = await this.browser.findElement(new Locator(context, 'css').toStrict())
   }
 
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this.browser.findElement(matchedLocator.toStrict(), contextEl);
+    return this.browser.findElement(matchedLocator.toStrict(), contextEl)
   }
 
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await this.browser.findElements({ xpath: Locator.clickable.narrow(literal) }, contextEl);
+  let els = await this.browser.findElements({ xpath: Locator.clickable.narrow(literal) }, contextEl)
   if (els.length) {
-    return els[0];
+    return els[0]
   }
 
-  els = await this.browser.findElements({ xpath: Locator.clickable.wide(literal) }, contextEl);
+  els = await this.browser.findElements({ xpath: Locator.clickable.wide(literal) }, contextEl)
   if (els.length) {
-    return els[0];
+    return els[0]
   }
 
-  return this.browser.findElement({ css: locator }, contextEl);
+  return this.browser.findElement({ css: locator }, contextEl)
 }
 
 async function findField(locator) {
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this.browser.findElements(matchedLocator.toStrict());
+    return this.browser.findElements(matchedLocator.toStrict())
   }
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await this.browser.findElements({ xpath: Locator.field.labelEquals(literal) });
+  let els = await this.browser.findElements({ xpath: Locator.field.labelEquals(literal) })
   if (els.length) {
-    return els[0];
+    return els[0]
   }
 
-  els = await this.browser.findElements({ xpath: Locator.field.labelContains(literal) });
+  els = await this.browser.findElements({ xpath: Locator.field.labelContains(literal) })
   if (els.length) {
-    return els[0];
+    return els[0]
   }
-  els = await this.browser.findElements({ xpath: Locator.field.byName(literal) });
+  els = await this.browser.findElements({ xpath: Locator.field.byName(literal) })
   if (els.length) {
-    return els[0];
+    return els[0]
   }
-  return this.browser.findElement({ css: locator });
+  return this.browser.findElement({ css: locator })
 }
 
 function assertElementExists(el, locator, prefix, suffix) {
-  if (el === null) throw new ElementNotFound(locator, prefix, suffix);
+  if (el === null) throw new ElementNotFound(locator, prefix, suffix)
 }
diff --git a/lib/helper/Playwright.js b/lib/helper/Playwright.js
index d03e3af2b..0921fb1ad 100644
--- a/lib/helper/Playwright.js
+++ b/lib/helper/Playwright.js
@@ -1,17 +1,17 @@
-const path = require('path');
-const fs = require('fs');
-
-const Helper = require('@codeceptjs/helper');
-const { v4: uuidv4 } = require('uuid');
-const assert = require('assert');
-const promiseRetry = require('promise-retry');
-const Locator = require('../locator');
-const recorder = require('../recorder');
-const stringIncludes = require('../assert/include').includes;
-const { urlEquals } = require('../assert/equal');
-const { equals } = require('../assert/equal');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
+const path = require('path')
+const fs = require('fs')
+
+const Helper = require('@codeceptjs/helper')
+const { v4: uuidv4 } = require('uuid')
+const assert = require('assert')
+const promiseRetry = require('promise-retry')
+const Locator = require('../locator')
+const recorder = require('../recorder')
+const stringIncludes = require('../assert/include').includes
+const { urlEquals } = require('../assert/equal')
+const { equals } = require('../assert/equal')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
 const {
   xpathLocator,
   ucfirst,
@@ -24,37 +24,44 @@ const {
   clearString,
   requireWithFallback,
   normalizeSpacesInString,
-} = require('../utils');
-const {
-  isColorProperty,
-  convertColorToRGBA,
-} = require('../colorUtils');
-const ElementNotFound = require('./errors/ElementNotFound');
-const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused');
-const Popup = require('./extras/Popup');
-const Console = require('./extras/Console');
-const { findReact, findVue, findByPlaywrightLocator } = require('./extras/PlaywrightReactVueLocator');
-
-let playwright;
-let perfTiming;
-let defaultSelectorEnginesInitialized = false;
-
-const popupStore = new Popup();
-const consoleLogStore = new Console();
-const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron'];
+} = require('../utils')
+const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
+const ElementNotFound = require('./errors/ElementNotFound')
+const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused')
+const Popup = require('./extras/Popup')
+const Console = require('./extras/Console')
+const { findReact, findVue, findByPlaywrightLocator } = require('./extras/PlaywrightReactVueLocator')
+
+let playwright
+let perfTiming
+let defaultSelectorEnginesInitialized = false
+
+const popupStore = new Popup()
+const consoleLogStore = new Console()
+const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron']
 
 const {
-  setRestartStrategy, restartsSession, restartsContext, restartsBrowser,
-} = require('./extras/PlaywrightRestartOpts');
-const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine');
+  setRestartStrategy,
+  restartsSession,
+  restartsContext,
+  restartsBrowser,
+} = require('./extras/PlaywrightRestartOpts')
+const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine')
 const {
-  seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError,
-} = require('./errors/ElementAssertion');
+  seeElementError,
+  dontSeeElementError,
+  dontSeeElementInDOMError,
+  seeElementInDOMError,
+} = require('./errors/ElementAssertion')
 const {
-  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
-} = require('./network/actions');
+  dontSeeTraffic,
+  seeTraffic,
+  grabRecordedNetworkTraffics,
+  stopRecordingTraffic,
+  flushNetworkTraffics,
+} = require('./network/actions')
 
-const pathSeparator = path.sep;
+const pathSeparator = path.sep
 
 /**
  * ## Configuration
@@ -103,7 +110,7 @@ const pathSeparator = path.sep;
  * @prop {object} [recordHar] - record HAR and will be saved to `output/har`. See more of [HAR options](https://playwright.dev/docs/api/class-browser#browser-new-context-option-record-har).
  * @prop {string} [testIdAttribute=data-testid] - locate elements based on the testIdAttribute. See more of [locate by test id](https://playwright.dev/docs/locators#locate-by-test-id).
  */
-const config = {};
+const config = {}
 
 /**
  * Uses [Playwright](https://github.com/microsoft/playwright) library to run tests inside:
@@ -325,34 +332,34 @@ const config = {};
  */
 class Playwright extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
-    playwright = requireWithFallback('playwright', 'playwright-core');
+    playwright = requireWithFallback('playwright', 'playwright-core')
 
     // set defaults
-    this.isRemoteBrowser = false;
-    this.isRunning = false;
-    this.isAuthenticated = false;
-    this.sessionPages = {};
-    this.activeSessionName = '';
-    this.isElectron = false;
-    this.isCDPConnection = false;
-    this.electronSessions = [];
-    this.storageState = null;
+    this.isRemoteBrowser = false
+    this.isRunning = false
+    this.isAuthenticated = false
+    this.sessionPages = {}
+    this.activeSessionName = ''
+    this.isElectron = false
+    this.isCDPConnection = false
+    this.electronSessions = []
+    this.storageState = null
 
     // for network stuff
-    this.requests = [];
-    this.recording = false;
-    this.recordedAtLeastOnce = false;
+    this.requests = []
+    this.recording = false
+    this.recordedAtLeastOnce = false
 
     // for websocket messages
-    this.webSocketMessages = [];
-    this.recordingWebSocketMessages = false;
-    this.recordedWebSocketMessagesAtLeastOnce = false;
-    this.cdpSession = null;
+    this.webSocketMessages = []
+    this.recordingWebSocketMessages = false
+    this.recordedWebSocketMessagesAtLeastOnce = false
+    this.cdpSession = null
 
     // override defaults with config
-    this._setConfig(config);
+    this._setConfig(config)
   }
 
   _validateConfig(config) {
@@ -379,61 +386,65 @@ class Playwright extends Helper {
       use: { actionTimeout: 0 },
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
-    };
+    }
 
-    process.env.testIdAttribute = 'data-testid';
-    config = Object.assign(defaults, config);
+    process.env.testIdAttribute = 'data-testid'
+    config = Object.assign(defaults, config)
 
     if (availableBrowsers.indexOf(config.browser) < 0) {
-      throw new Error(`Invalid config. Can't use browser "${config.browser}". Accepted values: ${availableBrowsers.join(', ')}`);
+      throw new Error(
+        `Invalid config. Can't use browser "${config.browser}". Accepted values: ${availableBrowsers.join(', ')}`,
+      )
     }
 
-    return config;
+    return config
   }
 
   _getOptionsForBrowser(config) {
     if (config[config.browser]) {
       if (config[config.browser].browserWSEndpoint && config[config.browser].browserWSEndpoint.wsEndpoint) {
-        config[config.browser].browserWSEndpoint = config[config.browser].browserWSEndpoint.wsEndpoint;
+        config[config.browser].browserWSEndpoint = config[config.browser].browserWSEndpoint.wsEndpoint
       }
       return {
         ...config[config.browser],
         wsEndpoint: config[config.browser].browserWSEndpoint,
-      };
+      }
     }
-    return {};
+    return {}
   }
 
   _setConfig(config) {
-    this.options = this._validateConfig(config);
-    setRestartStrategy(this.options);
+    this.options = this._validateConfig(config)
+    setRestartStrategy(this.options)
     this.playwrightOptions = {
       headless: !this.options.show,
       ...this._getOptionsForBrowser(config),
-    };
+    }
 
     if (this.options.channel && this.options.browser === 'chromium') {
-      this.playwrightOptions.channel = this.options.channel;
+      this.playwrightOptions.channel = this.options.channel
     }
 
     if (this.options.video) {
       // set the video resolution with window size
-      let size = parseWindowSize(this.options.windowSize);
+      let size = parseWindowSize(this.options.windowSize)
 
       // if the video resolution is passed, set the record resoultion with that resolution
       if (this.options.recordVideo && this.options.recordVideo.size) {
-        size = parseWindowSize(this.options.recordVideo.size);
+        size = parseWindowSize(this.options.recordVideo.size)
       }
-      this.options.recordVideo = { size };
+      this.options.recordVideo = { size }
     }
     if (this.options.recordVideo && !this.options.recordVideo.dir) {
-      this.options.recordVideo.dir = `${global.output_dir}/videos/`;
+      this.options.recordVideo.dir = `${global.output_dir}/videos/`
     }
-    this.isRemoteBrowser = !!this.playwrightOptions.browserWSEndpoint;
-    this.isElectron = this.options.browser === 'electron';
-    this.userDataDir = this.playwrightOptions.userDataDir ? `${this.playwrightOptions.userDataDir}_${Date.now().toString()}` : undefined;
-    this.isCDPConnection = this.playwrightOptions.cdpConnection;
-    popupStore.defaultAction = this.options.defaultPopupAction;
+    this.isRemoteBrowser = !!this.playwrightOptions.browserWSEndpoint
+    this.isElectron = this.options.browser === 'electron'
+    this.userDataDir = this.playwrightOptions.userDataDir
+      ? `${this.playwrightOptions.userDataDir}_${Date.now().toString()}`
+      : undefined
+    this.isCDPConnection = this.playwrightOptions.cdpConnection
+    popupStore.defaultAction = this.options.defaultPopupAction
   }
 
   static _config() {
@@ -456,216 +467,222 @@ class Playwright extends Helper {
         type: 'confirm',
         when: (answers) => answers.Playwright_browser !== 'electron',
       },
-    ];
+    ]
   }
 
   static _checkRequirements() {
     try {
-      requireWithFallback('playwright', 'playwright-core');
+      requireWithFallback('playwright', 'playwright-core')
     } catch (e) {
-      return ['playwright@^1.18'];
+      return ['playwright@^1.18']
     }
   }
 
   async _init() {
     // register an internal selector engine for reading value property of elements in a selector
-    if (defaultSelectorEnginesInitialized) return;
-    defaultSelectorEnginesInitialized = true;
+    if (defaultSelectorEnginesInitialized) return
+    defaultSelectorEnginesInitialized = true
     try {
-      await playwright.selectors.register('__value', createValueEngine);
-      await playwright.selectors.register('__disabled', createDisabledEngine);
-      if (process.env.testIdAttribute) await playwright.selectors.setTestIdAttribute(process.env.testIdAttribute);
+      await playwright.selectors.register('__value', createValueEngine)
+      await playwright.selectors.register('__disabled', createDisabledEngine)
+      if (process.env.testIdAttribute) await playwright.selectors.setTestIdAttribute(process.env.testIdAttribute)
     } catch (e) {
-      console.warn(e);
+      console.warn(e)
     }
   }
 
   _beforeSuite() {
     if ((restartsSession() || restartsContext()) && !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()
     }
   }
 
   async _before(test) {
-    this.currentRunningTest = test;
+    this.currentRunningTest = test
     recorder.retry({
       retries: process.env.FAILED_STEP_RETRIES || 3,
-      when: err => {
-        if (!err || typeof (err.message) !== 'string') {
-          return false;
+      when: (err) => {
+        if (!err || typeof err.message !== 'string') {
+          return false
         }
         // ignore context errors
-        return err.message.includes('context');
+        return err.message.includes('context')
       },
-    });
+    })
 
-    if (restartsBrowser() && !this.options.manualStart) await this._startBrowser();
-    if (!this.isRunning && !this.options.manualStart) await this._startBrowser();
+    if (restartsBrowser() && !this.options.manualStart) await this._startBrowser()
+    if (!this.isRunning && !this.options.manualStart) await this._startBrowser()
 
-    this.isAuthenticated = false;
+    this.isAuthenticated = false
     if (this.isElectron) {
-      this.browserContext = this.browser.context();
+      this.browserContext = this.browser.context()
     } else if (this.playwrightOptions.userDataDir) {
-      this.browserContext = this.browser;
+      this.browserContext = this.browser
     } else {
       const contextOptions = {
         ignoreHTTPSErrors: this.options.ignoreHTTPSErrors,
         acceptDownloads: true,
         ...this.options.emulate,
-      };
+      }
       if (this.options.basicAuth) {
-        contextOptions.httpCredentials = this.options.basicAuth;
-        this.isAuthenticated = true;
+        contextOptions.httpCredentials = this.options.basicAuth
+        this.isAuthenticated = true
       }
-      if (this.options.bypassCSP) contextOptions.bypassCSP = this.options.bypassCSP;
-      if (this.options.recordVideo) contextOptions.recordVideo = this.options.recordVideo;
+      if (this.options.bypassCSP) contextOptions.bypassCSP = this.options.bypassCSP
+      if (this.options.recordVideo) contextOptions.recordVideo = this.options.recordVideo
       if (this.options.recordHar) {
-        const harExt = this.options.recordHar.content && this.options.recordHar.content === 'attach' ? 'zip' : 'har';
-        const fileName = `${`${global.output_dir}${path.sep}har${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.${harExt}`;
-        const dir = path.dirname(fileName);
-        if (!fileExists(dir)) fs.mkdirSync(dir);
-        this.options.recordHar.path = fileName;
-        this.currentRunningTest.artifacts.har = fileName;
-        contextOptions.recordHar = this.options.recordHar;
+        const harExt = this.options.recordHar.content && this.options.recordHar.content === 'attach' ? 'zip' : 'har'
+        const fileName = `${`${global.output_dir}${path.sep}har${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.${harExt}`
+        const dir = path.dirname(fileName)
+        if (!fileExists(dir)) fs.mkdirSync(dir)
+        this.options.recordHar.path = fileName
+        this.currentRunningTest.artifacts.har = fileName
+        contextOptions.recordHar = this.options.recordHar
       }
-      if (this.storageState) contextOptions.storageState = this.storageState;
-      if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent;
-      if (this.options.locale) contextOptions.locale = this.options.locale;
-      if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme;
-      this.contextOptions = contextOptions;
+      if (this.storageState) contextOptions.storageState = this.storageState
+      if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent
+      if (this.options.locale) contextOptions.locale = this.options.locale
+      if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme
+      this.contextOptions = contextOptions
       if (!this.browserContext || !restartsSession()) {
-        this.browserContext = await this.browser.newContext(this.contextOptions); // Adding the HTTPSError ignore in the context so that we can ignore those errors
+        this.browserContext = await this.browser.newContext(this.contextOptions) // Adding the HTTPSError ignore in the context so that we can ignore those errors
       }
     }
 
-    let mainPage;
+    let mainPage
     if (this.isElectron) {
-      mainPage = await this.browser.firstWindow();
+      mainPage = await this.browser.firstWindow()
     } else {
       try {
-        const existingPages = await this.browserContext.pages();
-        mainPage = existingPages[0] || await this.browserContext.newPage();
+        const existingPages = await this.browserContext.pages()
+        mainPage = existingPages[0] || (await this.browserContext.newPage())
       } catch (e) {
         if (this.playwrightOptions.userDataDir) {
-          this.browser = await playwright[this.options.browser].launchPersistentContext(this.userDataDir, this.playwrightOptions);
-          this.browserContext = this.browser;
-          const existingPages = await this.browserContext.pages();
-          mainPage = existingPages[0];
+          this.browser = await playwright[this.options.browser].launchPersistentContext(
+            this.userDataDir,
+            this.playwrightOptions,
+          )
+          this.browserContext = this.browser
+          const existingPages = await this.browserContext.pages()
+          mainPage = existingPages[0]
         }
       }
     }
-    await targetCreatedHandler.call(this, mainPage);
+    await targetCreatedHandler.call(this, mainPage)
 
-    await this._setPage(mainPage);
+    await this._setPage(mainPage)
 
-    if (this.options.trace) await this.browserContext.tracing.start({ screenshots: true, snapshots: true });
+    if (this.options.trace) await this.browserContext.tracing.start({ screenshots: true, snapshots: true })
 
-    return this.browser;
+    return this.browser
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
 
     if (this.isElectron) {
-      this.browser.close();
-      this.electronSessions.forEach(session => session.close());
-      return;
+      this.browser.close()
+      this.electronSessions.forEach((session) => session.close())
+      return
     }
 
     if (restartsSession()) {
-      return refreshContextSession.bind(this)();
+      return refreshContextSession.bind(this)()
     }
 
     if (restartsBrowser()) {
-      this.isRunning = false;
-      return this._stopBrowser();
+      this.isRunning = false
+      return this._stopBrowser()
     }
 
     // close other sessions
     try {
       if ((await this.browser)._type === 'Browser') {
-        const contexts = await this.browser.contexts();
-        const currentContext = contexts[0];
+        const contexts = await this.browser.contexts()
+        const currentContext = contexts[0]
         if (currentContext && (this.options.keepCookies || this.options.keepBrowserState)) {
-          this.storageState = await currentContext.storageState();
+          this.storageState = await currentContext.storageState()
         }
 
-        await Promise.all(contexts.map(c => c.close()));
+        await Promise.all(contexts.map((c) => c.close()))
       }
     } catch (e) {
-      console.log(e);
+      console.log(e)
     }
 
     // await this.closeOtherTabs();
-    return this.browser;
+    return this.browser
   }
 
   _afterSuite() {}
 
   async _finishTest() {
-    if ((restartsSession() || restartsContext()) && this.isRunning) return this._stopBrowser();
+    if ((restartsSession() || restartsContext()) && this.isRunning) return this._stopBrowser()
   }
 
   _session() {
-    const defaultContext = this.browserContext;
+    const defaultContext = this.browserContext
     return {
       start: async (sessionName = '', config) => {
-        this.debugSection('New Context', config ? JSON.stringify(config) : 'opened');
-        this.activeSessionName = sessionName;
+        this.debugSection('New Context', config ? JSON.stringify(config) : 'opened')
+        this.activeSessionName = sessionName
 
-        let browserContext;
-        let page;
+        let browserContext
+        let page
         if (this.isElectron) {
-          const browser = await playwright._electron.launch(this.playwrightOptions);
-          this.electronSessions.push(browser);
-          browserContext = browser.context();
-          page = await browser.firstWindow();
+          const browser = await playwright._electron.launch(this.playwrightOptions)
+          this.electronSessions.push(browser)
+          browserContext = browser.context()
+          page = await browser.firstWindow()
         } else {
           try {
-            browserContext = await this.browser.newContext(Object.assign(this.contextOptions, config));
-            page = await browserContext.newPage();
+            browserContext = await this.browser.newContext(Object.assign(this.contextOptions, config))
+            page = await browserContext.newPage()
           } catch (e) {
             if (this.playwrightOptions.userDataDir) {
-              browserContext = await playwright[this.options.browser].launchPersistentContext(`${this.userDataDir}_${this.activeSessionName}`, this.playwrightOptions);
-              this.browser = browserContext;
-              page = await browserContext.pages()[0];
+              browserContext = await playwright[this.options.browser].launchPersistentContext(
+                `${this.userDataDir}_${this.activeSessionName}`,
+                this.playwrightOptions,
+              )
+              this.browser = browserContext
+              page = await browserContext.pages()[0]
             }
           }
         }
 
-        if (this.options.trace) await browserContext.tracing.start({ screenshots: true, snapshots: true });
-        await targetCreatedHandler.call(this, page);
-        await this._setPage(page);
+        if (this.options.trace) await browserContext.tracing.start({ screenshots: true, snapshots: true })
+        await targetCreatedHandler.call(this, page)
+        await this._setPage(page)
         // Create a new page inside context.
-        return browserContext;
+        return browserContext
       },
       stop: async () => {
         // is closed by _after
       },
       loadVars: async (context) => {
         if (context) {
-          this.browserContext = context;
-          const existingPages = await context.pages();
-          this.sessionPages[this.activeSessionName] = existingPages[0];
-          return this._setPage(this.sessionPages[this.activeSessionName]);
+          this.browserContext = context
+          const existingPages = await context.pages()
+          this.sessionPages[this.activeSessionName] = existingPages[0]
+          return this._setPage(this.sessionPages[this.activeSessionName])
         }
       },
       restoreVars: async (session) => {
-        this.withinLocator = null;
-        this.browserContext = defaultContext;
+        this.withinLocator = null
+        this.browserContext = defaultContext
 
         if (!session) {
-          this.activeSessionName = '';
+          this.activeSessionName = ''
         } else {
-          this.activeSessionName = session;
+          this.activeSessionName = session
         }
-        const existingPages = await this.browserContext.pages();
-        await this._setPage(existingPages[0]);
+        const existingPages = await this.browserContext.pages()
+        await this._setPage(existingPages[0])
 
-        return this._waitForAction();
+        return this._waitForAction()
       },
-    };
+    }
   }
 
   /**
@@ -686,7 +703,7 @@ class Playwright extends Helper {
    * @param {function} fn async function that executed with Playwright helper as arguments
    */
   usePlaywrightTo(description, fn) {
-    return this._useTo(...arguments);
+    return this._useTo(...arguments)
   }
 
   /**
@@ -700,7 +717,7 @@ class Playwright extends Helper {
    * ```
    */
   amAcceptingPopups() {
-    popupStore.actionType = 'accept';
+    popupStore.actionType = 'accept'
   }
 
   /**
@@ -709,7 +726,7 @@ class Playwright extends Helper {
    * libraries](http://jster.net/category/windows-modals-popups).
    */
   acceptPopup() {
-    popupStore.assertPopupActionType('accept');
+    popupStore.assertPopupActionType('accept')
   }
 
   /**
@@ -723,23 +740,23 @@ class Playwright extends Helper {
    * ```
    */
   amCancellingPopups() {
-    popupStore.actionType = 'cancel';
+    popupStore.actionType = 'cancel'
   }
 
   /**
    * Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
    */
   cancelPopup() {
-    popupStore.assertPopupActionType('cancel');
+    popupStore.assertPopupActionType('cancel')
   }
 
   /**
    * {{> seeInPopup }}
    */
   async seeInPopup(text) {
-    popupStore.assertPopupVisible();
-    const popupText = await popupStore.popup.message();
-    stringIncludes('text in popup').assert(text, popupText);
+    popupStore.assertPopupVisible()
+    const popupText = await popupStore.popup.message()
+    stringIncludes('text in popup').assert(text, popupText)
   }
 
   /**
@@ -747,21 +764,21 @@ class Playwright extends Helper {
    * @param {object} page page to set
    */
   async _setPage(page) {
-    page = await page;
-    this._addPopupListener(page);
-    this.page = page;
-    if (!page) return;
-    this.browserContext.setDefaultTimeout(0);
-    page.setDefaultNavigationTimeout(this.options.getPageTimeout);
-    page.setDefaultTimeout(this.options.timeout);
+    page = await page
+    this._addPopupListener(page)
+    this.page = page
+    if (!page) return
+    this.browserContext.setDefaultTimeout(0)
+    page.setDefaultNavigationTimeout(this.options.getPageTimeout)
+    page.setDefaultTimeout(this.options.timeout)
 
     page.on('crash', async () => {
-      console.log('ERROR: Page has crashed, closing page!');
-      await page.close();
-    });
-    this.context = await this.page;
-    this.contextLocator = null;
-    await page.bringToFront();
+      console.log('ERROR: Page has crashed, closing page!')
+      await page.close()
+    })
+    this.context = await this.page
+    this.contextLocator = null
+    await page.bringToFront()
   }
 
   /**
@@ -773,33 +790,33 @@ class Playwright extends Helper {
    */
   _addPopupListener(page) {
     if (!page) {
-      return;
+      return
     }
-    page.removeAllListeners('dialog');
+    page.removeAllListeners('dialog')
     page.on('dialog', async (dialog) => {
-      popupStore.popup = dialog;
-      const action = popupStore.actionType || this.options.defaultPopupAction;
-      await this._waitForAction();
+      popupStore.popup = dialog
+      const action = popupStore.actionType || this.options.defaultPopupAction
+      await this._waitForAction()
 
       switch (action) {
         case 'accept':
-          return dialog.accept();
+          return dialog.accept()
 
         case 'cancel':
-          return dialog.dismiss();
+          return dialog.dismiss()
 
         default: {
-          throw new Error('Unknown popup action type. Only "accept" or "cancel" are accepted');
+          throw new Error('Unknown popup action type. Only "accept" or "cancel" are accepted')
         }
       }
-    });
+    })
   }
 
   /**
    * Gets page URL including hash.
    */
   async _getPageUrl() {
-    return this.executeScript(() => window.location.href);
+    return this.executeScript(() => window.location.href)
   }
 
   /**
@@ -812,45 +829,48 @@ class Playwright extends Helper {
    */
   async grabPopupText() {
     if (popupStore.popup) {
-      return popupStore.popup.message();
+      return popupStore.popup.message()
     }
-    return null;
+    return null
   }
 
   async _startBrowser() {
     if (this.isElectron) {
-      this.browser = await playwright._electron.launch(this.playwrightOptions);
+      this.browser = await playwright._electron.launch(this.playwrightOptions)
     } else if (this.isRemoteBrowser && this.isCDPConnection) {
       try {
-        this.browser = await playwright[this.options.browser].connectOverCDP(this.playwrightOptions);
+        this.browser = await playwright[this.options.browser].connectOverCDP(this.playwrightOptions)
       } catch (err) {
         if (err.toString().indexOf('ECONNREFUSED')) {
-          throw new RemoteBrowserConnectionRefused(err);
+          throw new RemoteBrowserConnectionRefused(err)
         }
-        throw err;
+        throw err
       }
     } else if (this.isRemoteBrowser) {
       try {
-        this.browser = await playwright[this.options.browser].connect(this.playwrightOptions);
+        this.browser = await playwright[this.options.browser].connect(this.playwrightOptions)
       } catch (err) {
         if (err.toString().indexOf('ECONNREFUSED')) {
-          throw new RemoteBrowserConnectionRefused(err);
+          throw new RemoteBrowserConnectionRefused(err)
         }
-        throw err;
+        throw err
       }
     } else if (this.playwrightOptions.userDataDir) {
-      this.browser = await playwright[this.options.browser].launchPersistentContext(this.userDataDir, this.playwrightOptions);
+      this.browser = await playwright[this.options.browser].launchPersistentContext(
+        this.userDataDir,
+        this.playwrightOptions,
+      )
     } else {
-      this.browser = await playwright[this.options.browser].launch(this.playwrightOptions);
+      this.browser = await playwright[this.options.browser].launch(this.playwrightOptions)
     }
 
     // works only for Chromium
     this.browser.on('targetchanged', (target) => {
-      this.debugSection('Url', target.url());
-    });
+      this.debugSection('Url', target.url())
+    })
 
-    this.isRunning = true;
-    return this.browser;
+    this.isRunning = true
+    return this.browser
   }
 
   /**
@@ -859,72 +879,72 @@ class Playwright extends Helper {
    * @param {object} [contextOptions] See https://playwright.dev/docs/api/class-browser#browser-new-context
    */
   async _createContextPage(contextOptions) {
-    this.browserContext = await this.browser.newContext(contextOptions);
-    const page = await this.browserContext.newPage();
-    targetCreatedHandler.call(this, page);
-    await this._setPage(page);
+    this.browserContext = await this.browser.newContext(contextOptions)
+    const page = await this.browserContext.newPage()
+    targetCreatedHandler.call(this, page)
+    await this._setPage(page)
   }
 
   _getType() {
-    return this.browser._type;
+    return this.browser._type
   }
 
   async _stopBrowser() {
-    this.withinLocator = null;
-    await this._setPage(null);
-    this.context = null;
-    this.frame = null;
-    popupStore.clear();
-    if (this.options.recordHar) await this.browserContext.close();
-    await this.browser.close();
+    this.withinLocator = null
+    await this._setPage(null)
+    this.context = null
+    this.frame = null
+    popupStore.clear()
+    if (this.options.recordHar) await this.browserContext.close()
+    await this.browser.close()
   }
 
   async _evaluateHandeInContext(...args) {
-    const context = await this._getContext();
-    return context.evaluateHandle(...args);
+    const context = await this._getContext()
+    return context.evaluateHandle(...args)
   }
 
   async _withinBegin(locator) {
     if (this.withinLocator) {
-      throw new Error('Can\'t start within block inside another within block');
+      throw new Error("Can't start within block inside another within block")
     }
 
-    const frame = isFrameLocator(locator);
+    const frame = isFrameLocator(locator)
 
     if (frame) {
       if (Array.isArray(frame)) {
-        await this.switchTo(null);
-        return frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve());
+        await this.switchTo(null)
+        return frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve())
       }
-      await this.switchTo(frame);
-      this.withinLocator = new Locator(frame);
-      return;
+      await this.switchTo(frame)
+      this.withinLocator = new Locator(frame)
+      return
     }
 
-    const el = await this._locateElement(locator);
-    assertElementExists(el, locator);
-    this.context = el;
-    this.contextLocator = locator;
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator)
+    this.context = el
+    this.contextLocator = locator
 
-    this.withinLocator = new Locator(locator);
+    this.withinLocator = new Locator(locator)
   }
 
   async _withinEnd() {
-    this.withinLocator = null;
-    this.context = await this.page;
-    this.contextLocator = null;
-    this.frame = null;
+    this.withinLocator = null
+    this.context = await this.page
+    this.contextLocator = null
+    this.frame = null
   }
 
   _extractDataFromPerformanceTiming(timing, ...dataNames) {
-    const navigationStart = timing.navigationStart;
+    const navigationStart = timing.navigationStart
 
-    const extractedData = {};
+    const extractedData = {}
     dataNames.forEach((name) => {
-      extractedData[name] = timing[name] - navigationStart;
-    });
+      extractedData[name] = timing[name] - navigationStart
+    })
 
-    return extractedData;
+    return extractedData
   }
 
   /**
@@ -932,22 +952,22 @@ class Playwright extends Helper {
    */
   async amOnPage(url) {
     if (this.isElectron) {
-      throw new Error('Cannot open pages inside an Electron container');
+      throw new Error('Cannot open pages inside an Electron container')
     }
-    if (!(/^\w+\:(\/\/|.+)/.test(url))) {
-      url = this.options.url + (url.startsWith('/') ? url : `/${url}`);
+    if (!/^\w+\:(\/\/|.+)/.test(url)) {
+      url = this.options.url + (url.startsWith('/') ? url : `/${url}`)
     }
 
-    if (this.options.basicAuth && (this.isAuthenticated !== true)) {
+    if (this.options.basicAuth && this.isAuthenticated !== true) {
       if (url.includes(this.options.url)) {
-        await this.browserContext.setHTTPCredentials(this.options.basicAuth);
-        this.isAuthenticated = true;
+        await this.browserContext.setHTTPCredentials(this.options.basicAuth)
+        this.isAuthenticated = true
       }
     }
 
-    await this.page.goto(url, { waitUntil: this.options.waitForNavigation });
+    await this.page.goto(url, { waitUntil: this.options.waitForNavigation })
 
-    const performanceTiming = JSON.parse(await this.page.evaluate(() => JSON.stringify(window.performance.timing)));
+    const performanceTiming = JSON.parse(await this.page.evaluate(() => JSON.stringify(window.performance.timing)))
 
     perfTiming = this._extractDataFromPerformanceTiming(
       performanceTiming,
@@ -955,9 +975,9 @@ class Playwright extends Helper {
       'domInteractive',
       'domContentLoadedEventEnd',
       'loadEventEnd',
-    );
+    )
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -978,11 +998,11 @@ class Playwright extends Helper {
    */
   async resizeWindow(width, height) {
     if (width === 'maximize') {
-      throw new Error('Playwright can\'t control windows, so it can\'t maximize it');
+      throw new Error("Playwright can't control windows, so it can't maximize it")
     }
 
-    await this.page.setViewportSize({ width, height });
-    return this._waitForAction();
+    await this.page.setViewportSize({ width, height })
+    return this._waitForAction()
   }
 
   /**
@@ -998,9 +1018,9 @@ class Playwright extends Helper {
    */
   async setPlaywrightRequestHeaders(customHeaders) {
     if (!customHeaders) {
-      throw new Error('Cannot send empty headers.');
+      throw new Error('Cannot send empty headers.')
     }
-    return this.browserContext.setExtraHTTPHeaders(customHeaders);
+    return this.browserContext.setExtraHTTPHeaders(customHeaders)
   }
 
   /**
@@ -1008,13 +1028,13 @@ class Playwright extends Helper {
    *
    */
   async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
-    const el = await this._locateElement(locator);
-    assertElementExists(el, locator);
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator)
 
     // Use manual mouse.move instead of .hover() so the offset can be added to the coordinates
-    const { x, y } = await clickablePoint(el);
-    await this.page.mouse.move(x + offsetX, y + offsetY);
-    return this._waitForAction();
+    const { x, y } = await clickablePoint(el)
+    await this.page.mouse.move(x + offsetX, y + offsetY)
+    return this._waitForAction()
   }
 
   /**
@@ -1022,11 +1042,11 @@ class Playwright extends Helper {
    *
    */
   async focus(locator, options = {}) {
-    const el = await this._locateElement(locator);
-    assertElementExists(el, locator, 'Element to focus');
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator, 'Element to focus')
 
-    await el.focus(options);
-    return this._waitForAction();
+    await el.focus(options)
+    return this._waitForAction()
   }
 
   /**
@@ -1034,11 +1054,11 @@ class Playwright extends Helper {
    *
    */
   async blur(locator, options = {}) {
-    const el = await this._locateElement(locator);
-    assertElementExists(el, locator, 'Element to blur');
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator, 'Element to blur')
 
-    await el.blur(options);
-    return this._waitForAction();
+    await el.blur(options)
+    return this._waitForAction()
   }
   /**
    * Return the checked status of given element.
@@ -1050,14 +1070,14 @@ class Playwright extends Helper {
    */
 
   async grabCheckedElementStatus(locator, options = {}) {
-    const supportedTypes = ['checkbox', 'radio'];
-    const el = await this._locateElement(locator);
-    const type = await el.getAttribute('type');
+    const supportedTypes = ['checkbox', 'radio']
+    const el = await this._locateElement(locator)
+    const type = await el.getAttribute('type')
 
     if (supportedTypes.includes(type)) {
-      return el.isChecked(options);
+      return el.isChecked(options)
     }
-    throw new Error(`Element is not a ${supportedTypes.join(' or ')} input`);
+    throw new Error(`Element is not a ${supportedTypes.join(' or ')} input`)
   }
   /**
    * Return the disabled status of given element.
@@ -1069,8 +1089,8 @@ class Playwright extends Helper {
    */
 
   async grabDisabledElementStatus(locator, options = {}) {
-    const el = await this._locateElement(locator);
-    return el.isDisabled(options);
+    const el = await this._locateElement(locator)
+    return el.isDisabled(options)
   }
 
   /**
@@ -1087,24 +1107,24 @@ class Playwright extends Helper {
    *
    */
   async dragAndDrop(srcElement, destElement, options) {
-    const src = new Locator(srcElement);
-    const dst = new Locator(destElement);
+    const src = new Locator(srcElement)
+    const dst = new Locator(destElement)
 
     if (options) {
-      return this.page.dragAndDrop(buildLocatorString(src), buildLocatorString(dst), options);
+      return this.page.dragAndDrop(buildLocatorString(src), buildLocatorString(dst), options)
     }
 
-    const _smallWaitInMs = 600;
-    await this.page.locator(buildLocatorString(src)).hover();
-    await this.page.mouse.down();
-    await this.page.waitForTimeout(_smallWaitInMs);
+    const _smallWaitInMs = 600
+    await this.page.locator(buildLocatorString(src)).hover()
+    await this.page.mouse.down()
+    await this.page.waitForTimeout(_smallWaitInMs)
 
-    const destElBox = await this.page.locator(buildLocatorString(dst)).boundingBox();
+    const destElBox = await this.page.locator(buildLocatorString(dst)).boundingBox()
 
-    await this.page.mouse.move(destElBox.x + destElBox.width / 2, destElBox.y + destElBox.height / 2);
-    await this.page.locator(buildLocatorString(dst)).hover({ position: { x: 10, y: 10 } });
-    await this.page.waitForTimeout(_smallWaitInMs);
-    await this.page.mouse.up();
+    await this.page.mouse.move(destElBox.x + destElBox.width / 2, destElBox.y + destElBox.height / 2)
+    await this.page.locator(buildLocatorString(dst)).hover({ position: { x: 10, y: 10 } })
+    await this.page.waitForTimeout(_smallWaitInMs)
+    await this.page.mouse.up()
   }
 
   /**
@@ -1122,16 +1142,16 @@ class Playwright extends Helper {
    * @param {object} [contextOptions] [Options for browser context](https://playwright.dev/docs/api/class-browser#browser-new-context) when starting new browser
    */
   async restartBrowser(contextOptions) {
-    await this._stopBrowser();
-    await this._startBrowser();
-    await this._createContextPage(contextOptions);
+    await this._stopBrowser()
+    await this._startBrowser()
+    await this._createContextPage(contextOptions)
   }
 
   /**
    * {{> refreshPage }}
    */
   async refreshPage() {
-    return this.page.reload({ timeout: this.options.getPageTimeout, waitUntil: this.options.waitForNavigation });
+    return this.page.reload({ timeout: this.options.getPageTimeout, waitUntil: this.options.waitForNavigation })
   }
 
   /**
@@ -1152,13 +1172,13 @@ class Playwright extends Helper {
    * @returns Promise<void>
    */
   async replayFromHar(harFilePath, opts) {
-    const file = path.join(global.codecept_dir, harFilePath);
+    const file = path.join(global.codecept_dir, harFilePath)
 
     if (!fileExists(file)) {
-      throw new Error(`File at ${file} cannot be found on local system`);
+      throw new Error(`File at ${file} cannot be found on local system`)
     }
 
-    await this.page.routeFromHAR(harFilePath, opts);
+    await this.page.routeFromHAR(harFilePath, opts)
   }
 
   /**
@@ -1166,8 +1186,8 @@ class Playwright extends Helper {
    */
   scrollPageToTop() {
     return this.executeScript(() => {
-      window.scrollTo(0, 0);
-    });
+      window.scrollTo(0, 0)
+    })
   }
 
   /**
@@ -1175,16 +1195,13 @@ class Playwright extends Helper {
    */
   async scrollPageToBottom() {
     return this.executeScript(() => {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight,
-      ));
-    });
+      const body = document.body
+      const html = document.documentElement
+      window.scrollTo(
+        0,
+        Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
+      )
+    })
   }
 
   /**
@@ -1192,29 +1209,32 @@ class Playwright 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 el = await this._locateElement(locator);
-      assertElementExists(el, locator, 'Element');
-      await el.scrollIntoViewIfNeeded();
-      const elementCoordinates = await clickablePoint(el);
-      await this.executeScript((offsetX, offsetY) => window.scrollBy(offsetX, offsetY), { offsetX: elementCoordinates.x + offsetX, offsetY: elementCoordinates.y + offsetY });
+      const el = await this._locateElement(locator)
+      assertElementExists(el, locator, 'Element')
+      await el.scrollIntoViewIfNeeded()
+      const elementCoordinates = await clickablePoint(el)
+      await this.executeScript((offsetX, offsetY) => window.scrollBy(offsetX, offsetY), {
+        offsetX: elementCoordinates.x + offsetX,
+        offsetY: elementCoordinates.y + offsetY,
+      })
     } else {
-      await this.executeScript(({ offsetX, offsetY }) => window.scrollTo(offsetX, offsetY), { offsetX, offsetY });
+      await this.executeScript(({ offsetX, offsetY }) => window.scrollTo(offsetX, offsetY), { offsetX, offsetY })
     }
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
    * {{> seeInTitle }}
    */
   async seeInTitle(text) {
-    const title = await this.page.title();
-    stringIncludes('web page title').assert(text, title);
+    const title = await this.page.title()
+    stringIncludes('web page title').assert(text, title)
   }
 
   /**
@@ -1225,34 +1245,34 @@ class Playwright extends Helper {
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
+        y: window.pageYOffset,
+      }
     }
     /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
+    return this.executeScript(getScrollPosition)
   }
 
   /**
    * {{> seeTitleEquals }}
    */
   async seeTitleEquals(text) {
-    const title = await this.page.title();
-    return equals('web page title').assert(title, text);
+    const title = await this.page.title()
+    return equals('web page title').assert(title, text)
   }
 
   /**
    * {{> dontSeeInTitle }}
    */
   async dontSeeInTitle(text) {
-    const title = await this.page.title();
-    stringIncludes('web page title').negate(text, title);
+    const title = await this.page.title()
+    stringIncludes('web page title').negate(text, title)
   }
 
   /**
    * {{> grabTitle }}
    */
   async grabTitle() {
-    return this.page.title();
+    return this.page.title()
   }
 
   /**
@@ -1264,11 +1284,11 @@ class Playwright extends Helper {
    * ```
    */
   async _locate(locator) {
-    const context = await this.context || await this._getContext();
+    const context = (await this.context) || (await this._getContext())
 
-    if (this.frame) return findElements(this.frame, locator);
+    if (this.frame) return findElements(this.frame, locator)
 
-    return findElements(context, locator);
+    return findElements(context, locator)
   }
 
   /**
@@ -1280,8 +1300,8 @@ class Playwright extends Helper {
    * ```
    */
   async _locateElement(locator) {
-    const context = await this.context || await this._getContext();
-    return findElement(context, locator);
+    const context = (await this.context) || (await this._getContext())
+    return findElement(context, locator)
   }
 
   /**
@@ -1293,10 +1313,10 @@ class Playwright extends Helper {
    * ```
    */
   async _locateCheckable(locator, providedContext = null) {
-    const context = providedContext || await this._getContext();
-    const els = await findCheckable.call(this, locator, context);
-    assertElementExists(els[0], locator, 'Checkbox or radio');
-    return els[0];
+    const context = providedContext || (await this._getContext())
+    const els = await findCheckable.call(this, locator, context)
+    assertElementExists(els[0], locator, 'Checkbox or radio')
+    return els[0]
   }
 
   /**
@@ -1307,8 +1327,8 @@ class Playwright extends Helper {
    * ```
    */
   async _locateClickable(locator) {
-    const context = await this._getContext();
-    return findClickable.call(this, context, locator);
+    const context = await this._getContext()
+    return findClickable.call(this, context, locator)
   }
 
   /**
@@ -1319,7 +1339,7 @@ class Playwright extends Helper {
    * ```
    */
   async _locateFields(locator) {
-    return findFields.call(this, locator);
+    return findFields.call(this, locator)
   }
 
   /**
@@ -1327,7 +1347,7 @@ class Playwright extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator);
+    return this._locate(locator)
   }
 
   /**
@@ -1335,7 +1355,7 @@ class Playwright extends Helper {
    *
    */
   async grabWebElement(locator) {
-    return this._locateElement(locator);
+    return this._locateElement(locator)
   }
 
   /**
@@ -1350,20 +1370,20 @@ class Playwright extends Helper {
    */
   async switchToNextTab(num = 1) {
     if (this.isElectron) {
-      throw new Error('Cannot switch tabs inside an Electron container');
+      throw new Error('Cannot switch tabs inside an Electron container')
     }
-    const pages = await this.browserContext.pages();
+    const pages = await this.browserContext.pages()
 
-    const index = pages.indexOf(this.page);
-    this.withinLocator = null;
-    const page = pages[index + num];
+    const index = pages.indexOf(this.page)
+    this.withinLocator = null
+    const page = pages[index + num]
 
     if (!page) {
-      throw new Error(`There is no ability to switch to next tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to next tab with offset ${num}`)
     }
-    await targetCreatedHandler.call(this, page);
-    await this._setPage(page);
-    return this._waitForAction();
+    await targetCreatedHandler.call(this, page)
+    await this._setPage(page)
+    return this._waitForAction()
   }
 
   /**
@@ -1377,19 +1397,19 @@ class Playwright extends Helper {
    */
   async switchToPreviousTab(num = 1) {
     if (this.isElectron) {
-      throw new Error('Cannot switch tabs inside an Electron container');
+      throw new Error('Cannot switch tabs inside an Electron container')
     }
-    const pages = await this.browserContext.pages();
-    const index = pages.indexOf(this.page);
-    this.withinLocator = null;
-    const page = pages[index - num];
+    const pages = await this.browserContext.pages()
+    const index = pages.indexOf(this.page)
+    this.withinLocator = null
+    const page = pages[index - num]
 
     if (!page) {
-      throw new Error(`There is no ability to switch to previous tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to previous tab with offset ${num}`)
     }
 
-    await this._setPage(page);
-    return this._waitForAction();
+    await this._setPage(page)
+    return this._waitForAction()
   }
 
   /**
@@ -1401,12 +1421,12 @@ class Playwright extends Helper {
    */
   async closeCurrentTab() {
     if (this.isElectron) {
-      throw new Error('Cannot close current tab inside an Electron container');
+      throw new Error('Cannot close current tab inside an Electron container')
     }
-    const oldPage = this.page;
-    await this.switchToPreviousTab();
-    await oldPage.close();
-    return this._waitForAction();
+    const oldPage = this.page
+    await this.switchToPreviousTab()
+    await oldPage.close()
+    return this._waitForAction()
   }
 
   /**
@@ -1417,13 +1437,13 @@ class Playwright extends Helper {
    * ```
    */
   async closeOtherTabs() {
-    const pages = await this.browserContext.pages();
-    const otherPages = pages.filter(page => page !== this.page);
+    const pages = await this.browserContext.pages()
+    const otherPages = pages.filter((page) => page !== this.page)
     if (otherPages.length) {
-      this.debug(`Closing ${otherPages.length} tabs`);
-      return Promise.all(otherPages.map(p => p.close()));
+      this.debug(`Closing ${otherPages.length} tabs`)
+      return Promise.all(otherPages.map((p) => p.close()))
     }
-    return Promise.resolve();
+    return Promise.resolve()
   }
 
   /**
@@ -1442,20 +1462,20 @@ class Playwright extends Helper {
    */
   async openNewTab(options) {
     if (this.isElectron) {
-      throw new Error('Cannot open new tabs inside an Electron container');
+      throw new Error('Cannot open new tabs inside an Electron container')
     }
-    const page = await this.browserContext.newPage(options);
-    await targetCreatedHandler.call(this, page);
-    await this._setPage(page);
-    return this._waitForAction();
+    const page = await this.browserContext.newPage(options)
+    await targetCreatedHandler.call(this, page)
+    await this._setPage(page)
+    return this._waitForAction()
   }
 
   /**
    * {{> grabNumberOfOpenTabs }}
    */
   async grabNumberOfOpenTabs() {
-    const pages = await this.browserContext.pages();
-    return pages.length;
+    const pages = await this.browserContext.pages()
+    return pages.length
   }
 
   /**
@@ -1463,12 +1483,12 @@ class Playwright extends Helper {
    *
    */
   async seeElement(locator) {
-    let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.isVisible()));
+    let els = await this._locate(locator)
+    els = await Promise.all(els.map((el) => el.isVisible()))
     try {
-      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+      return empty('visible elements').negate(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      dontSeeElementError(locator);
+      dontSeeElementError(locator)
     }
   }
 
@@ -1477,12 +1497,12 @@ class Playwright extends Helper {
    *
    */
   async dontSeeElement(locator) {
-    let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.isVisible()));
+    let els = await this._locate(locator)
+    els = await Promise.all(els.map((el) => el.isVisible()))
     try {
-      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+      return empty('visible elements').assert(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      seeElementError(locator);
+      seeElementError(locator)
     }
   }
 
@@ -1490,11 +1510,11 @@ class Playwright extends Helper {
    * {{> seeElementInDOM }}
    */
   async seeElementInDOM(locator) {
-    const els = await this._locate(locator);
+    const els = await this._locate(locator)
     try {
-      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+      return empty('elements on page').negate(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      dontSeeElementInDOMError(locator);
+      dontSeeElementInDOMError(locator)
     }
   }
 
@@ -1502,11 +1522,11 @@ class Playwright extends Helper {
    * {{> dontSeeElementInDOM }}
    */
   async dontSeeElementInDOM(locator) {
-    const els = await this._locate(locator);
+    const els = await this._locate(locator)
     try {
-      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+      return empty('elements on a page').assert(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      seeElementInDOMError(locator);
+      seeElementInDOMError(locator)
     }
   }
 
@@ -1529,18 +1549,18 @@ class Playwright extends Helper {
    */
   async handleDownloads(fileName) {
     this.page.waitForEvent('download').then(async (download) => {
-      const filePath = await download.path();
-      fileName = fileName || `downloads/${path.basename(filePath)}`;
+      const filePath = await download.path()
+      fileName = fileName || `downloads/${path.basename(filePath)}`
 
-      const downloadPath = path.join(global.output_dir, fileName);
+      const downloadPath = path.join(global.output_dir, fileName)
       if (!fs.existsSync(path.dirname(downloadPath))) {
-        fs.mkdirSync(path.dirname(downloadPath), '0777');
+        fs.mkdirSync(path.dirname(downloadPath), '0777')
       }
-      fs.copyFileSync(filePath, downloadPath);
-      this.debug('Download completed');
-      this.debugSection('Downloaded From', await download.url());
-      this.debugSection('Downloaded To', downloadPath);
-    });
+      fs.copyFileSync(filePath, downloadPath)
+      this.debug('Download completed')
+      this.debugSection('Downloaded From', await download.url())
+      this.debugSection('Downloaded To', downloadPath)
+    })
   }
 
   /**
@@ -1560,37 +1580,37 @@ class Playwright extends Helper {
    *
    */
   async click(locator, context = null, options = {}) {
-    return proceedClick.call(this, locator, context, options);
+    return proceedClick.call(this, locator, context, options)
   }
 
   /**
    * Clicks link and waits for navigation (deprecated)
    */
   async clickLink(locator, context = null) {
-    console.log('clickLink deprecated: Playwright automatically waits for navigation to happen.');
-    console.log('Replace I.clickLink with I.click');
-    return this.click(locator, context);
+    console.log('clickLink deprecated: Playwright automatically waits for navigation to happen.')
+    console.log('Replace I.clickLink with I.click')
+    return this.click(locator, context)
   }
 
   /**
    * {{> forceClick }}
    */
   async forceClick(locator, context = null) {
-    return proceedClick.call(this, locator, context, { force: true });
+    return proceedClick.call(this, locator, context, { force: true })
   }
 
   /**
    * {{> doubleClick }}
    */
   async doubleClick(locator, context = null) {
-    return proceedClick.call(this, locator, context, { clickCount: 2 });
+    return proceedClick.call(this, locator, context, { clickCount: 2 })
   }
 
   /**
    * {{> rightClick }}
    */
   async rightClick(locator, context = null) {
-    return proceedClick.call(this, locator, context, { button: 'right' });
+    return proceedClick.call(this, locator, context, { button: 'right' })
   }
 
   /**
@@ -1609,9 +1629,9 @@ class Playwright extends Helper {
    *
    */
   async checkOption(field, context = null, options = { force: true }) {
-    const elm = await this._locateCheckable(field, context);
-    await elm.check(options);
-    return this._waitForAction();
+    const elm = await this._locateCheckable(field, context)
+    await elm.check(options)
+    return this._waitForAction()
   }
 
   /**
@@ -1629,41 +1649,41 @@ class Playwright extends Helper {
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null, options = { force: true }) {
-    const elm = await this._locateCheckable(field, context);
-    await elm.uncheck(options);
-    return this._waitForAction();
+    const elm = await this._locateCheckable(field, context)
+    await elm.uncheck(options)
+    return this._waitForAction()
   }
 
   /**
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'assert', field);
+    return proceedIsChecked.call(this, 'assert', field)
   }
 
   /**
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'negate', field);
+    return proceedIsChecked.call(this, 'negate', field)
   }
 
   /**
    * {{> pressKeyDown }}
    */
   async pressKeyDown(key) {
-    key = getNormalizedKey.call(this, key);
-    await this.page.keyboard.down(key);
-    return this._waitForAction();
+    key = getNormalizedKey.call(this, key)
+    await this.page.keyboard.down(key)
+    return this._waitForAction()
   }
 
   /**
    * {{> pressKeyUp }}
    */
   async pressKeyUp(key) {
-    key = getNormalizedKey.call(this, key);
-    await this.page.keyboard.up(key);
-    return this._waitForAction();
+    key = getNormalizedKey.call(this, key)
+    await this.page.keyboard.up(key)
+    return this._waitForAction()
   }
 
   /**
@@ -1673,28 +1693,28 @@ class Playwright 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.page.keyboard.down(modifier);
+      await this.page.keyboard.down(modifier)
     }
-    await this.page.keyboard.press(key);
+    await this.page.keyboard.press(key)
     for (const modifier of modifiers) {
-      await this.page.keyboard.up(modifier);
+      await this.page.keyboard.up(modifier)
     }
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -1702,13 +1722,13 @@ class Playwright extends Helper {
    */
   async type(keys, delay = null) {
     if (!Array.isArray(keys)) {
-      keys = keys.toString();
-      keys = keys.split('');
+      keys = keys.toString()
+      keys = keys.split('')
     }
 
     for (const key of keys) {
-      await this.page.keyboard.press(key);
-      if (delay) await this.wait(delay / 1000);
+      await this.page.keyboard.press(key)
+      if (delay) await this.wait(delay / 1000)
     }
   }
 
@@ -1717,75 +1737,75 @@ class Playwright extends Helper {
    *
    */
   async fillField(field, value) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = els[0];
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = els[0]
 
-    await el.clear();
+    await el.clear()
 
-    await highlightActiveElement.call(this, el);
+    await highlightActiveElement.call(this, el)
 
-    await el.type(value.toString(), { delay: this.options.pressKeyDelay });
+    await el.type(value.toString(), { delay: this.options.pressKeyDelay })
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
    * Clears the text input element: `<input>`, `<textarea>` or `[contenteditable]` .
    *
-  *
-  * Examples:
-  *
-  * ```js
-  * I.clearField('.text-area')
-  *
-  * // if this doesn't work use force option
-  * I.clearField('#submit', { force: true })
-  * ```
-  * Use `force` to bypass the [actionability](https://playwright.dev/docs/actionability) checks.
-  *
+   *
+   * Examples:
+   *
+   * ```js
+   * I.clearField('.text-area')
+   *
+   * // if this doesn't work use force option
+   * I.clearField('#submit', { force: true })
+   * ```
+   * Use `force` to bypass the [actionability](https://playwright.dev/docs/actionability) checks.
+   *
    * @param {CodeceptJS.LocatorOrString} locator field located by label|name|CSS|XPath|strict locator.
    * @param {any} [options] [Additional options](https://playwright.dev/docs/api/class-locator#locator-clear) for available options object as 2nd argument.
    */
   async clearField(locator, options = {}) {
-    const els = await findFields.call(this, locator);
-    assertElementExists(els, locator, 'Field to clear');
+    const els = await findFields.call(this, locator)
+    assertElementExists(els, locator, 'Field to clear')
 
-    const el = els[0];
+    const el = els[0]
 
-    await highlightActiveElement.call(this, el);
+    await highlightActiveElement.call(this, el)
 
-    await el.clear();
+    await el.clear()
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
    * {{> appendField }}
    */
   async appendField(field, value) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    await highlightActiveElement.call(this, els[0]);
-    await els[0].press('End');
-    await els[0].type(value.toString(), { delay: this.options.pressKeyDelay });
-    return this._waitForAction();
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    await highlightActiveElement.call(this, els[0])
+    await els[0].press('End')
+    await els[0].type(value.toString(), { delay: this.options.pressKeyDelay })
+    return this._waitForAction()
   }
 
   /**
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'assert', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'assert', field, _value)
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'negate', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'negate', field, _value)
   }
 
   /**
@@ -1793,38 +1813,38 @@ class Playwright extends Helper {
    *
    */
   async attachFile(locator, pathToFile) {
-    const file = path.join(global.codecept_dir, pathToFile);
+    const 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 els = await findFields.call(this, locator);
-    assertElementExists(els, locator, 'Field');
-    await els[0].setInputFiles(file);
-    return this._waitForAction();
+    const els = await findFields.call(this, locator)
+    assertElementExists(els, locator, 'Field')
+    await els[0].setInputFiles(file)
+    return this._waitForAction()
   }
 
   /**
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const els = await findFields.call(this, select);
-    assertElementExists(els, select, 'Selectable field');
-    const el = els[0];
+    const els = await findFields.call(this, select)
+    assertElementExists(els, select, 'Selectable field')
+    const el = els[0]
 
-    await highlightActiveElement.call(this, el);
-    let optionToSelect = '';
+    await highlightActiveElement.call(this, el)
+    let optionToSelect = ''
 
     try {
-      optionToSelect = (await el.locator('option', { hasText: option }).textContent()).trim();
+      optionToSelect = (await el.locator('option', { hasText: option }).textContent()).trim()
     } catch (e) {
-      optionToSelect = option;
+      optionToSelect = option
     }
 
-    if (!Array.isArray(option)) option = [optionToSelect];
+    if (!Array.isArray(option)) option = [optionToSelect]
 
-    await el.selectOption(option);
-    return this._waitForAction();
+    await el.selectOption(option)
+    return this._waitForAction()
   }
 
   /**
@@ -1832,37 +1852,37 @@ class Playwright extends Helper {
    *
    */
   async grabNumberOfVisibleElements(locator) {
-    let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.isVisible()));
-    return els.filter(v => v).length;
+    let els = await this._locate(locator)
+    els = await Promise.all(els.map((el) => el.isVisible()))
+    return els.filter((v) => v).length
   }
 
   /**
    * {{> seeInCurrentUrl }}
    */
   async seeInCurrentUrl(url) {
-    stringIncludes('url').assert(url, await this._getPageUrl());
+    stringIncludes('url').assert(url, await this._getPageUrl())
   }
 
   /**
    * {{> dontSeeInCurrentUrl }}
    */
   async dontSeeInCurrentUrl(url) {
-    stringIncludes('url').negate(url, await this._getPageUrl());
+    stringIncludes('url').negate(url, await this._getPageUrl())
   }
 
   /**
    * {{> seeCurrentUrlEquals }}
    */
   async seeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).assert(url, await this._getPageUrl());
+    urlEquals(this.options.url).assert(url, await this._getPageUrl())
   }
 
   /**
    * {{> dontSeeCurrentUrlEquals }}
    */
   async dontSeeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).negate(url, await this._getPageUrl());
+    urlEquals(this.options.url).negate(url, await this._getPageUrl())
   }
 
   /**
@@ -1871,14 +1891,14 @@ class Playwright extends Helper {
    *
    */
   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)
   }
 
   /**
@@ -1887,14 +1907,14 @@ class Playwright extends Helper {
    *
    */
   async dontSee(text, context = null) {
-    return proceedSee.call(this, 'negate', text, context);
+    return proceedSee.call(this, 'negate', text, context)
   }
 
   /**
    * {{> grabSource }}
    */
   async grabSource() {
-    return this.page.content();
+    return this.page.content()
   }
 
   /**
@@ -1909,32 +1929,32 @@ class Playwright extends Helper {
    * @return {Promise<any[]>}
    */
   async grabBrowserLogs() {
-    const logs = consoleLogStore.entries;
-    consoleLogStore.clear();
-    return logs;
+    const logs = consoleLogStore.entries
+    consoleLogStore.clear()
+    return logs
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    return this._getPageUrl();
+    return this._getPageUrl()
   }
 
   /**
    * {{> seeInSource }}
    */
   async seeInSource(text) {
-    const source = await this.page.content();
-    stringIncludes('HTML source of a page').assert(text, source);
+    const source = await this.page.content()
+    stringIncludes('HTML source of a page').assert(text, source)
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    const source = await this.page.content();
-    stringIncludes('HTML source of a page').negate(text, source);
+    const source = await this.page.content()
+    stringIncludes('HTML source of a page').negate(text, source)
   }
 
   /**
@@ -1943,8 +1963,10 @@ class Playwright extends Helper {
    *
    */
   async seeNumberOfElements(locator, num) {
-    const elements = await this._locate(locator);
-    return equals(`expected number of elements (${(new Locator(locator))}) is ${num}, but found ${elements.length}`).assert(elements.length, num);
+    const elements = await this._locate(locator)
+    return equals(
+      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
+    ).assert(elements.length, num)
   }
 
   /**
@@ -1953,8 +1975,11 @@ class Playwright extends Helper {
    *
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const res = await this.grabNumberOfVisibleElements(locator);
-    return equals(`expected number of visible elements (${(new Locator(locator))}) is ${num}, but found ${res}`).assert(res, num);
+    const res = await this.grabNumberOfVisibleElements(locator)
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
+      res,
+      num,
+    )
   }
 
   /**
@@ -1962,9 +1987,9 @@ class Playwright extends Helper {
    */
   async setCookie(cookie) {
     if (Array.isArray(cookie)) {
-      return this.browserContext.addCookies(cookie);
+      return this.browserContext.addCookies(cookie)
     }
-    return this.browserContext.addCookies([cookie]);
+    return this.browserContext.addCookies([cookie])
   }
 
   /**
@@ -1972,16 +1997,16 @@ class Playwright extends Helper {
    *
    */
   async seeCookie(name) {
-    const cookies = await this.browserContext.cookies();
-    empty(`cookie ${name} to be set`).negate(cookies.filter(c => c.name === name));
+    const cookies = await this.browserContext.cookies()
+    empty(`cookie ${name} to be set`).negate(cookies.filter((c) => c.name === name))
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    const cookies = await this.browserContext.cookies();
-    empty(`cookie ${name} not to be set`).assert(cookies.filter(c => c.name === name));
+    const cookies = await this.browserContext.cookies()
+    empty(`cookie ${name} not to be set`).assert(cookies.filter((c) => c.name === name))
   }
 
   /**
@@ -1990,10 +2015,10 @@ class Playwright extends Helper {
    * {{> grabCookie }}
    */
   async grabCookie(name) {
-    const cookies = await this.browserContext.cookies();
-    if (!name) return cookies;
-    const cookie = cookies.filter(c => c.name === name);
-    if (cookie[0]) return cookie[0];
+    const cookies = await this.browserContext.cookies()
+    if (!name) return cookies
+    const cookie = cookies.filter((c) => c.name === name)
+    if (cookie[0]) return cookie[0]
   }
 
   /**
@@ -2002,8 +2027,8 @@ class Playwright extends Helper {
   async clearCookie() {
     // Playwright currently doesn't support to delete a certain cookie
     // https://github.com/microsoft/playwright/blob/main/docs/src/api/class-browsercontext.md#async-method-browsercontextclearcookies
-    if (!this.browserContext) return;
-    return this.browserContext.clearCookies();
+    if (!this.browserContext) return
+    return this.browserContext.clearCookies()
   }
 
   /**
@@ -2033,9 +2058,9 @@ class Playwright extends Helper {
   async executeScript(fn, arg) {
     if (this.context && this.context.constructor.name === 'FrameLocator') {
       // switching to iframe context
-      return this.context.locator(':root').evaluate(fn, arg);
+      return this.context.locator(':root').evaluate(fn, arg)
     }
-    return this.page.evaluate.apply(this.page, [fn, arg]);
+    return this.page.evaluate.apply(this.page, [fn, arg])
   }
 
   /**
@@ -2044,14 +2069,14 @@ class Playwright extends Helper {
    * @param {*} locator
    */
   _contextLocator(locator) {
-    locator = buildLocatorString(new Locator(locator, 'css'));
+    locator = buildLocatorString(new Locator(locator, 'css'))
 
     if (this.contextLocator) {
-      const contextLocator = buildLocatorString(new Locator(this.contextLocator, 'css'));
-      locator = `${contextLocator} >> ${locator}`;
+      const contextLocator = buildLocatorString(new Locator(this.contextLocator, 'css'))
+      locator = `${contextLocator} >> ${locator}`
     }
 
-    return locator;
+    return locator
   }
 
   /**
@@ -2059,11 +2084,11 @@ class Playwright extends Helper {
    *
    */
   async grabTextFrom(locator) {
-    locator = this._contextLocator(locator);
-    const text = await this.page.textContent(locator);
-    assertElementExists(text, locator);
-    this.debugSection('Text', text);
-    return text;
+    locator = this._contextLocator(locator)
+    const text = await this.page.textContent(locator)
+    assertElementExists(text, locator)
+    this.debugSection('Text', text)
+    return text
   }
 
   /**
@@ -2071,51 +2096,51 @@ class Playwright extends Helper {
    *
    */
   async grabTextFromAll(locator) {
-    const els = await this._locate(locator);
-    const texts = [];
+    const els = await this._locate(locator)
+    const texts = []
     for (const el of els) {
-      texts.push(await (await el.innerText()));
+      texts.push(await await el.innerText())
     }
-    this.debug(`Matched ${els.length} elements`);
-    return texts;
+    this.debug(`Matched ${els.length} elements`)
+    return texts
   }
 
   /**
    * {{> grabValueFrom }}
    */
   async grabValueFrom(locator) {
-    const values = await this.grabValueFromAll(locator);
-    assertElementExists(values, locator);
-    this.debugSection('Value', values[0]);
-    return values[0];
+    const values = await this.grabValueFromAll(locator)
+    assertElementExists(values, locator)
+    this.debugSection('Value', values[0])
+    return values[0]
   }
 
   /**
    * {{> grabValueFromAll }}
    */
   async grabValueFromAll(locator) {
-    const els = await findFields.call(this, locator);
-    this.debug(`Matched ${els.length} elements`);
-    return Promise.all(els.map(el => el.inputValue()));
+    const els = await findFields.call(this, locator)
+    this.debug(`Matched ${els.length} elements`)
+    return Promise.all(els.map((el) => el.inputValue()))
   }
 
   /**
    * {{> grabHTMLFrom }}
    */
   async grabHTMLFrom(locator) {
-    const html = await this.grabHTMLFromAll(locator);
-    assertElementExists(html, locator);
-    this.debugSection('HTML', html[0]);
-    return html[0];
+    const html = await this.grabHTMLFromAll(locator)
+    assertElementExists(html, locator)
+    this.debugSection('HTML', html[0])
+    return html[0]
   }
 
   /**
    * {{> grabHTMLFromAll }}
    */
   async grabHTMLFromAll(locator) {
-    const els = await this._locate(locator);
-    this.debug(`Matched ${els.length} elements`);
-    return Promise.all(els.map(el => el.innerHTML()));
+    const els = await this._locate(locator)
+    this.debug(`Matched ${els.length} elements`)
+    return Promise.all(els.map((el) => el.innerHTML()))
   }
 
   /**
@@ -2123,10 +2148,10 @@ class Playwright extends Helper {
    *
    */
   async grabCssPropertyFrom(locator, cssProperty) {
-    const cssValues = await this.grabCssPropertyFromAll(locator, cssProperty);
-    assertElementExists(cssValues, locator);
-    this.debugSection('CSS', cssValues[0]);
-    return cssValues[0];
+    const cssValues = await this.grabCssPropertyFromAll(locator, cssProperty)
+    assertElementExists(cssValues, locator)
+    this.debugSection('CSS', cssValues[0])
+    return cssValues[0]
   }
 
   /**
@@ -2134,11 +2159,15 @@ class Playwright extends Helper {
    *
    */
   async grabCssPropertyFromAll(locator, cssProperty) {
-    const els = await this._locate(locator);
-    this.debug(`Matched ${els.length} elements`);
-    const cssValues = await Promise.all(els.map(el => el.evaluate((el, cssProperty) => getComputedStyle(el).getPropertyValue(cssProperty), cssProperty)));
+    const els = await this._locate(locator)
+    this.debug(`Matched ${els.length} elements`)
+    const cssValues = await Promise.all(
+      els.map((el) =>
+        el.evaluate((el, cssProperty) => getComputedStyle(el).getPropertyValue(cssProperty), cssProperty),
+      ),
+    )
 
-    return cssValues;
+    return cssValues
   }
 
   /**
@@ -2146,35 +2175,37 @@ class Playwright extends Helper {
    *
    */
   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);
+    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)
   }
 
   /**
@@ -2182,31 +2213,33 @@ class Playwright extends Helper {
    *
    */
   async seeAttributesOnElements(locator, attributes) {
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
+    const res = await this._locate(locator)
+    assertElementExists(res, locator)
 
-    const elemAmount = res.length;
-    const commands = [];
+    const elemAmount = res.length
+    const commands = []
     res.forEach((el) => {
       Object.keys(attributes).forEach((prop) => {
-        commands.push(el
-          .evaluate((el, attr) => el[attr] || el.getAttribute(attr), prop));
-      });
-    });
-    let attrs = await Promise.all(commands);
-    const values = Object.keys(attributes).map(key => attributes[key]);
-    if (!Array.isArray(attrs)) attrs = [attrs];
-    let chunked = chunkArray(attrs, values.length);
+        commands.push(el.evaluate((el, attr) => el[attr] || el.getAttribute(attr), prop))
+      })
+    })
+    let attrs = await Promise.all(commands)
+    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) {
         // the attribute could be a boolean
-        if (typeof val[i] === 'boolean') return val[i] === values[i];
+        if (typeof val[i] === 'boolean') return val[i] === values[i]
         // if the attribute doesn't exist, returns false as well
-        if (!val[i] || !val[i].includes(values[i])) return false;
+        if (!val[i] || !val[i].includes(values[i])) return false
       }
-      return true;
-    });
-    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`).assert(chunked.length, elemAmount);
+      return true
+    })
+    return equals(`all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`).assert(
+      chunked.length,
+      elemAmount,
+    )
   }
 
   /**
@@ -2214,21 +2247,21 @@ class Playwright extends Helper {
    *
    */
   async dragSlider(locator, offsetX = 0) {
-    const src = await this._locateElement(locator);
-    assertElementExists(src, locator, 'Slider Element');
+    const src = await this._locateElement(locator)
+    assertElementExists(src, locator, 'Slider Element')
 
     // Note: Using clickablePoint private api because the .BoundingBox does not take into account iframe offsets!
-    const sliderSource = await clickablePoint(src);
+    const sliderSource = await clickablePoint(src)
 
     // Drag start point
-    await this.page.mouse.move(sliderSource.x, sliderSource.y, { steps: 5 });
-    await this.page.mouse.down();
+    await this.page.mouse.move(sliderSource.x, sliderSource.y, { steps: 5 })
+    await this.page.mouse.down()
 
     // Drag destination
-    await this.page.mouse.move(sliderSource.x + offsetX, sliderSource.y, { steps: 5 });
-    await this.page.mouse.up();
+    await this.page.mouse.move(sliderSource.x + offsetX, sliderSource.y, { steps: 5 })
+    await this.page.mouse.up()
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -2236,10 +2269,10 @@ class Playwright extends Helper {
    *
    */
   async grabAttributeFrom(locator, attr) {
-    const attrs = await this.grabAttributeFromAll(locator, attr);
-    assertElementExists(attrs, locator);
-    this.debugSection('Attribute', attrs[0]);
-    return attrs[0];
+    const attrs = await this.grabAttributeFromAll(locator, attr)
+    assertElementExists(attrs, locator)
+    this.debugSection('Attribute', attrs[0])
+    return attrs[0]
   }
 
   /**
@@ -2247,15 +2280,15 @@ class Playwright extends Helper {
    *
    */
   async grabAttributeFromAll(locator, attr) {
-    const els = await this._locate(locator);
-    this.debug(`Matched ${els.length} elements`);
-    const array = [];
+    const els = await this._locate(locator)
+    this.debug(`Matched ${els.length} elements`)
+    const array = []
 
     for (let index = 0; index < els.length; index++) {
-      array.push(await els[index].getAttribute(attr));
+      array.push(await els[index].getAttribute(attr))
     }
 
-    return array;
+    return array
   }
 
   /**
@@ -2263,43 +2296,43 @@ class Playwright extends Helper {
    *
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
-    const res = await this._locateElement(locator);
-    assertElementExists(res, locator);
-    const elem = res;
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
-    return elem.screenshot({ path: outputFile, type: 'png' });
+    const res = await this._locateElement(locator)
+    assertElementExists(res, locator)
+    const elem = res
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+    return elem.screenshot({ path: outputFile, type: 'png' })
   }
 
   /**
    * {{> saveScreenshot }}
    */
   async saveScreenshot(fileName, fullPage) {
-    const fullPageOption = fullPage || this.options.fullPageScreenshots;
-    let outputFile = screenshotOutputFolder(fileName);
+    const fullPageOption = fullPage || this.options.fullPageScreenshots
+    let outputFile = screenshotOutputFolder(fileName)
 
-    this.debug(`Screenshot is saving to ${outputFile}`);
+    this.debug(`Screenshot is saving to ${outputFile}`)
 
     await this.page.screenshot({
       path: outputFile,
       fullPage: fullPageOption,
       type: 'png',
-    });
+    })
 
     if (this.activeSessionName) {
       for (const sessionName in this.sessionPages) {
-        const activeSessionPage = this.sessionPages[sessionName];
-        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`);
+        const activeSessionPage = this.sessionPages[sessionName]
+        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`)
 
-        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`);
+        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`)
 
         if (activeSessionPage) {
           await activeSessionPage.screenshot({
             path: outputFile,
             fullPage: fullPageOption,
             type: 'png',
-          });
+          })
         }
       }
     }
@@ -2323,20 +2356,23 @@ class Playwright extends Helper {
    * @returns {Promise<object>} response
    */
   async makeApiRequest(method, url, options) {
-    method = method.toLowerCase();
-    const allowedMethods = ['get', 'post', 'patch', 'head', 'fetch', 'delete'];
+    method = method.toLowerCase()
+    const allowedMethods = ['get', 'post', 'patch', 'head', 'fetch', 'delete']
     if (!allowedMethods.includes(method)) {
-      throw new Error(`Method ${method} is not allowed, use the one from a list ${allowedMethods} or switch to using REST helper`);
+      throw new Error(
+        `Method ${method} is not allowed, use the one from a list ${allowedMethods} or switch to using REST helper`,
+      )
     }
 
-    if (url.startsWith('/')) { // local url
-      url = this.options.url + url;
-      this.debugSection('URL', url);
+    if (url.startsWith('/')) {
+      // local url
+      url = this.options.url + url
+      this.debugSection('URL', url)
     }
 
-    const response = await this.page.request[method](url, options);
-    this.debugSection('Status', response.status());
-    this.debugSection('Response', await response.text());
+    const response = await this.page.request[method](url, options)
+    this.debugSection('Status', response.status())
+    this.debugSection('Response', await response.text())
 
     // hook to allow JSON response handle this
     if (this.config.onResponse) {
@@ -2345,68 +2381,83 @@ class Playwright extends Helper {
         status: response.status(),
         statusText: response.statusText(),
         headers: response.headers(),
-      };
-      this.config.onResponse(axiosResponse);
+      }
+      this.config.onResponse(axiosResponse)
     }
 
-    return response;
+    return response
   }
 
   async _failed(test) {
-    await this._withinEnd();
+    await this._withinEnd()
 
     if (!test.artifacts) {
-      test.artifacts = {};
+      test.artifacts = {}
     }
 
     if (this.options.recordVideo && this.page && this.page.video()) {
-      test.artifacts.video = await saveVideoForPage(this.page, `${test.title}.failed`);
+      test.artifacts.video = await saveVideoForPage(this.page, `${test.title}.failed`)
       for (const sessionName in this.sessionPages) {
-        test.artifacts[`video_${sessionName}`] = await saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.failed`);
+        test.artifacts[`video_${sessionName}`] = await saveVideoForPage(
+          this.sessionPages[sessionName],
+          `${test.title}_${sessionName}.failed`,
+        )
       }
     }
 
     if (this.options.trace) {
-      test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.failed`);
+      test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.failed`)
       for (const sessionName in this.sessionPages) {
-        if (!this.sessionPages[sessionName].context) continue;
-        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.failed`);
+        if (!this.sessionPages[sessionName].context) continue
+        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(
+          this.sessionPages[sessionName].context,
+          `${test.title}_${sessionName}.failed`,
+        )
       }
     }
 
     if (this.options.recordHar) {
-      test.artifacts.har = this.currentRunningTest.artifacts.har;
+      test.artifacts.har = this.currentRunningTest.artifacts.har
     }
   }
 
   async _passed(test) {
     if (this.options.recordVideo && this.page && this.page.video()) {
       if (this.options.keepVideoForPassedTests) {
-        test.artifacts.video = await saveVideoForPage(this.page, `${test.title}.passed`);
+        test.artifacts.video = await saveVideoForPage(this.page, `${test.title}.passed`)
         for (const sessionName of Object.keys(this.sessionPages)) {
-          test.artifacts[`video_${sessionName}`] = await saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.passed`);
+          test.artifacts[`video_${sessionName}`] = await saveVideoForPage(
+            this.sessionPages[sessionName],
+            `${test.title}_${sessionName}.passed`,
+          )
         }
       } else {
-        this.page.video().delete().catch(e => {});
+        this.page
+          .video()
+          .delete()
+          .catch((e) => {})
       }
     }
 
     if (this.options.trace) {
       if (this.options.keepTraceForPassedTests) {
         if (this.options.trace) {
-          test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.passed`);
+          test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.passed`)
           for (const sessionName in this.sessionPages) {
-            if (!this.sessionPages[sessionName].context) continue;
-            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.passed`);
+            if (!this.sessionPages[sessionName].context) continue
+            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(
+              this.sessionPages[sessionName].context,
+              `${test.title}_${sessionName}.passed`,
+            )
           }
         }
       } else {
-        await this.browserContext.tracing.stop();
+        await this.browserContext.tracing.stop()
       }
     }
 
     if (this.options.recordHar) {
-      test.artifacts.har = this.currentRunningTest.artifacts.har;
+      test.artifacts.har = this.currentRunningTest.artifacts.har
     }
   }
 
@@ -2414,62 +2465,99 @@ class Playwright extends Helper {
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise(((done) => {
-      setTimeout(done, sec * 1000);
-    }));
+    return new Promise((done) => {
+      setTimeout(done, sec * 1000)
+    })
   }
 
   /**
    * {{> waitForEnabled }}
    */
   async waitForEnabled(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    const matcher = await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+
+    let waiter
+    const context = await this._getContext()
     if (!locator.isXPath()) {
       const valueFn = function ([locator]) {
-        return Array.from(document.querySelectorAll(locator)).filter(el => !el.disabled).length > 0;
-      };
-      waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout });
+        return Array.from(document.querySelectorAll(locator)).filter((el) => !el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout })
     } else {
       const enabledFn = function ([locator, $XPath]) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => !el.disabled).length > 0;
-      };
-      waiter = context.waitForFunction(enabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout });
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => !el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(enabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
+    }
+    return waiter.catch((err) => {
+      throw new Error(
+        `element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
+  }
+
+  /**
+   * {{> waitForDisabled }}
+   */
+  async waitForDisabled(locator, sec) {
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+
+    let waiter
+    const context = await this._getContext()
+    if (!locator.isXPath()) {
+      const valueFn = function ([locator]) {
+        return Array.from(document.querySelectorAll(locator)).filter((el) => el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout })
+    } else {
+      const disabledFn = function ([locator, $XPath]) {
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(disabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `element (${locator.toString()}) is still enabled after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForValue }}
    */
   async waitForValue(field, value, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const locator = new Locator(field, 'css');
-    const matcher = await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const locator = new Locator(field, 'css')
+    const matcher = await this.context
+    let waiter
+    const context = await this._getContext()
     if (!locator.isXPath()) {
       const valueFn = function ([locator, value]) {
-        return Array.from(document.querySelectorAll(locator)).filter(el => (el.value || '').indexOf(value) !== -1).length > 0;
-      };
-      waiter = context.waitForFunction(valueFn, [locator.value, value], { timeout: waitTimeout });
+        return (
+          Array.from(document.querySelectorAll(locator)).filter((el) => (el.value || '').indexOf(value) !== -1).length >
+          0
+        )
+      }
+      waiter = context.waitForFunction(valueFn, [locator.value, value], { timeout: waitTimeout })
     } else {
       const valueFn = function ([locator, $XPath, value]) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => (el.value || '').indexOf(value) !== -1).length > 0;
-      };
-      waiter = context.waitForFunction(valueFn, [locator.value, $XPath.toString(), value], { timeout: waitTimeout });
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => (el.value || '').indexOf(value) !== -1).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, [locator.value, $XPath.toString(), value], {
+        timeout: waitTimeout,
+      })
     }
     return waiter.catch((err) => {
-      const loc = locator.toString();
-      throw new Error(`element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      const loc = locator.toString()
+      throw new Error(
+        `element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
@@ -2477,38 +2565,44 @@ class Playwright extends Helper {
    *
    */
   async waitNumberOfVisibleElements(locator, num, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    let waiter;
-    const context = await this._getContext();
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
       const visibleFn = function ([locator, num]) {
-        const els = document.querySelectorAll(locator);
+        const els = document.querySelectorAll(locator)
         if (!els || els.length === 0) {
-          return false;
+          return false
         }
-        return Array.prototype.filter.call(els, el => el.offsetParent !== null).length === num;
-      };
-      waiter = context.waitForFunction(visibleFn, [locator.value, num], { timeout: waitTimeout });
+        return Array.prototype.filter.call(els, (el) => el.offsetParent !== null).length === num
+      }
+      waiter = context.waitForFunction(visibleFn, [locator.value, num], { timeout: waitTimeout })
     } else {
       const visibleFn = function ([locator, $XPath, num]) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => el.offsetParent !== null).length === num;
-      };
-      waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString(), num], { timeout: waitTimeout });
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => el.offsetParent !== null).length === num
+      }
+      waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString(), num], {
+        timeout: waitTimeout,
+      })
     }
     return waiter.catch((err) => {
-      throw new Error(`The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForClickable }}
    */
   async waitForClickable(locator, waitTimeout) {
-    console.log('I.waitForClickable is DEPRECATED: This is no longer needed, Playwright automatically waits for element to be clickable');
-    console.log('Remove usage of this function');
+    console.log(
+      'I.waitForClickable is DEPRECATED: This is no longer needed, Playwright automatically waits for element to be clickable',
+    )
+    console.log('Remove usage of this function')
   }
 
   /**
@@ -2516,14 +2610,16 @@ class Playwright extends Helper {
    *
    */
   async waitForElement(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    const context = await this._getContext();
+    const context = await this._getContext()
     try {
-      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'attached' });
+      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'attached' })
     } catch (e) {
-      throw new Error(`element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${e.message}`);
+      throw new Error(
+        `element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${e.message}`,
+      )
     }
   }
 
@@ -2533,28 +2629,28 @@ class Playwright extends Helper {
    * {{> waitForVisible }}
    */
   async waitForVisible(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    const context = await this._getContext();
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    const context = await this._getContext()
+    let count = 0
 
     // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
-    let waiter;
+    let waiter
     if (this.frame) {
       do {
-        waiter = await this.frame.locator(buildLocatorString(locator)).first().isVisible();
-        await this.wait(1);
-        count += 1000;
-        if (waiter) break;
-      } while (count <= waitTimeout);
+        waiter = await this.frame.locator(buildLocatorString(locator)).first().isVisible()
+        await this.wait(1)
+        count += 1000
+        if (waiter) break
+      } while (count <= waitTimeout)
 
-      if (!waiter) throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec.`);
+      if (!waiter) throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec.`)
     }
 
     try {
-      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'visible' });
+      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'visible' })
     } catch (e) {
-      throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${e.message}`);
+      throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${e.message}`)
     }
   }
 
@@ -2562,29 +2658,29 @@ class Playwright extends Helper {
    * {{> waitForInvisible }}
    */
   async waitForInvisible(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    const context = await this._getContext();
-    let waiter;
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    const context = await this._getContext()
+    let waiter
+    let count = 0
 
     // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
     if (this.frame) {
       do {
-        waiter = await this.frame.locator(buildLocatorString(locator)).first().isHidden();
-        await this.wait(1);
-        count += 1000;
-        if (waiter) break;
-      } while (count <= waitTimeout);
+        waiter = await this.frame.locator(buildLocatorString(locator)).first().isHidden()
+        await this.wait(1)
+        count += 1000
+        if (waiter) break
+      } while (count <= waitTimeout)
 
-      if (!waiter) throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec.`);
-      return;
+      if (!waiter) throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec.`)
+      return
     }
 
     try {
-      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'hidden' });
+      await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'hidden' })
     } catch (e) {
-      throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${e.message}`);
+      throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${e.message}`)
     }
   }
 
@@ -2592,143 +2688,168 @@ class Playwright extends Helper {
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    const context = await this._getContext();
-    let waiter;
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    const context = await this._getContext()
+    let waiter
+    let count = 0
 
     // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
     if (this.frame) {
       do {
-        waiter = await this.frame.locator(buildLocatorString(locator)).first().isHidden();
-        await this.wait(1);
-        count += 1000;
-        if (waiter) break;
-      } while (count <= waitTimeout);
+        waiter = await this.frame.locator(buildLocatorString(locator)).first().isHidden()
+        await this.wait(1)
+        count += 1000
+        if (waiter) break
+      } while (count <= waitTimeout)
 
-      if (!waiter) throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec.`);
-      return;
+      if (!waiter) throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec.`)
+      return
     }
 
-    return context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'hidden' }).catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+    return context
+      .locator(buildLocatorString(locator))
+      .first()
+      .waitFor({ timeout: waitTimeout, state: 'hidden' })
+      .catch((err) => {
+        throw new Error(
+          `element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`,
+        )
+      })
   }
 
   /**
    * {{> waitForNumberOfTabs }}
    */
   async waitForNumberOfTabs(expectedTabs, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    let currentTabs;
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    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.`)
   }
 
   async _getContext() {
     if (this.context && this.context.constructor.name === 'FrameLocator') {
-      return this.context;
+      return this.context
     }
-    return this.page;
+    return this.page
   }
 
   /**
    * {{> waitInUrl }}
    */
   async waitInUrl(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-
-    return this.page.waitForFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl.indexOf(urlPart) > -1;
-    }, urlPart, { timeout: waitTimeout }).catch(async (e) => {
-      const currUrl = await this._getPageUrl(); // Required because the waitForFunction can't return data.
-      if (/Timeout/i.test(e.message)) {
-        throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
-      } else {
-        throw e;
-      }
-    });
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+
+    return this.page
+      .waitForFunction(
+        (urlPart) => {
+          const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+          return currUrl.indexOf(urlPart) > -1
+        },
+        urlPart,
+        { timeout: waitTimeout },
+      )
+      .catch(async (e) => {
+        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        if (/Timeout/i.test(e.message)) {
+          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+        } else {
+          throw e
+        }
+      })
   }
 
   /**
    * {{> waitUrlEquals }}
    */
   async waitUrlEquals(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    const baseUrl = this.options.url;
+    const baseUrl = this.options.url
     if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart;
-    }
-
-    return this.page.waitForFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl.indexOf(urlPart) > -1;
-    }, urlPart, { timeout: waitTimeout }).catch(async (e) => {
-      const currUrl = await this._getPageUrl(); // Required because the waitForFunction can't return data.
-      if (/Timeout/i.test(e.message)) {
-        throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`);
-      } else {
-        throw e;
-      }
-    });
+      urlPart = baseUrl + urlPart
+    }
+
+    return this.page
+      .waitForFunction(
+        (urlPart) => {
+          const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+          return currUrl.indexOf(urlPart) > -1
+        },
+        urlPart,
+        { timeout: waitTimeout },
+      )
+      .catch(async (e) => {
+        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        if (/Timeout/i.test(e.message)) {
+          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+        } else {
+          throw e
+        }
+      })
   }
 
   /**
    * {{> waitForText }}
    */
   async waitForText(text, sec = null, context = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const errorMessage = `Text "${text}" was not found on page after ${waitTimeout / 1000} sec.`;
-    let waiter;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const errorMessage = `Text "${text}" was not found on page after ${waitTimeout / 1000} sec.`
+    let waiter
 
-    const contextObject = await this._getContext();
+    const contextObject = await this._getContext()
 
     if (context) {
-      const locator = new Locator(context, 'css');
+      const locator = new Locator(context, 'css')
       if (!locator.isXPath()) {
         try {
-          await contextObject.locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`).first().waitFor({ timeout: waitTimeout, state: 'visible' });
+          await contextObject
+            .locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`)
+            .first()
+            .waitFor({ timeout: waitTimeout, state: 'visible' })
         } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`);
+          throw new Error(`${errorMessage}\n${e.message}`)
         }
       }
 
       if (locator.isXPath()) {
         try {
-          await contextObject.waitForFunction(([locator, text, $XPath]) => {
-            eval($XPath); // eslint-disable-line no-eval
-            const el = $XPath(null, locator);
-            if (!el.length) return false;
-            return el[0].innerText.indexOf(text) > -1;
-          }, [locator.value, text, $XPath.toString()], { timeout: waitTimeout });
+          await contextObject.waitForFunction(
+            ([locator, text, $XPath]) => {
+              eval($XPath) // eslint-disable-line no-eval
+              const el = $XPath(null, locator)
+              if (!el.length) return false
+              return el[0].innerText.indexOf(text) > -1
+            },
+            [locator.value, text, $XPath.toString()],
+            { timeout: waitTimeout },
+          )
         } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`);
+          throw new Error(`${errorMessage}\n${e.message}`)
         }
       }
     } else {
       // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
       // eslint-disable-next-line no-lonely-if
-      const _contextObject = this.frame ? this.frame : contextObject;
-      let count = 0;
+      const _contextObject = this.frame ? this.frame : contextObject
+      let count = 0
       do {
-        waiter = await _contextObject.locator(`:has-text("${text}")`).first().isVisible();
-        if (waiter) break;
-        await this.wait(1);
-        count += 1000;
-      } while (count <= waitTimeout);
+        waiter = await _contextObject.locator(`:has-text("${text}")`).first().isVisible()
+        if (waiter) break
+        await this.wait(1)
+        count += 1000
+      } while (count <= waitTimeout)
 
-      if (!waiter) throw new Error(`${errorMessage}`);
+      if (!waiter) throw new Error(`${errorMessage}`)
     }
   }
 
@@ -2744,8 +2865,8 @@ class Playwright extends Helper {
    * @param {?number} [sec=null] seconds to wait
    */
   async waitForRequest(urlOrPredicate, sec = null) {
-    const timeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.page.waitForRequest(urlOrPredicate, { timeout });
+    const timeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.page.waitForRequest(urlOrPredicate, { timeout })
   }
 
   /**
@@ -2760,8 +2881,8 @@ class Playwright extends Helper {
    * @param {?number} [sec=null] number of seconds to wait
    */
   async waitForResponse(urlOrPredicate, sec = null) {
-    const timeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.page.waitForResponse(urlOrPredicate, { timeout });
+    const timeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.page.waitForResponse(urlOrPredicate, { timeout })
   }
 
   /**
@@ -2771,51 +2892,51 @@ class Playwright extends Helper {
     if (Number.isInteger(locator)) {
       // Select by frame index of current context
 
-      let childFrames = null;
+      let childFrames = null
       if (this.context && typeof this.context.childFrames === 'function') {
-        childFrames = this.context.childFrames();
+        childFrames = this.context.childFrames()
       } else {
-        childFrames = this.page.mainFrame().childFrames();
+        childFrames = this.page.mainFrame().childFrames()
       }
 
       if (locator >= 0 && locator < childFrames.length) {
-        this.context = await this.page.frameLocator('iframe').nth(locator);
-        this.contextLocator = locator;
+        this.context = await this.page.frameLocator('iframe').nth(locator)
+        this.contextLocator = locator
       } else {
-        throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath');
+        throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath')
       }
-      return;
+      return
     }
 
     if (!locator) {
-      this.context = this.page;
-      this.contextLocator = null;
-      this.frame = null;
-      return;
+      this.context = this.page
+      this.contextLocator = null
+      this.frame = null
+      return
     }
 
     // iframe by selector
-    locator = buildLocatorString(new Locator(locator, 'css'));
-    const frame = await this._locateElement(locator);
+    locator = buildLocatorString(new Locator(locator, 'css'))
+    const frame = await this._locateElement(locator)
 
     if (!frame) {
-      throw new Error(`Frame ${JSON.stringify(locator)} was not found by text|CSS|XPath`);
+      throw new Error(`Frame ${JSON.stringify(locator)} was not found by text|CSS|XPath`)
     }
 
     if (this.frame) {
-      this.frame = await this.frame.frameLocator(locator);
+      this.frame = await this.frame.frameLocator(locator)
     } else {
-      this.frame = await this.page.frameLocator(locator);
+      this.frame = await this.page.frameLocator(locator)
     }
 
-    const contentFrame = this.frame;
+    const contentFrame = this.frame
 
     if (contentFrame) {
-      this.context = contentFrame;
-      this.contextLocator = null;
+      this.context = contentFrame
+      this.contextLocator = null
     } else {
-      this.context = this.page.frame(this.page.frames()[1].name());
-      this.contextLocator = locator;
+      this.context = this.page.frame(this.page.frames()[1].name())
+      this.contextLocator = locator
     }
   }
 
@@ -2823,17 +2944,17 @@ class Playwright extends Helper {
    * {{> 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 waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const context = await this._getContext();
-    return context.waitForFunction(fn, args, { timeout: waitTimeout });
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const context = await this._getContext()
+    return context.waitForFunction(fn, args, { timeout: waitTimeout })
   }
 
   /**
@@ -2845,13 +2966,13 @@ class Playwright extends Helper {
    */
   async waitForNavigation(options = {}) {
     console.log(`waitForNavigation deprecated:
-    * This method is inherently racy, please use 'waitForURL' instead.`);
+    * This method is inherently racy, please use 'waitForURL' instead.`)
     options = {
       timeout: this.options.getPageTimeout,
       waitUntil: this.options.waitForNavigation,
       ...options,
-    };
-    return this.page.waitForNavigation(options);
+    }
+    return this.page.waitForNavigation(options)
   }
 
   /**
@@ -2867,41 +2988,44 @@ class Playwright extends Helper {
       timeout: this.options.getPageTimeout,
       waitUntil: this.options.waitForNavigation,
       ...options,
-    };
-    return this.page.waitForURL(url, options);
+    }
+    return this.page.waitForURL(url, options)
   }
 
   async waitUntilExists(locator, sec) {
     console.log(`waitUntilExists deprecated:
     * use 'waitForElement' to wait for element to be attached
-    * use 'waitForDetached to wait for element to be removed'`);
-    return this.waitForDetached(locator, sec);
+    * use 'waitForDetached to wait for element to be removed'`)
+    return this.waitForDetached(locator, sec)
   }
 
   /**
    * {{> waitForDetached }}
    */
   async waitForDetached(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    let waiter;
-    const context = await this._getContext();
+    let waiter
+    const context = await this._getContext()
     if (!locator.isXPath()) {
       try {
-        await context.locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()}`).first().waitFor({ timeout: waitTimeout, state: 'detached' });
+        await context
+          .locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()}`)
+          .first()
+          .waitFor({ timeout: waitTimeout, state: 'detached' })
       } catch (e) {
-        throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${e.message}`);
+        throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${e.message}`)
       }
     } else {
       const visibleFn = function ([locator, $XPath]) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).length === 0;
-      };
-      waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString()], { timeout: waitTimeout });
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).length === 0
+      }
+      waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
       return waiter.catch((err) => {
-        throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${err.message}`);
-      });
+        throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${err.message}`)
+      })
     }
   }
 
@@ -2910,53 +3034,56 @@ class Playwright extends Helper {
    */
   async waitForCookie(name, sec) {
     // by default, we will retry 3 times
-    let retries = 3;
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    let retries = 3
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
     if (sec) {
-      retries = sec;
+      retries = sec
     } else {
-      retries = Math.ceil(waitTimeout / 1000) - 1;
+      retries = Math.ceil(waitTimeout / 1000) - 1
     }
 
-    return promiseRetry(async (retry, number) => {
-      const _grabCookie = async (name) => {
-        const cookies = await this.browserContext.cookies();
-        const cookie = cookies.filter(c => c.name === 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 cookies = await this.browserContext.cookies()
+          const cookie = cookies.filter((c) => c.name === 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 },
+    )
   }
 
   async _waitForAction() {
-    return this.wait(this.options.waitForAction / 1000);
+    return this.wait(this.options.waitForAction / 1000)
   }
 
   /**
    * {{> grabDataFromPerformanceTiming }}
    */
   async grabDataFromPerformanceTiming() {
-    return perfTiming;
+    return perfTiming
   }
 
   /**
    * {{> grabElementBoundingRect }}
    */
   async grabElementBoundingRect(locator, prop) {
-    const el = await this._locateElement(locator);
-    assertElementExists(el, locator);
-    const rect = await el.boundingBox();
-    if (prop) return rect[prop];
-    return rect;
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator)
+    const rect = await el.boundingBox()
+    if (prop) return rect[prop]
+    return rect
   }
 
   /**
@@ -2971,7 +3098,7 @@ class Playwright extends Helper {
    * @param {function} [handler] a function to process request
    */
   async mockRoute(url, handler) {
-    return this.browserContext.route(...arguments);
+    return this.browserContext.route(...arguments)
   }
 
   /**
@@ -2987,7 +3114,7 @@ class Playwright extends Helper {
    * @param {function} [handler] a function to process request
    */
   async stopMockingRoute(url, handler) {
-    return this.browserContext.unroute(...arguments);
+    return this.browserContext.unroute(...arguments)
   }
 
   /**
@@ -2995,9 +3122,9 @@ class Playwright extends Helper {
    *
    */
   startRecordingTraffic() {
-    this.flushNetworkTraffics();
-    this.recording = true;
-    this.recordedAtLeastOnce = true;
+    this.flushNetworkTraffics()
+    this.recording = true
+    this.recordedAtLeastOnce = true
 
     this.page.on('requestfinished', async (request) => {
       const information = {
@@ -3006,16 +3133,16 @@ class Playwright extends Helper {
         requestHeaders: request.headers(),
         requestPostData: request.postData(),
         response: request.response(),
-      };
+      }
 
-      this.debugSection('REQUEST: ', JSON.stringify(information));
+      this.debugSection('REQUEST: ', JSON.stringify(information))
 
       if (typeof information.requestPostData === 'object') {
-        information.requestPostData = JSON.parse(information.requestPostData);
+        information.requestPostData = JSON.parse(information.requestPostData)
       }
 
-      this.requests.push(information);
-    });
+      this.requests.push(information)
+    })
   }
 
   /**
@@ -3038,21 +3165,21 @@ class Playwright extends Helper {
    */
   blockTraffic(urls) {
     if (Array.isArray(urls)) {
-      urls.forEach(url => {
+      urls.forEach((url) => {
         this.page.route(url, (route) => {
           route
             .abort()
             // Sometimes it happens that browser has been closed in the meantime. It is ok to ignore error then.
-            .catch((e) => {});
-        });
-      });
+            .catch((e) => {})
+        })
+      })
     } else {
       this.page.route(urls, (route) => {
         route
           .abort()
           // Sometimes it happens that browser has been closed in the meantime. It is ok to ignore error then.
-          .catch((e) => {});
-      });
+          .catch((e) => {})
+      })
     }
   }
 
@@ -3074,10 +3201,10 @@ class Playwright extends Helper {
    */
   mockTraffic(urls, responseString, contentType = 'application/json') {
     // Required to mock cross-domain requests
-    const headers = { 'access-control-allow-origin': '*' };
+    const headers = { 'access-control-allow-origin': '*' }
 
     if (typeof urls === 'string') {
-      urls = [urls];
+      urls = [urls]
     }
 
     urls.forEach((url) => {
@@ -3085,15 +3212,15 @@ class Playwright extends Helper {
         if (this.page.isClosed()) {
           // Sometimes it happens that browser has been closed in the meantime.
           // In this case we just don't fulfill to prevent error in test scenario.
-          return;
+          return
         }
         route.fulfill({
           contentType,
           headers,
           body: responseString,
-        });
-      });
-    });
+        })
+      })
+    })
   }
 
   /**
@@ -3101,7 +3228,7 @@ class Playwright extends Helper {
    * {{> flushNetworkTraffics }}
    */
   flushNetworkTraffics() {
-    flushNetworkTraffics.call(this);
+    flushNetworkTraffics.call(this)
   }
 
   /**
@@ -3109,7 +3236,7 @@ class Playwright extends Helper {
    * {{> stopRecordingTraffic }}
    */
   stopRecordingTraffic() {
-    stopRecordingTraffic.call(this);
+    stopRecordingTraffic.call(this)
   }
 
   /**
@@ -3127,21 +3254,23 @@ class Playwright extends Helper {
    */
   grabTrafficUrl(urlMatch) {
     if (!this.recordedAtLeastOnce) {
-      throw new Error('Failure in test automation. You use "I.grabTrafficUrl", but "I.startRecordingTraffic" was never called before.');
+      throw new Error(
+        'Failure in test automation. You use "I.grabTrafficUrl", but "I.startRecordingTraffic" was never called before.',
+      )
     }
 
     for (const i in this.requests) {
       // eslint-disable-next-line no-prototype-builtins
       if (this.requests.hasOwnProperty(i)) {
-        const request = this.requests[i];
+        const request = this.requests[i]
 
         if (request.url && request.url.match(new RegExp(urlMatch))) {
-          return request.url;
+          return request.url
         }
       }
     }
 
-    assert.fail(`Method "getTrafficUrl" failed: No request found in traffic that matches ${urlMatch}`);
+    assert.fail(`Method "getTrafficUrl" failed: No request found in traffic that matches ${urlMatch}`)
   }
 
   /**
@@ -3149,17 +3278,15 @@ class Playwright extends Helper {
    * {{> grabRecordedNetworkTraffics }}
    */
   async grabRecordedNetworkTraffics() {
-    return grabRecordedNetworkTraffics.call(this);
+    return grabRecordedNetworkTraffics.call(this)
   }
 
   /**
    *
    * {{> seeTraffic }}
    */
-  async seeTraffic({
-    name, url, parameters, requestPostData, timeout = 10,
-  }) {
-    await seeTraffic.call(this, ...arguments);
+  async seeTraffic({ name, url, parameters, requestPostData, timeout = 10 }) {
+    await seeTraffic.call(this, ...arguments)
   }
 
   /**
@@ -3168,51 +3295,42 @@ class Playwright extends Helper {
    *
    */
   dontSeeTraffic({ name, url }) {
-    dontSeeTraffic.call(this, ...arguments);
+    dontSeeTraffic.call(this, ...arguments)
   }
 
   /**
    * {{> startRecordingWebSocketMessages }}
    */
   async startRecordingWebSocketMessages() {
-    this.flushWebSocketMessages();
-    this.recordingWebSocketMessages = true;
-    this.recordedWebSocketMessagesAtLeastOnce = true;
-
-    this.cdpSession = await this.getNewCDPSession();
-    await this.cdpSession.send('Network.enable');
-    await this.cdpSession.send('Page.enable');
-
-    this.cdpSession.on(
-      'Network.webSocketFrameReceived',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload));
-      },
-    );
+    this.flushWebSocketMessages()
+    this.recordingWebSocketMessages = true
+    this.recordedWebSocketMessagesAtLeastOnce = true
 
-    this.cdpSession.on(
-      'Network.webSocketFrameSent',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('SENT', payload));
-      },
-    );
+    this.cdpSession = await this.getNewCDPSession()
+    await this.cdpSession.send('Network.enable')
+    await this.cdpSession.send('Page.enable')
 
-    this.cdpSession.on(
-      'Network.webSocketFrameError',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload));
-      },
-    );
+    this.cdpSession.on('Network.webSocketFrameReceived', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload))
+    })
+
+    this.cdpSession.on('Network.webSocketFrameSent', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('SENT', payload))
+    })
+
+    this.cdpSession.on('Network.webSocketFrameError', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload))
+    })
   }
 
   /**
    * {{> stopRecordingWebSocketMessages }}
    */
   async stopRecordingWebSocketMessages() {
-    await this.cdpSession.send('Network.disable');
-    await this.cdpSession.send('Page.disable');
-    this.page.removeAllListeners('Network');
-    this.recordingWebSocketMessages = false;
+    await this.cdpSession.send('Network.disable')
+    await this.cdpSession.send('Page.disable')
+    this.page.removeAllListeners('Network')
+    this.recordingWebSocketMessages = false
   }
 
   /**
@@ -3224,17 +3342,19 @@ class Playwright extends Helper {
   grabWebSocketMessages() {
     if (!this.recordingWebSocketMessages) {
       if (!this.recordedWebSocketMessagesAtLeastOnce) {
-        throw new Error('Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.');
+        throw new Error(
+          'Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.',
+        )
       }
     }
-    return this.webSocketMessages;
+    return this.webSocketMessages
   }
 
   /**
    * Resets all recorded WS messages.
    */
   flushWebSocketMessages() {
-    this.webSocketMessages = [];
+    this.webSocketMessages = []
   }
 
   /**
@@ -3292,431 +3412,444 @@ class Playwright extends Helper {
    * @return {Promise<Array<Object>>}
    */
   async grabMetrics() {
-    const client = await this.page.context().newCDPSession(this.page);
-    await client.send('Performance.enable');
-    const perfMetricObject = await client.send('Performance.getMetrics');
-    return perfMetricObject?.metrics;
+    const client = await this.page.context().newCDPSession(this.page)
+    await client.send('Performance.enable')
+    const perfMetricObject = await client.send('Performance.getMetrics')
+    return perfMetricObject?.metrics
   }
 
   _getWebSocketMessage(payload) {
     if (payload.errorMessage) {
-      return payload.errorMessage;
+      return payload.errorMessage
     }
 
-    return payload.response.payloadData;
+    return payload.response.payloadData
   }
 
   _getWebSocketLog(prefix, payload) {
-    return `${prefix} ID: ${payload.requestId} TIMESTAMP: ${payload.timestamp} (${new Date().toISOString()})\n\n${this._getWebSocketMessage(payload)}\n\n`;
+    return `${prefix} ID: ${payload.requestId} TIMESTAMP: ${payload.timestamp} (${new Date().toISOString()})\n\n${this._getWebSocketMessage(payload)}\n\n`
   }
 
   async getNewCDPSession() {
-    return this.page.context().newCDPSession(this.page);
+    return this.page.context().newCDPSession(this.page)
   }
 
   _logWebsocketMessages(message) {
-    this.webSocketMessages += message;
+    this.webSocketMessages += message
   }
 }
 
-module.exports = Playwright;
+module.exports = Playwright
 
 function buildLocatorString(locator) {
   if (locator.isCustom()) {
-    return `${locator.type}=${locator.value}`;
-  } if (locator.isXPath()) {
-    return `xpath=${locator.value}`;
+    return `${locator.type}=${locator.value}`
+  }
+  if (locator.isXPath()) {
+    return `xpath=${locator.value}`
   }
-  return locator.simplify();
+  return locator.simplify()
 }
 
 async function findElements(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator);
-  if (locator.vue) return findVue(matcher, locator);
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator);
-  locator = new Locator(locator, 'css');
+  if (locator.react) return findReact(matcher, locator)
+  if (locator.vue) return findVue(matcher, locator)
+  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
+  locator = new Locator(locator, 'css')
 
-  return matcher.locator(buildLocatorString(locator)).all();
+  return matcher.locator(buildLocatorString(locator)).all()
 }
 
 async function findElement(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator);
-  if (locator.vue) return findVue(matcher, locator);
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator);
-  locator = new Locator(locator, 'css');
+  if (locator.react) return findReact(matcher, locator)
+  if (locator.vue) return findVue(matcher, locator)
+  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
+  locator = new Locator(locator, 'css')
 
-  return matcher.locator(buildLocatorString(locator)).first();
+  return matcher.locator(buildLocatorString(locator)).first()
 }
 
 async function getVisibleElements(elements) {
-  const visibleElements = [];
+  const visibleElements = []
   for (const element of elements) {
     if (await element.isVisible()) {
-      visibleElements.push(element);
+      visibleElements.push(element)
     }
   }
   if (visibleElements.length === 0) {
-    return elements;
+    return elements
   }
-  return visibleElements;
+  return visibleElements
 }
 
 async function proceedClick(locator, context = null, options = {}) {
-  let matcher = await this._getContext();
+  let matcher = await this._getContext()
   if (context) {
-    const els = await this._locate(context);
-    assertElementExists(els, context);
-    matcher = els[0];
+    const els = await this._locate(context)
+    assertElementExists(els, context)
+    matcher = els[0]
   }
-  const els = await findClickable.call(this, matcher, locator);
+  const els = await findClickable.call(this, matcher, locator)
   if (context) {
-    assertElementExists(els, locator, 'Clickable element', `was not found inside element ${new Locator(context).toString()}`);
+    assertElementExists(
+      els,
+      locator,
+      'Clickable element',
+      `was not found inside element ${new Locator(context).toString()}`,
+    )
   } else {
-    assertElementExists(els, locator, 'Clickable element');
+    assertElementExists(els, locator, 'Clickable element')
   }
 
-  await highlightActiveElement.call(this, els[0]);
+  await highlightActiveElement.call(this, els[0])
 
   /*
     using the force true options itself but instead dispatching a click
   */
   if (options.force) {
-    await els[0].dispatchEvent('click');
+    await els[0].dispatchEvent('click')
   } else {
-    const element = els.length > 1 ? (await getVisibleElements(els))[0] : els[0];
-    await element.click(options);
+    const element = els.length > 1 ? (await getVisibleElements(els))[0] : els[0]
+    await element.click(options)
   }
-  const promises = [];
+  const promises = []
   if (options.waitForNavigation) {
-    promises.push(this.waitForURL(/.*/, { waitUntil: options.waitForNavigation }));
+    promises.push(this.waitForURL(/.*/, { waitUntil: options.waitForNavigation }))
   }
-  promises.push(this._waitForAction());
+  promises.push(this._waitForAction())
 
-  return Promise.all(promises);
+  return Promise.all(promises)
 }
 
 async function findClickable(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator);
-  if (locator.vue) return findVue(matcher, locator);
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator);
+  if (locator.react) return findReact(matcher, locator)
+  if (locator.vue) return findVue(matcher, locator)
+  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
 
-  locator = new Locator(locator);
-  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator);
+  locator = new Locator(locator)
+  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator)
 
-  let els;
-  const literal = xpathLocator.literal(locator.value);
+  let els
+  const literal = xpathLocator.literal(locator.value)
 
-  els = await findElements.call(this, matcher, Locator.clickable.narrow(literal));
-  if (els.length) return els;
+  els = await findElements.call(this, matcher, Locator.clickable.narrow(literal))
+  if (els.length) return els
 
-  els = await findElements.call(this, matcher, Locator.clickable.wide(literal));
-  if (els.length) return els;
+  els = await findElements.call(this, matcher, Locator.clickable.wide(literal))
+  if (els.length) return els
 
   try {
-    els = await findElements.call(this, matcher, Locator.clickable.self(literal));
-    if (els.length) return els;
+    els = await findElements.call(this, matcher, Locator.clickable.self(literal))
+    if (els.length) return els
   } catch (err) {
     // Do nothing
   }
 
-  return findElements.call(this, matcher, locator.value); // by css or xpath
+  return findElements.call(this, matcher, locator.value) // by css or xpath
 }
 
 async function proceedSee(assertType, text, context, strict = false) {
-  let description;
-  let allText;
+  let description
+  let allText
 
   if (!context) {
-    const el = await this.context;
+    const el = await this.context
 
-    allText = el.constructor.name !== 'Locator' ? [await el.locator('body').innerText()] : [await el.innerText()];
+    allText = el.constructor.name !== 'Locator' ? [await el.locator('body').innerText()] : [await el.innerText()]
 
-    description = 'web application';
+    description = 'web application'
   } else {
-    const locator = new Locator(context, 'css');
-    description = `element ${locator.toString()}`;
-    const els = await this._locate(locator);
-    assertElementExists(els, locator.toString());
-    allText = await Promise.all(els.map(el => el.innerText()));
+    const locator = new Locator(context, 'css')
+    description = `element ${locator.toString()}`
+    const els = await this._locate(locator)
+    assertElementExists(els, locator.toString())
+    allText = await Promise.all(els.map((el) => el.innerText()))
   }
 
   if (strict) {
-    return allText.map(elText => equals(description)[assertType](text, elText));
+    return allText.map((elText) => equals(description)[assertType](text, elText))
   }
-  return stringIncludes(description)[assertType](normalizeSpacesInString(text), normalizeSpacesInString(allText.join(' | ')));
+  return stringIncludes(description)[assertType](
+    normalizeSpacesInString(text),
+    normalizeSpacesInString(allText.join(' | ')),
+  )
 }
 
 async function findCheckable(locator, context) {
-  let contextEl = await this.context;
+  let contextEl = await this.context
   if (typeof context === 'string') {
-    contextEl = await findElements.call(this, contextEl, (new Locator(context, 'css')).simplify());
-    contextEl = contextEl[0];
+    contextEl = await findElements.call(this, contextEl, new Locator(context, 'css').simplify())
+    contextEl = contextEl[0]
   }
 
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return findElements.call(this, contextEl, matchedLocator.simplify());
+    return findElements.call(this, contextEl, matchedLocator.simplify())
   }
 
-  const literal = xpathLocator.literal(locator);
-  let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal));
+  const literal = xpathLocator.literal(locator)
+  let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
   if (els.length) {
-    return els;
+    return els
   }
-  els = await findElements.call(this, contextEl, Locator.checkable.byName(literal));
+  els = await findElements.call(this, contextEl, Locator.checkable.byName(literal))
   if (els.length) {
-    return els;
+    return els
   }
-  return findElements.call(this, contextEl, locator);
+  return findElements.call(this, contextEl, locator)
 }
 
 async function proceedIsChecked(assertType, option) {
-  let els = await findCheckable.call(this, option);
-  assertElementExists(els, option, 'Checkable');
-  els = await Promise.all(els.map(el => el.isChecked()));
-  const selected = els.reduce((prev, cur) => prev || cur);
-  return truth(`checkable ${option}`, 'to be checked')[assertType](selected);
+  let els = await findCheckable.call(this, option)
+  assertElementExists(els, option, 'Checkable')
+  els = await Promise.all(els.map((el) => el.isChecked()))
+  const selected = els.reduce((prev, cur) => prev || cur)
+  return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
 async function findFields(locator) {
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this._locate(matchedLocator);
+    return this._locate(matchedLocator)
   }
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) });
+  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) })
   if (els.length) {
-    return els;
+    return els
   }
 
-  els = await this._locate({ xpath: Locator.field.labelContains(literal) });
+  els = await this._locate({ xpath: Locator.field.labelContains(literal) })
   if (els.length) {
-    return els;
+    return els
   }
-  els = await this._locate({ xpath: Locator.field.byName(literal) });
+  els = await this._locate({ xpath: Locator.field.byName(literal) })
   if (els.length) {
-    return els;
+    return els
   }
-  return this._locate({ css: locator });
+  return this._locate({ css: locator })
 }
 
 async function proceedSeeInField(assertType, field, value) {
-  const els = await findFields.call(this, field);
-  assertElementExists(els, field, 'Field');
-  const el = els[0];
-  const tag = await el.evaluate(e => e.tagName);
-  const fieldType = await el.getAttribute('type');
+  const els = await findFields.call(this, field)
+  assertElementExists(els, field, 'Field')
+  const el = els[0]
+  const tag = await el.evaluate((e) => e.tagName)
+  const fieldType = await el.getAttribute('type')
 
   const proceedMultiple = async (elements) => {
-    const fields = Array.isArray(elements) ? elements : [elements];
+    const fields = Array.isArray(elements) ? elements : [elements]
 
-    const elementValues = [];
+    const elementValues = []
     for (const element of fields) {
-      elementValues.push(await element.inputValue());
+      elementValues.push(await element.inputValue())
     }
 
     if (typeof value === 'boolean') {
-      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!elementValues.length);
+      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!elementValues.length)
     } else {
       if (assertType === 'assert') {
-        equals(`select option by ${field}`)[assertType](true, elementValues.length > 0);
+        equals(`select option by ${field}`)[assertType](true, elementValues.length > 0)
       }
-      elementValues.forEach(val => stringIncludes(`fields by ${field}`)[assertType](value, val));
+      elementValues.forEach((val) => stringIncludes(`fields by ${field}`)[assertType](value, val))
     }
-  };
+  }
 
   if (tag === 'SELECT') {
     if (await el.getAttribute('multiple')) {
-      const selectedOptions = await el.all('option:checked');
-      if (!selectedOptions.length) return null;
+      const selectedOptions = await el.all('option:checked')
+      if (!selectedOptions.length) return null
 
-      const options = await filterFieldsByValue(selectedOptions, value, true);
-      return proceedMultiple(options);
+      const options = await filterFieldsByValue(selectedOptions, value, true)
+      return proceedMultiple(options)
     }
 
-    return el.inputValue();
+    return el.inputValue()
   }
 
   if (tag === 'INPUT') {
     if (fieldType === 'checkbox' || fieldType === 'radio') {
       if (typeof value === 'boolean') {
         // Filter by values
-        const options = await filterFieldsBySelectionState(els, true);
-        return proceedMultiple(options);
+        const options = await filterFieldsBySelectionState(els, true)
+        return proceedMultiple(options)
       }
 
-      const options = await filterFieldsByValue(els, value, true);
-      return proceedMultiple(options);
+      const options = await filterFieldsByValue(els, value, true)
+      return proceedMultiple(options)
     }
-    return proceedMultiple(els[0]);
+    return proceedMultiple(els[0])
   }
 
-  let fieldVal;
+  let fieldVal
 
   try {
-    fieldVal = await el.inputValue();
+    fieldVal = await el.inputValue()
   } catch (e) {
     if (e.message.includes('Error: Node is not an <input>, <textarea> or <select> element')) {
-      fieldVal = await el.innerText();
+      fieldVal = await el.innerText()
     }
   }
 
-  return stringIncludes(`fields by ${field}`)[assertType](value, fieldVal);
+  return stringIncludes(`fields by ${field}`)[assertType](value, fieldVal)
 }
 
 async function filterFieldsByValue(elements, value, onlySelected) {
-  const matches = [];
+  const matches = []
   for (const element of elements) {
-    const val = await element.getAttribute('value');
-    let isSelected = true;
+    const val = await element.getAttribute('value')
+    let isSelected = true
     if (onlySelected) {
-      isSelected = await elementSelected(element);
+      isSelected = await elementSelected(element)
     }
     if ((value == null || val.indexOf(value) > -1) && isSelected) {
-      matches.push(element);
+      matches.push(element)
     }
   }
-  return matches;
+  return matches
 }
 
 async function filterFieldsBySelectionState(elements, state) {
-  const matches = [];
+  const matches = []
   for (const element of elements) {
-    const isSelected = await elementSelected(element);
+    const isSelected = await elementSelected(element)
     if (isSelected === state) {
-      matches.push(element);
+      matches.push(element)
     }
   }
-  return matches;
+  return matches
 }
 
 async function elementSelected(element) {
-  const type = await element.getAttribute('type');
+  const type = await element.getAttribute('type')
 
   if (type === 'checkbox' || type === 'radio') {
-    return element.isChecked();
+    return element.isChecked()
   }
-  return element.getAttribute('selected');
+  return element.getAttribute('selected')
 }
 
 function isFrameLocator(locator) {
-  locator = new Locator(locator);
+  locator = new Locator(locator)
   if (locator.isFrame()) {
-    return locator.value;
+    return locator.value
   }
-  return false;
+  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 $XPath(element, selector) {
-  const found = document.evaluate(selector, element || document.body, null, 5, null);
-  const res = [];
-  let current = null;
-  while (current = found.iterateNext()) {
-    res.push(current);
+  const found = document.evaluate(selector, element || document.body, null, 5, null)
+  const res = []
+  let current = null
+  while ((current = found.iterateNext())) {
+    res.push(current)
   }
-  return res;
+  return res
 }
 
 async function targetCreatedHandler(page) {
-  if (!page) return;
-  this.withinLocator = null;
+  if (!page) return
+  this.withinLocator = null
   page.on('load', () => {
-    page.$('body')
+    page
+      .$('body')
       .catch(() => null)
       .then(async () => {
         if (this.context && this.context._type === 'Frame') {
           // we are inside iframe?
-          const frameEl = await this.context.frameElement();
-          this.context = await frameEl.contentFrame();
-          this.contextLocator = null;
-          return;
+          const frameEl = await this.context.frameElement()
+          this.context = await frameEl.contentFrame()
+          this.contextLocator = null
+          return
         }
         // if context element was in iframe - keep it
         // if (await this.context.ownerFrame()) return;
-        this.context = page;
-        this.contextLocator = null;
-      });
-  });
+        this.context = page
+        this.contextLocator = null
+      })
+  })
   page.on('console', (msg) => {
     if (!consoleLogStore.includes(msg) && this.options.ignoreLog && !this.options.ignoreLog.includes(msg.type())) {
-      this.debugSection(`Browser:${ucfirst(msg.type())}`, (msg.text && msg.text() || msg._text || '') + msg.args().join(' '));
+      this.debugSection(
+        `Browser:${ucfirst(msg.type())}`,
+        ((msg.text && msg.text()) || msg._text || '') + msg.args().join(' '),
+      )
     }
-    consoleLogStore.add(msg);
-  });
+    consoleLogStore.add(msg)
+  })
 
   if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0 && this._getType() === 'Browser') {
     try {
-      await page.setViewportSize(parseWindowSize(this.options.windowSize));
+      await page.setViewportSize(parseWindowSize(this.options.windowSize))
     } catch (err) {
-      this.debug('Target can be already closed, ignoring...');
+      this.debug('Target can be already closed, ignoring...')
     }
   }
 }
 
 function parseWindowSize(windowSize) {
-  if (!windowSize) return { width: 800, height: 600 };
+  if (!windowSize) return { width: 800, height: 600 }
 
   if (windowSize.width && windowSize.height) {
-    return { width: parseInt(windowSize.width, 10), height: parseInt(windowSize.height, 10) };
+    return { width: parseInt(windowSize.width, 10), height: parseInt(windowSize.height, 10) }
   }
 
-  const dimensions = windowSize.split('x');
+  const dimensions = windowSize.split('x')
   if (dimensions.length < 2 || windowSize === 'maximize') {
-    console.log('Invalid window size, setting window to default values');
-    return { width: 800, height: 600 }; // invalid size
+    console.log('Invalid window size, setting window to default values')
+    return { width: 800, height: 600 } // invalid size
   }
-  const width = parseInt(dimensions[0], 10);
-  const height = parseInt(dimensions[1], 10);
-  return { width, height };
+  const width = parseInt(dimensions[0], 10)
+  const height = parseInt(dimensions[1], 10)
+  return { width, height }
 }
 
 // List of key values to key definitions
 // https://github.com/puppeteer/puppeteer/blob/v1.20.0/lib/USKeyboardLayout.js
 const keyDefinitionMap = {
   /* eslint-disable quote-props */
-  '0': 'Digit0',
-  '1': 'Digit1',
-  '2': 'Digit2',
-  '3': 'Digit3',
-  '4': 'Digit4',
-  '5': 'Digit5',
-  '6': 'Digit6',
-  '7': 'Digit7',
-  '8': 'Digit8',
-  '9': 'Digit9',
-  'a': 'KeyA',
-  'b': 'KeyB',
-  'c': 'KeyC',
-  'd': 'KeyD',
-  'e': 'KeyE',
-  'f': 'KeyF',
-  'g': 'KeyG',
-  'h': 'KeyH',
-  'i': 'KeyI',
-  'j': 'KeyJ',
-  'k': 'KeyK',
-  'l': 'KeyL',
-  'm': 'KeyM',
-  'n': 'KeyN',
-  'o': 'KeyO',
-  'p': 'KeyP',
-  'q': 'KeyQ',
-  'r': 'KeyR',
-  's': 'KeyS',
-  't': 'KeyT',
-  'u': 'KeyU',
-  'v': 'KeyV',
-  'w': 'KeyW',
-  'x': 'KeyX',
-  'y': 'KeyY',
-  'z': 'KeyZ',
+  0: 'Digit0',
+  1: 'Digit1',
+  2: 'Digit2',
+  3: 'Digit3',
+  4: 'Digit4',
+  5: 'Digit5',
+  6: 'Digit6',
+  7: 'Digit7',
+  8: 'Digit8',
+  9: 'Digit9',
+  a: 'KeyA',
+  b: 'KeyB',
+  c: 'KeyC',
+  d: 'KeyD',
+  e: 'KeyE',
+  f: 'KeyF',
+  g: 'KeyG',
+  h: 'KeyH',
+  i: 'KeyI',
+  j: 'KeyJ',
+  k: 'KeyK',
+  l: 'KeyL',
+  m: 'KeyM',
+  n: 'KeyN',
+  o: 'KeyO',
+  p: 'KeyP',
+  q: 'KeyQ',
+  r: 'KeyR',
+  s: 'KeyS',
+  t: 'KeyT',
+  u: 'KeyU',
+  v: 'KeyV',
+  w: 'KeyW',
+  x: 'KeyX',
+  y: 'KeyY',
+  z: 'KeyZ',
   ';': 'Semicolon',
   '=': 'Equal',
   ',': 'Comma',
@@ -3727,89 +3860,93 @@ const keyDefinitionMap = {
   '[': 'BracketLeft',
   '\\': 'Backslash',
   ']': 'BracketRight',
-  '\'': 'Quote',
+  "'": 'Quote',
   /* eslint-enable quote-props */
-};
+}
 
 function getNormalizedKey(key) {
-  const normalizedKey = getNormalizedKeyAttributeValue(key);
+  const normalizedKey = getNormalizedKeyAttributeValue(key)
   if (key !== normalizedKey) {
-    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`);
+    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`)
   }
   // Use key definition to ensure correct key is displayed when Shift modifier is active
   if (Object.prototype.hasOwnProperty.call(keyDefinitionMap, normalizedKey)) {
-    return keyDefinitionMap[normalizedKey];
+    return keyDefinitionMap[normalizedKey]
   }
-  return normalizedKey;
+  return normalizedKey
 }
 
 async function clickablePoint(el) {
-  const rect = await el.boundingBox();
-  if (!rect) throw new ElementNotFound(el);
-  const {
-    x, y, width, height,
-  } = rect;
-  return { x: x + width / 2, y: y + height / 2 };
+  const rect = await el.boundingBox()
+  if (!rect) throw new ElementNotFound(el)
+  const { x, y, width, height } = rect
+  return { x: x + width / 2, y: y + height / 2 }
 }
 
 async function refreshContextSession() {
   // close other sessions
   try {
-    const contexts = await this.browser.contexts();
-    contexts.shift();
+    const contexts = await this.browser.contexts()
+    contexts.shift()
 
-    await Promise.all(contexts.map(c => c.close()));
+    await Promise.all(contexts.map((c) => c.close()))
   } catch (e) {
-    console.log(e);
+    console.log(e)
   }
 
   if (this.page) {
-    const existingPages = await this.browserContext.pages();
-    await this._setPage(existingPages[0]);
+    const existingPages = await this.browserContext.pages()
+    await this._setPage(existingPages[0])
   }
 
-  if (this.options.keepBrowserState) return;
+  if (this.options.keepBrowserState) return
 
   if (!this.options.keepCookies) {
-    this.debugSection('Session', 'cleaning cookies and localStorage');
-    await this.clearCookie();
+    this.debugSection('Session', 'cleaning cookies and localStorage')
+    await this.clearCookie()
   }
-  const currentUrl = await this.grabCurrentUrl();
+  const currentUrl = await this.grabCurrentUrl()
 
   if (currentUrl.startsWith('http')) {
     await this.executeScript('localStorage.clear();').catch((err) => {
-      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-    });
+      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+    })
     await this.executeScript('sessionStorage.clear();').catch((err) => {
-      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-    });
+      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+    })
   }
 }
 
 async function saveVideoForPage(page, name) {
-  if (!page.video()) return null;
-  const fileName = `${`${global.output_dir}${pathSeparator}videos${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.webm`;
-  page.video().saveAs(fileName).then(() => {
-    if (!page) return;
-    page.video().delete().catch(e => {});
-  });
-  return fileName;
+  if (!page.video()) return null
+  const fileName = `${`${global.output_dir}${pathSeparator}videos${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.webm`
+  page
+    .video()
+    .saveAs(fileName)
+    .then(() => {
+      if (!page) return
+      page
+        .video()
+        .delete()
+        .catch((e) => {})
+    })
+  return fileName
 }
 
 async function saveTraceForContext(context, name) {
-  if (!context) return;
-  if (!context.tracing) return;
-  const fileName = `${`${global.output_dir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`;
-  await context.tracing.stop({ path: fileName });
-  return fileName;
+  if (!context) return
+  if (!context.tracing) return
+  const fileName = `${`${global.output_dir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`
+  await context.tracing.stop({ path: fileName })
+  return fileName
 }
 
 async function highlightActiveElement(element) {
   if (this.options.highlightElement && global.debugMode) {
-    await element.evaluate(el => {
-      const prevStyle = el.style.boxShadow;
-      el.style.boxShadow = '0px 0px 4px 3px rgba(255, 0, 0, 0.7)';
-      setTimeout(() => el.style.boxShadow = prevStyle, 2000);
-    });
+    await element.evaluate((el) => {
+      const prevStyle = el.style.boxShadow
+      el.style.boxShadow = '0px 0px 4px 3px rgba(255, 0, 0, 0.7)'
+      setTimeout(() => (el.style.boxShadow = prevStyle), 2000)
+    })
   }
 }
diff --git a/lib/helper/Protractor.js b/lib/helper/Protractor.js
index 1d2a42d26..9b785d33e 100644
--- a/lib/helper/Protractor.js
+++ b/lib/helper/Protractor.js
@@ -1,32 +1,24 @@
-let EC;
-let Key;
-let Button;
-let ProtractorBy;
-let ProtractorExpectedConditions;
-
-const path = require('path');
-
-const Helper = require('@codeceptjs/helper');
-const stringIncludes = require('../assert/include').includes;
-const { urlEquals, equals } = require('../assert/equal');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
-const {
-  xpathLocator,
-  fileExists,
-  convertCssPropertiesToCamelCase,
-  screenshotOutputFolder,
-} = require('../utils');
-const {
-  isColorProperty,
-  convertColorToRGBA,
-} = require('../colorUtils');
-const ElementNotFound = require('./errors/ElementNotFound');
-const ConnectionRefused = require('./errors/ConnectionRefused');
-const Locator = require('../locator');
-
-let withinStore = {};
-let Runner;
+let EC
+let Key
+let Button
+let ProtractorBy
+let ProtractorExpectedConditions
+
+const path = require('path')
+
+const Helper = require('@codeceptjs/helper')
+const stringIncludes = require('../assert/include').includes
+const { urlEquals, equals } = require('../assert/equal')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
+const { xpathLocator, fileExists, convertCssPropertiesToCamelCase, screenshotOutputFolder } = require('../utils')
+const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
+const ElementNotFound = require('./errors/ElementNotFound')
+const ConnectionRefused = require('./errors/ConnectionRefused')
+const Locator = require('../locator')
+
+let withinStore = {}
+let Runner
 
 /**
  * Protractor helper is based on [Protractor library](http://www.protractortest.org) and used for testing web applications.
@@ -120,12 +112,14 @@ let Runner;
 class Protractor extends Helper {
   constructor(config) {
     // process.env.SELENIUM_PROMISE_MANAGER = false; // eslint-disable-line
-    super(config);
+    super(config)
 
-    this.isRunning = false;
-    this._setConfig(config);
+    this.isRunning = false
+    this._setConfig(config)
 
-    console.log('Protractor helper is deprecated as well as Protractor itself.\nThis helper will be removed in next major release');
+    console.log(
+      'Protractor helper is deprecated as well as Protractor itself.\nThis helper will be removed in next major release',
+    )
   }
 
   _validateConfig(config) {
@@ -144,206 +138,213 @@ class Protractor extends Helper {
       capabilities: {},
       angular: true,
       restart: true,
-    };
+    }
 
-    config = Object.assign(defaults, config);
+    config = Object.assign(defaults, config)
 
-    if (!config.allScriptsTimeout) config.allScriptsTimeout = config.scriptsTimeout;
-    if (!config.scriptTimeout) config.scriptTimeout = config.scriptsTimeout;
-    if (config.proxy) config.capabilities.proxy = config.proxy;
-    if (config.browser) config.capabilities.browserName = config.browser;
+    if (!config.allScriptsTimeout) config.allScriptsTimeout = config.scriptsTimeout
+    if (!config.scriptTimeout) config.scriptTimeout = config.scriptsTimeout
+    if (config.proxy) config.capabilities.proxy = config.proxy
+    if (config.browser) config.capabilities.browserName = config.browser
 
-    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000; // convert to seconds
-    return config;
+    config.waitForTimeoutInSeconds = config.waitForTimeout / 1000 // convert to seconds
+    return config
   }
 
   async _init() {
     process.on('unhandledRejection', (reason) => {
       if (reason.message.indexOf('ECONNREFUSED') > 0) {
-        this.browser = null;
+        this.browser = null
       }
-    });
+    })
 
-    Runner = require('protractor/built/runner').Runner;
-    ProtractorBy = require('protractor').ProtractorBy;
-    Key = require('protractor').Key;
-    Button = require('protractor').Button;
-    ProtractorExpectedConditions = require('protractor').ProtractorExpectedConditions;
+    Runner = require('protractor/built/runner').Runner
+    ProtractorBy = require('protractor').ProtractorBy
+    Key = require('protractor').Key
+    Button = require('protractor').Button
+    ProtractorExpectedConditions = require('protractor').ProtractorExpectedConditions
 
-    return Promise.resolve();
+    return Promise.resolve()
   }
 
   static _checkRequirements() {
     try {
-      require('protractor');
-      require('assert').ok(require('protractor/built/runner').Runner);
+      require('protractor')
+      require('assert').ok(require('protractor/built/runner').Runner)
     } catch (e) {
-      return ['protractor@^5.3.0'];
+      return ['protractor@^5.3.0']
     }
   }
 
   static _config() {
     return [
       { name: 'url', message: 'Base url of site to be tested', default: 'http://localhost' },
-      { name: 'driver', message: 'Protractor driver (local, direct, session, hosted, sauce, browserstack)', default: 'hosted' },
+      {
+        name: 'driver',
+        message: 'Protractor driver (local, direct, session, hosted, sauce, browserstack)',
+        default: 'hosted',
+      },
       { name: 'browser', message: 'Browser in which testing will be performed', default: 'chrome' },
       { name: 'rootElement', message: 'Root element of AngularJS application', default: 'body' },
       {
-        name: 'angular', message: 'Enable AngularJS synchronization', default: false, type: 'confirm',
+        name: 'angular',
+        message: 'Enable AngularJS synchronization',
+        default: false,
+        type: 'confirm',
       },
-
-    ];
+    ]
   }
 
   async _beforeStep() {
     if (!this.insideAngular) {
-      return this.amOutsideAngularApp();
+      return this.amOutsideAngularApp()
     }
   }
 
   async _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()
     }
   }
 
   async _startBrowser() {
     try {
-      const runner = new Runner(this.options);
-      this.browser = runner.createBrowser();
-      await this.browser.ready;
+      const runner = new Runner(this.options)
+      this.browser = runner.createBrowser()
+      await this.browser.ready
     } catch (err) {
       if (err.toString().indexOf('ECONNREFUSED')) {
-        throw new ConnectionRefused(err);
+        throw new ConnectionRefused(err)
       }
-      throw err;
+      throw err
     }
     if (this.options.angular) {
-      await this.amInsideAngularApp();
+      await this.amInsideAngularApp()
     } else {
-      await this.amOutsideAngularApp();
+      await this.amOutsideAngularApp()
     }
 
-    loadGlobals(this.browser);
+    loadGlobals(this.browser)
 
     if (this.options.windowSize === 'maximize') {
-      await this.resizeWindow(this.options.windowSize);
+      await this.resizeWindow(this.options.windowSize)
     } else if (this.options.windowSize) {
-      const size = this.options.windowSize.split('x');
-      await this.resizeWindow(parseInt(size[0], 10), parseInt(size[1], 10));
+      const size = this.options.windowSize.split('x')
+      await this.resizeWindow(parseInt(size[0], 10), parseInt(size[1], 10))
     }
-    this.context = this.options.rootElement;
-    this.isRunning = true;
-    return this.browser.ready;
+    this.context = this.options.rootElement
+    this.isRunning = true
+    return this.browser.ready
   }
 
   async _before() {
-    if (this.options.restart && !this.options.manualStart) return this._startBrowser();
-    if (!this.isRunning && !this.options.manualStart) return this._startBrowser();
+    if (this.options.restart && !this.options.manualStart) return this._startBrowser()
+    if (!this.isRunning && !this.options.manualStart) return this._startBrowser()
   }
 
   async _after() {
-    if (!this.browser) return;
-    if (!this.isRunning) return;
+    if (!this.browser) return
+    if (!this.isRunning) return
     if (this.options.restart) {
-      this.isRunning = false;
-      return this.browser.quit();
+      this.isRunning = false
+      return this.browser.quit()
     }
-    if (this.options.keepBrowserState) return;
+    if (this.options.keepBrowserState) return
 
-    const dialog = await this.grabPopupText();
+    const dialog = await this.grabPopupText()
     if (dialog) {
-      await this.cancelPopup();
+      await this.cancelPopup()
     }
     if (!this.options.keepCookies) {
-      await this.browser.manage().deleteAllCookies();
+      await this.browser.manage().deleteAllCookies()
     }
-    let url;
+    let url
     try {
-      url = await this.browser.getCurrentUrl();
+      url = await this.browser.getCurrentUrl()
     } catch (err) {
       // Ignore, as above will throw if no webpage has been loaded
     }
     if (url && !/data:,/i.test(url)) {
-      await this.browser.executeScript('localStorage.clear();');
+      await this.browser.executeScript('localStorage.clear();')
     }
-    return this.closeOtherTabs();
+    return this.closeOtherTabs()
   }
 
   async _failed() {
-    await this._withinEnd();
+    await this._withinEnd()
   }
 
   async _finishTest() {
-    if (!this.options.restart && this.isRunning) return this.browser.quit();
+    if (!this.options.restart && this.isRunning) return this.browser.quit()
   }
 
   async _withinBegin(locator) {
-    withinStore.elFn = this.browser.findElement;
-    withinStore.elsFn = this.browser.findElements;
+    withinStore.elFn = this.browser.findElement
+    withinStore.elsFn = this.browser.findElements
 
-    const frame = isFrameLocator(locator);
+    const frame = isFrameLocator(locator)
 
     if (frame) {
       if (Array.isArray(frame)) {
-        withinStore.frame = frame.join('>');
-        return this.switchTo(null)
-          .then(() => frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve()));
+        withinStore.frame = frame.join('>')
+        return this.switchTo(null).then(() =>
+          frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve()),
+        )
       }
-      withinStore.frame = frame;
-      return this.switchTo(locator);
+      withinStore.frame = frame
+      return this.switchTo(locator)
     }
 
-    this.context = locator;
-    const context = await global.element(guessLocator(locator) || global.by.css(locator));
-    if (!context) throw new ElementNotFound(locator);
+    this.context = locator
+    const context = await global.element(guessLocator(locator) || global.by.css(locator))
+    if (!context) throw new ElementNotFound(locator)
 
-    this.browser.findElement = l => (l ? context.element(l).getWebElement() : context.getWebElement());
-    this.browser.findElements = l => context.all(l).getWebElements();
-    return context;
+    this.browser.findElement = (l) => (l ? context.element(l).getWebElement() : context.getWebElement())
+    this.browser.findElements = (l) => context.all(l).getWebElements()
+    return context
   }
 
   async _withinEnd() {
-    if (!isWithin()) return;
+    if (!isWithin()) return
     if (withinStore.frame) {
-      withinStore = {};
-      return this.switchTo(null);
+      withinStore = {}
+      return this.switchTo(null)
     }
-    this.browser.findElement = withinStore.elFn;
-    this.browser.findElements = withinStore.elsFn;
-    withinStore = {};
-    this.context = this.options.rootElement;
+    this.browser.findElement = withinStore.elFn
+    this.browser.findElements = withinStore.elsFn
+    withinStore = {}
+    this.context = this.options.rootElement
   }
 
   _session() {
-    const defaultSession = this.browser;
+    const defaultSession = this.browser
     return {
       start: async (opts) => {
-        opts = this._validateConfig(Object.assign(this.options, opts));
-        this.debugSection('New Browser', JSON.stringify(opts));
-        const runner = new Runner(opts);
-        const res = await this.browser.executeScript('return [window.outerWidth, window.outerHeight]');
-        const browser = runner.createBrowser(null, this.browser);
-        await browser.ready;
-        await browser.waitForAngularEnabled(this.insideAngular);
-        await browser.manage().window().setSize(parseInt(res[0], 10), parseInt(res[1], 10));
-        return browser.ready;
+        opts = this._validateConfig(Object.assign(this.options, opts))
+        this.debugSection('New Browser', JSON.stringify(opts))
+        const runner = new Runner(opts)
+        const res = await this.browser.executeScript('return [window.outerWidth, window.outerHeight]')
+        const browser = runner.createBrowser(null, this.browser)
+        await browser.ready
+        await browser.waitForAngularEnabled(this.insideAngular)
+        await browser.manage().window().setSize(parseInt(res[0], 10), parseInt(res[1], 10))
+        return browser.ready
       },
       stop: async (browser) => {
-        return browser.close();
+        return browser.close()
       },
       loadVars: async (browser) => {
-        if (isWithin()) throw new Error('Can\'t start session inside within block');
-        this.browser = browser;
-        loadGlobals(this.browser);
+        if (isWithin()) throw new Error("Can't start session inside within block")
+        this.browser = browser
+        loadGlobals(this.browser)
       },
       restoreVars: async () => {
-        if (isWithin()) await this._withinEnd();
-        this.browser = defaultSession;
-        loadGlobals(this.browser);
+        if (isWithin()) await this._withinEnd()
+        this.browser = defaultSession
+        loadGlobals(this.browser)
       },
-    };
+    }
   }
 
   /**
@@ -364,7 +365,7 @@ class Protractor extends Helper {
    * @param {function} fn async functuion that executed with Protractor helper as argument
    */
   useProtractorTo(description, fn) {
-    return this._useTo(...arguments);
+    return this._useTo(...arguments)
   }
 
   /**
@@ -372,9 +373,9 @@ class Protractor extends Helper {
    * start using WebDriver instead of Protractor in this session
    */
   async amOutsideAngularApp() {
-    if (!this.browser) return;
-    await this.browser.waitForAngularEnabled(false);
-    return Promise.resolve(this.insideAngular = false);
+    if (!this.browser) return
+    await this.browser.waitForAngularEnabled(false)
+    return Promise.resolve((this.insideAngular = false))
   }
 
   /**
@@ -382,8 +383,8 @@ class Protractor extends Helper {
    * Should be used after "amOutsideAngularApp"
    */
   async amInsideAngularApp() {
-    await this.browser.waitForAngularEnabled(true);
-    return Promise.resolve(this.insideAngular = true);
+    await this.browser.waitForAngularEnabled(true)
+    return Promise.resolve((this.insideAngular = true))
   }
 
   /**
@@ -401,15 +402,15 @@ class Protractor extends Helper {
    *
    */
   async _locate(locator, smartWait = false) {
-    return this._smartWait(() => this.browser.findElements(guessLocator(locator) || global.by.css(locator)), smartWait);
+    return this._smartWait(() => this.browser.findElements(guessLocator(locator) || global.by.css(locator)), smartWait)
   }
 
   async _smartWait(fn, enabled = true) {
-    if (!this.options.smartWait || !enabled) return fn();
-    await this.browser.manage().timeouts().implicitlyWait(this.options.smartWait);
-    const res = await fn();
-    await this.browser.manage().timeouts().implicitlyWait(0);
-    return res;
+    if (!this.options.smartWait || !enabled) return fn()
+    await this.browser.manage().timeouts().implicitlyWait(this.options.smartWait)
+    const res = await fn()
+    await this.browser.manage().timeouts().implicitlyWait(0)
+    return res
   }
 
   /**
@@ -420,7 +421,7 @@ class Protractor extends Helper {
    * ```
    */
   async _locateCheckable(locator) {
-    return findCheckable.call(this, this.browser, locator);
+    return findCheckable.call(this, this.browser, locator)
   }
 
   /**
@@ -431,7 +432,7 @@ class Protractor extends Helper {
    * ```
    */
   async _locateClickable(locator) {
-    return findClickable.call(this, this.browser, locator);
+    return findClickable.call(this, this.browser, locator)
   }
 
   /**
@@ -442,47 +443,47 @@ class Protractor extends Helper {
    * ```
    */
   async _locateFields(locator) {
-    return findFields.call(this, this.browser, locator);
+    return findFields.call(this, this.browser, locator)
   }
 
   /**
    * {{> amOnPage }}
    */
   async amOnPage(url) {
-    if (!(/^\w+\:\/\//.test(url))) {
-      url = this.options.url + url;
+    if (!/^\w+\:\/\//.test(url)) {
+      url = this.options.url + url
     }
-    const res = await this.browser.get(url);
-    this.debug(`Visited ${url}`);
-    return res;
+    const res = await this.browser.get(url)
+    this.debug(`Visited ${url}`)
+    return res
   }
 
   /**
    * {{> click }}
    */
   async click(locator, context = null) {
-    let matcher = this.browser;
+    let matcher = this.browser
     if (context) {
-      const els = await this._locate(context, true);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context, true)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
-    const el = await findClickable.call(this, matcher, locator);
-    return el.click();
+    const el = await findClickable.call(this, matcher, locator)
+    return el.click()
   }
 
   /**
    * {{> doubleClick }}
    */
   async doubleClick(locator, context = null) {
-    let matcher = this.browser;
+    let matcher = this.browser
     if (context) {
-      const els = await this._locate(context, true);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context, true)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
-    const el = await findClickable.call(this, matcher, locator);
-    return this.browser.actions().doubleClick(el).perform();
+    const el = await findClickable.call(this, matcher, locator)
+    return this.browser.actions().doubleClick(el).perform()
   }
 
   /**
@@ -493,98 +494,98 @@ class Protractor extends Helper {
      * just press button if no selector is given
      */
     if (locator === undefined) {
-      return this.browser.actions().click(Button.RIGHT).perform();
+      return this.browser.actions().click(Button.RIGHT).perform()
     }
-    let matcher = this.browser;
+    let matcher = this.browser
     if (context) {
-      const els = await this._locate(context, true);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context, true)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
-    const el = await findClickable.call(this, matcher, locator);
+    const el = await findClickable.call(this, matcher, locator)
 
-    await this.browser.actions().mouseMove(el).perform();
-    return this.browser.actions().click(Button.RIGHT).perform();
+    await this.browser.actions().mouseMove(el).perform()
+    return this.browser.actions().click(Button.RIGHT).perform()
   }
 
   /**
    * {{> moveCursorTo }}
    */
   async moveCursorTo(locator, offsetX = null, offsetY = null) {
-    let offset = null;
+    let offset = null
     if (offsetX !== null || offsetY !== null) {
-      offset = { x: offsetX, y: offsetY };
+      offset = { x: offsetX, y: offsetY }
     }
-    const els = await this._locate(locator, true);
-    assertElementExists(els, locator);
-    return this.browser.actions().mouseMove(els[0], offset).perform();
+    const els = await this._locate(locator, true)
+    assertElementExists(els, locator)
+    return this.browser.actions().mouseMove(els[0], offset).perform()
   }
 
   /**
    * {{> see }}
    */
   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)
   }
 
   /**
    * {{> dontSee }}
    */
   dontSee(text, context = null) {
-    return proceedSee.call(this, 'negate', text, context);
+    return proceedSee.call(this, 'negate', text, context)
   }
 
   /**
    * {{> grabBrowserLogs }}
    */
   async grabBrowserLogs() {
-    return this.browser.manage().logs().get('browser');
+    return this.browser.manage().logs().get('browser')
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    return this.browser.getCurrentUrl();
+    return this.browser.getCurrentUrl()
   }
 
   /**
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const fields = await findFields(this.browser, select);
-    assertElementExists(fields, select, 'Selectable field');
+    const fields = await findFields(this.browser, select)
+    assertElementExists(fields, select, 'Selectable field')
     if (!Array.isArray(option)) {
-      option = [option];
+      option = [option]
     }
-    const field = fields[0];
-    const promises = [];
+    const field = fields[0]
+    const promises = []
     for (const key in option) {
-      const opt = xpathLocator.literal(option[key]);
-      let els = await field.findElements(global.by.xpath(Locator.select.byVisibleText(opt)));
+      const opt = xpathLocator.literal(option[key])
+      let els = await field.findElements(global.by.xpath(Locator.select.byVisibleText(opt)))
       if (!els.length) {
-        els = await field.findElements(global.by.xpath(Locator.select.byValue(opt)));
+        els = await field.findElements(global.by.xpath(Locator.select.byValue(opt)))
       }
-      els.forEach(el => promises.push(el.click()));
+      els.forEach((el) => promises.push(el.click()))
     }
 
-    return Promise.all(promises);
+    return Promise.all(promises)
   }
 
   /**
    * {{> fillField }}
    */
   async fillField(field, value) {
-    const els = await findFields(this.browser, field);
-    await els[0].clear();
-    return els[0].sendKeys(value.toString());
+    const els = await findFields(this.browser, field)
+    await els[0].clear()
+    return els[0].sendKeys(value.toString())
   }
 
   /**
@@ -592,266 +593,269 @@ class Protractor extends Helper {
    * {{ keys }}
    */
   async pressKey(key) {
-    let modifier;
-    if (Array.isArray(key) && ~['Control', 'Command', 'Shift', 'Alt'].indexOf(key[0])) { // eslint-disable-line no-bitwise
-      modifier = Key[key[0].toUpperCase()];
-      key = key[1];
+    let modifier
+    if (Array.isArray(key) && ~['Control', 'Command', 'Shift', 'Alt'].indexOf(key[0])) {
+      // eslint-disable-line no-bitwise
+      modifier = Key[key[0].toUpperCase()]
+      key = key[1]
     }
 
     // guess special key in Selenium Webdriver list
     if (Key[key.toUpperCase()]) {
-      key = Key[key.toUpperCase()];
+      key = Key[key.toUpperCase()]
     }
 
-    const action = this.browser.actions();
-    if (modifier) action.keyDown(modifier);
-    action.sendKeys(key);
-    if (modifier) action.keyUp(modifier);
-    return action.perform();
+    const action = this.browser.actions()
+    if (modifier) action.keyDown(modifier)
+    action.sendKeys(key)
+    if (modifier) action.keyUp(modifier)
+    return action.perform()
   }
 
   /**
    * {{> attachFile }}
    */
   async attachFile(locator, pathToFile) {
-    const file = path.join(global.codecept_dir, pathToFile);
+    const 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 els = await findFields(this.browser, locator);
-    assertElementExists(els, locator, 'Field');
+    const els = await findFields(this.browser, locator)
+    assertElementExists(els, locator, 'Field')
     if (this.options.browser !== 'phantomjs') {
-      const remote = require('selenium-webdriver/remote');
-      this.browser.setFileDetector(new remote.FileDetector());
+      const remote = require('selenium-webdriver/remote')
+      this.browser.setFileDetector(new remote.FileDetector())
     }
-    return els[0].sendKeys(file);
+    return els[0].sendKeys(file)
   }
 
   /**
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'assert', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'assert', field, _value)
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'negate', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'negate', field, _value)
   }
 
   /**
    * {{> appendField }}
    */
   async appendField(field, value) {
-    const els = await findFields(this.browser, field);
-    assertElementExists(els, field, 'Field');
-    return els[0].sendKeys(value.toString());
+    const els = await findFields(this.browser, field)
+    assertElementExists(els, field, 'Field')
+    return els[0].sendKeys(value.toString())
   }
 
   /**
    * {{> clearField }}
    */
   async clearField(field) {
-    const els = await findFields(this.browser, field);
-    assertElementExists(els, field, 'Field');
-    return els[0].clear();
+    const els = await findFields(this.browser, field)
+    assertElementExists(els, field, 'Field')
+    return els[0].clear()
   }
 
   /**
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    let matcher = this.browser;
+    let matcher = this.browser
     if (context) {
-      const els = await this._locate(context, true);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context, true)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
-    const els = await findCheckable(matcher, field);
-    assertElementExists(els, field, 'Checkbox or radio');
-    const isSelected = await els[0].isSelected();
-    if (!isSelected) return els[0].click();
+    const els = await findCheckable(matcher, field)
+    assertElementExists(els, field, 'Checkbox or radio')
+    const isSelected = await els[0].isSelected()
+    if (!isSelected) return els[0].click()
   }
 
   /**
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    let matcher = this.browser;
+    let matcher = this.browser
     if (context) {
-      const els = await this._locate(context, true);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context, true)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
-    const els = await findCheckable(matcher, field);
-    assertElementExists(els, field, 'Checkbox or radio');
-    const isSelected = await els[0].isSelected();
-    if (isSelected) return els[0].click();
+    const els = await findCheckable(matcher, field)
+    assertElementExists(els, field, 'Checkbox or radio')
+    const isSelected = await els[0].isSelected()
+    if (isSelected) return els[0].click()
   }
 
   /**
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'assert', field);
+    return proceedIsChecked.call(this, 'assert', field)
   }
 
   /**
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'negate', field);
+    return proceedIsChecked.call(this, 'negate', field)
   }
 
   /**
    * {{> grabTextFromAll }}
    */
   async grabTextFromAll(locator) {
-    const els = await this._locate(locator);
-    const texts = [];
+    const els = await this._locate(locator)
+    const texts = []
     for (const el of els) {
-      texts.push(await el.getText());
+      texts.push(await el.getText())
     }
-    return texts;
+    return texts
   }
 
   /**
    * {{> grabTextFrom }}
    */
   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]
   }
 
   /**
    * {{> grabHTMLFromAll }}
    */
   async grabHTMLFromAll(locator) {
-    const els = await this._locate(locator);
+    const els = await this._locate(locator)
 
-    const html = await Promise.all(els.map((el) => {
-      return this.browser.executeScript('return arguments[0].innerHTML;', el);
-    }));
+    const html = await Promise.all(
+      els.map((el) => {
+        return this.browser.executeScript('return arguments[0].innerHTML;', el)
+      }),
+    )
 
-    return html;
+    return html
   }
 
   /**
    * {{> grabHTMLFrom }}
    */
   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]
   }
 
   /**
    * {{> grabValueFromAll }}
    */
   async grabValueFromAll(locator) {
-    const els = await findFields(this.browser, locator);
-    const values = await Promise.all(els.map(el => el.getAttribute('value')));
+    const els = await findFields(this.browser, locator)
+    const values = await Promise.all(els.map((el) => el.getAttribute('value')))
 
-    return values;
+    return values
   }
 
   /**
    * {{> grabValueFrom }}
    */
   async grabValueFrom(locator) {
-    const values = await this.grabValueFromAll(locator);
-    assertElementExists(values, locator, 'Field');
+    const values = await this.grabValueFromAll(locator)
+    assertElementExists(values, locator, 'Field')
     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 els = await this._locate(locator, true);
-    const values = await Promise.all(els.map(el => el.getCssValue(cssProperty)));
+    const els = await this._locate(locator, true)
+    const values = await Promise.all(els.map((el) => el.getCssValue(cssProperty)))
 
-    return values;
+    return values
   }
 
   /**
    * {{> 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 els = await this._locate(locator);
-    const array = [];
+    const els = await this._locate(locator)
+    const array = []
 
     for (let index = 0; index < els.length; index++) {
-      const el = els[index];
-      array.push(await el.getAttribute(attr));
+      const el = els[index]
+      array.push(await el.getAttribute(attr))
     }
-    return array;
+    return array
   }
 
   /**
    * {{> 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) {
-    return this.browser.getTitle().then(title => stringIncludes('web page title').assert(text, title));
+    return this.browser.getTitle().then((title) => stringIncludes('web page title').assert(text, title))
   }
 
   /**
    * {{> seeTitleEquals }}
    */
   async seeTitleEquals(text) {
-    const title = await this.browser.getTitle();
-    return equals('web page title').assert(title, text);
+    const title = await this.browser.getTitle()
+    return equals('web page title').assert(title, text)
   }
 
   /**
    * {{> dontSeeInTitle }}
    */
   async dontSeeInTitle(text) {
-    return this.browser.getTitle().then(title => stringIncludes('web page title').negate(text, title));
+    return this.browser.getTitle().then((title) => stringIncludes('web page title').negate(text, title))
   }
 
   /**
@@ -859,188 +863,202 @@ class Protractor extends Helper {
    */
   async grabTitle() {
     return this.browser.getTitle().then((title) => {
-      this.debugSection('Title', title);
-      return title;
-    });
+      this.debugSection('Title', title)
+      return title
+    })
   }
 
   /**
    * {{> seeElement }}
    */
   async seeElement(locator) {
-    let els = await this._locate(locator, true);
-    els = await Promise.all(els.map(el => el.isDisplayed()));
-    return empty('elements').negate(els.filter(v => v).fill('ELEMENT'));
+    let els = await this._locate(locator, true)
+    els = await Promise.all(els.map((el) => el.isDisplayed()))
+    return empty('elements').negate(els.filter((v) => v).fill('ELEMENT'))
   }
 
   /**
    * {{> dontSeeElement }}
    */
   async dontSeeElement(locator) {
-    let els = await this._locate(locator, false);
-    els = await Promise.all(els.map(el => el.isDisplayed()));
-    return empty('elements').assert(els.filter(v => v).fill('ELEMENT'));
+    let els = await this._locate(locator, false)
+    els = await Promise.all(els.map((el) => el.isDisplayed()))
+    return empty('elements').assert(els.filter((v) => v).fill('ELEMENT'))
   }
 
   /**
    * {{> seeElementInDOM }}
    */
   async seeElementInDOM(locator) {
-    return this.browser.findElements(guessLocator(locator) || global.by.css(locator)).then(els => empty('elements').negate(els.fill('ELEMENT')));
+    return this.browser
+      .findElements(guessLocator(locator) || global.by.css(locator))
+      .then((els) => empty('elements').negate(els.fill('ELEMENT')))
   }
 
   /**
    * {{> dontSeeElementInDOM }}
    */
   async dontSeeElementInDOM(locator) {
-    return this.browser.findElements(guessLocator(locator) || global.by.css(locator)).then(els => empty('elements').assert(els.fill('ELEMENT')));
+    return this.browser
+      .findElements(guessLocator(locator) || global.by.css(locator))
+      .then((els) => empty('elements').assert(els.fill('ELEMENT')))
   }
 
   /**
    * {{> seeInSource }}
    */
   async seeInSource(text) {
-    return this.browser.getPageSource().then(source => stringIncludes('HTML source of a page').assert(text, source));
+    return this.browser.getPageSource().then((source) => stringIncludes('HTML source of a page').assert(text, source))
   }
 
   /**
    * {{> grabSource }}
    */
   async grabSource() {
-    return this.browser.getPageSource();
+    return this.browser.getPageSource()
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    return this.browser.getPageSource().then(source => stringIncludes('HTML source of a page').negate(text, source));
+    return this.browser.getPageSource().then((source) => stringIncludes('HTML source of a page').negate(text, source))
   }
 
   /**
    * {{> seeNumberOfElements }}
    */
   async seeNumberOfElements(locator, num) {
-    const elements = await this._locate(locator);
-    return equals(`expected number of elements (${(new Locator(locator))}) is ${num}, but found ${elements.length}`).assert(elements.length, num);
+    const elements = await this._locate(locator)
+    return equals(
+      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
+    ).assert(elements.length, num)
   }
 
   /**
    * {{> seeNumberOfVisibleElements }}
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const res = await this.grabNumberOfVisibleElements(locator);
-    return equals(`expected number of visible elements (${(new Locator(locator))}) is ${num}, but found ${res}`).assert(res, num);
+    const res = await this.grabNumberOfVisibleElements(locator)
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
+      res,
+      num,
+    )
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    let els = await this._locate(locator);
-    els = await Promise.all(els.map(el => el.isDisplayed()));
-    return els.length;
+    let els = await this._locate(locator)
+    els = await Promise.all(els.map((el) => el.isDisplayed()))
+    return els.length
   }
 
   /**
    * {{> seeCssPropertiesOnElements }}
    */
   async seeCssPropertiesOnElements(locator, cssProperties) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
 
-    const cssPropertiesCamelCase = convertCssPropertiesToCamelCase(cssProperties);
+    const cssPropertiesCamelCase = convertCssPropertiesToCamelCase(cssProperties)
 
-    const attributeNames = Object.keys(cssPropertiesCamelCase);
-    const expectedValues = attributeNames.map(name => cssPropertiesCamelCase[name]);
-    const missingAttributes = [];
+    const attributeNames = Object.keys(cssPropertiesCamelCase)
+    const expectedValues = attributeNames.map((name) => cssPropertiesCamelCase[name])
+    const missingAttributes = []
 
     for (const el of els) {
-      const attributeValues = await Promise.all(attributeNames.map(attr => el.getCssValue(attr)));
+      const attributeValues = await Promise.all(attributeNames.map((attr) => el.getCssValue(attr)))
 
       const missing = attributeValues.filter((actual, i) => {
-        const prop = attributeNames[i];
-        let propValue = actual;
+        const prop = attributeNames[i]
+        let propValue = actual
         if (isColorProperty(prop) && propValue) {
-          propValue = convertColorToRGBA(propValue);
+          propValue = convertColorToRGBA(propValue)
         }
-        return propValue !== expectedValues[i];
-      });
+        return propValue !== expectedValues[i]
+      })
       if (missing.length) {
-        missingAttributes.push(...missing);
+        missingAttributes.push(...missing)
       }
     }
-    return equals(`all elements (${(new Locator(locator))}) to have CSS property ${JSON.stringify(cssProperties)}`).assert(missingAttributes.length, 0);
+    return equals(
+      `all elements (${new Locator(locator)}) to have CSS property ${JSON.stringify(cssProperties)}`,
+    ).assert(missingAttributes.length, 0)
   }
 
   /**
    * {{> seeAttributesOnElements }}
    */
   async seeAttributesOnElements(locator, attributes) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
 
-    const attributeNames = Object.keys(attributes);
-    const expectedValues = attributeNames.map(name => attributes[name]);
-    const missingAttributes = [];
+    const attributeNames = Object.keys(attributes)
+    const expectedValues = attributeNames.map((name) => attributes[name])
+    const missingAttributes = []
 
     for (const el of els) {
-      const attributeValues = await Promise.all(attributeNames.map(attr => el.getAttribute(attr)));
+      const attributeValues = await Promise.all(attributeNames.map((attr) => el.getAttribute(attr)))
       const missing = attributeValues.filter((actual, i) => {
         if (expectedValues[i] instanceof RegExp) {
-          return expectedValues[i].test(actual);
+          return expectedValues[i].test(actual)
         }
-        return actual !== expectedValues[i];
-      });
+        return actual !== expectedValues[i]
+      })
       if (missing.length) {
-        missingAttributes.push(...missing);
+        missingAttributes.push(...missing)
       }
     }
 
-    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`).assert(missingAttributes.length, 0);
+    return equals(`all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`).assert(
+      missingAttributes.length,
+      0,
+    )
   }
 
   /**
    * {{> executeScript }}
    */
   async executeScript() {
-    return this.browser.executeScript.apply(this.browser, arguments);
+    return this.browser.executeScript.apply(this.browser, arguments)
   }
 
   /**
    * {{> executeAsyncScript }}
    */
   async executeAsyncScript() {
-    this.browser.manage().timeouts().setScriptTimeout(this.options.scriptTimeout);
-    return this.browser.executeAsyncScript.apply(this.browser, arguments);
+    this.browser.manage().timeouts().setScriptTimeout(this.options.scriptTimeout)
+    return this.browser.executeAsyncScript.apply(this.browser, arguments)
   }
 
   /**
    * {{> seeInCurrentUrl }}
    */
   async seeInCurrentUrl(url) {
-    return this.browser.getCurrentUrl().then(currentUrl => stringIncludes('url').assert(url, currentUrl));
+    return this.browser.getCurrentUrl().then((currentUrl) => stringIncludes('url').assert(url, currentUrl))
   }
 
   /**
    * {{> dontSeeInCurrentUrl }}
    */
   async dontSeeInCurrentUrl(url) {
-    return this.browser.getCurrentUrl().then(currentUrl => stringIncludes('url').negate(url, currentUrl));
+    return this.browser.getCurrentUrl().then((currentUrl) => stringIncludes('url').negate(url, currentUrl))
   }
 
   /**
    * {{> seeCurrentUrlEquals }}
    */
   async seeCurrentUrlEquals(url) {
-    return this.browser.getCurrentUrl().then(currentUrl => urlEquals(this.options.url).assert(url, currentUrl));
+    return this.browser.getCurrentUrl().then((currentUrl) => urlEquals(this.options.url).assert(url, currentUrl))
   }
 
   /**
    * {{> dontSeeCurrentUrlEquals }}
    */
   async dontSeeCurrentUrlEquals(url) {
-    return this.browser.getCurrentUrl().then(currentUrl => urlEquals(this.options.url).negate(url, currentUrl));
+    return this.browser.getCurrentUrl().then((currentUrl) => urlEquals(this.options.url).negate(url, currentUrl))
   }
 
   /**
@@ -1048,56 +1066,57 @@ class Protractor extends Helper {
    *
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
     const writeFile = (png, outputFile) => {
-      const fs = require('fs');
-      const stream = fs.createWriteStream(outputFile);
-      stream.write(Buffer.from(png, 'base64'));
-      stream.end();
-      return new Promise(resolve => stream.on('finish', resolve)); // eslint-disable-line no-promise-executor-return
-    };
+      const fs = require('fs')
+      const stream = fs.createWriteStream(outputFile)
+      stream.write(Buffer.from(png, 'base64'))
+      stream.end()
+      return new Promise((resolve) => stream.on('finish', resolve)) // eslint-disable-line no-promise-executor-return
+    }
 
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
-    if (res.length > 1) this.debug(`[Elements] Using first element out of ${res.length}`);
-    const elem = res[0];
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
-    const png = await elem.takeScreenshot();
-    return writeFile(png, outputFile);
+    const res = await this._locate(locator)
+    assertElementExists(res, locator)
+    if (res.length > 1) this.debug(`[Elements] Using first element out of ${res.length}`)
+    const elem = res[0]
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+    const png = await elem.takeScreenshot()
+    return writeFile(png, outputFile)
   }
 
   /**
    * {{> saveScreenshot }}
    */
   async saveScreenshot(fileName, fullPage = false) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
     const writeFile = (png, outputFile) => {
-      const fs = require('fs');
-      const stream = fs.createWriteStream(outputFile);
-      stream.write(Buffer.from(png, 'base64'));
-      stream.end();
-      return new Promise(resolve => stream.on('finish', resolve)); // eslint-disable-line no-promise-executor-return
-    };
+      const fs = require('fs')
+      const stream = fs.createWriteStream(outputFile)
+      stream.write(Buffer.from(png, 'base64'))
+      stream.end()
+      return new Promise((resolve) => stream.on('finish', resolve)) // eslint-disable-line no-promise-executor-return
+    }
 
     if (!fullPage) {
-      this.debug(`Screenshot has been saved to ${outputFile}`);
-      const png = await this.browser.takeScreenshot();
-      return writeFile(png, outputFile);
+      this.debug(`Screenshot has been saved to ${outputFile}`)
+      const png = await this.browser.takeScreenshot()
+      return writeFile(png, outputFile)
     }
 
-    let { width, height } = await this.browser.executeScript(() => ({ // eslint-disable-line
+    let { width, height } = await this.browser.executeScript(() => ({
+      // eslint-disable-line
       height: document.body.scrollHeight,
       width: document.body.scrollWidth,
-    }));
+    }))
 
-    if (height < 100) height = 500;
+    if (height < 100) height = 500
 
-    await this.browser.manage().window().setSize(width, height);
-    this.debug(`Screenshot has been saved to ${outputFile}, size: ${width}x${height}`);
-    const png = await this.browser.takeScreenshot();
-    return writeFile(png, outputFile);
+    await this.browser.manage().window().setSize(width, height)
+    this.debug(`Screenshot has been saved to ${outputFile}, size: ${width}x${height}`)
+    const png = await this.browser.takeScreenshot()
+    return writeFile(png, outputFile)
   }
 
   /**
@@ -1105,23 +1124,29 @@ class Protractor extends Helper {
    */
   async clearCookie(cookie = null) {
     if (!cookie) {
-      return this.browser.manage().deleteAllCookies();
+      return this.browser.manage().deleteAllCookies()
     }
-    return this.browser.manage().deleteCookie(cookie);
+    return this.browser.manage().deleteCookie(cookie)
   }
 
   /**
    * {{> seeCookie }}
    */
   async seeCookie(name) {
-    return this.browser.manage().getCookie(name).then(res => truth(`cookie ${name}`, 'to be set').assert(res));
+    return this.browser
+      .manage()
+      .getCookie(name)
+      .then((res) => truth(`cookie ${name}`, 'to be set').assert(res))
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    return this.browser.manage().getCookie(name).then(res => truth(`cookie ${name}`, 'to be set').negate(res));
+    return this.browser
+      .manage()
+      .getCookie(name)
+      .then((res) => truth(`cookie ${name}`, 'to be set').negate(res))
   }
 
   /**
@@ -1130,8 +1155,8 @@ class Protractor extends Helper {
    * Returns cookie in JSON [format](https://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object).
    */
   async grabCookie(name) {
-    if (!name) return this.browser.manage().getCookies();
-    return this.browser.manage().getCookie(name);
+    if (!name) return this.browser.manage().getCookies()
+    return this.browser.manage().getCookie(name)
   }
 
   /**
@@ -1140,26 +1165,26 @@ class Protractor extends Helper {
    * libraries](http://jster.net/category/windows-modals-popups). Appium: support only web testing
    */
   async acceptPopup() {
-    return this.browser.switchTo().alert().accept();
+    return this.browser.switchTo().alert().accept()
   }
 
   /**
    * Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
    */
   async cancelPopup() {
-    return this.browser.switchTo().alert().dismiss();
+    return this.browser.switchTo().alert().dismiss()
   }
 
   /**
    * {{> seeInPopup }}
    */
   async seeInPopup(text) {
-    const popupAlert = await this.browser.switchTo().alert();
-    const res = await popupAlert.getText();
+    const popupAlert = await this.browser.switchTo().alert()
+    const res = await popupAlert.getText()
     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)
   }
 
   /**
@@ -1171,17 +1196,17 @@ class Protractor extends Helper {
    */
   async grabPopupText() {
     try {
-      const dialog = await this.browser.switchTo().alert();
+      const dialog = await this.browser.switchTo().alert()
 
       if (dialog) {
-        return dialog.getText();
+        return dialog.getText()
       }
     } catch (e) {
       if (e.message.match(/no.*?(alert|modal)/i)) {
         // Don't throw an error
-        return null;
+        return null
       }
-      throw e;
+      throw e
     }
   }
 
@@ -1190,24 +1215,21 @@ class Protractor extends Helper {
    */
   async resizeWindow(width, height) {
     if (width === 'maximize') {
-      const res = await this.browser.executeScript('return [screen.width, screen.height]');
-      return this.browser.manage().window().setSize(parseInt(res[0], 10), parseInt(res[1], 10));
+      const res = await this.browser.executeScript('return [screen.width, screen.height]')
+      return this.browser.manage().window().setSize(parseInt(res[0], 10), parseInt(res[1], 10))
     }
-    return this.browser.manage().window().setSize(parseInt(width, 10), parseInt(height, 10));
+    return this.browser.manage().window().setSize(parseInt(width, 10), parseInt(height, 10))
   }
 
   /**
    * {{> dragAndDrop }}
    */
   async dragAndDrop(srcElement, destElement) {
-    const srcEl = await this._locate(srcElement, true);
-    const destEl = await this._locate(destElement, true);
-    assertElementExists(srcEl, srcElement);
-    assertElementExists(destEl, destElement);
-    return this.browser
-      .actions()
-      .dragAndDrop(srcEl[0], destEl[0])
-      .perform();
+    const srcEl = await this._locate(srcElement, true)
+    const destEl = await this._locate(destElement, true)
+    assertElementExists(srcEl, srcElement)
+    assertElementExists(destEl, destElement)
+    return this.browser.actions().dragAndDrop(srcEl[0], destEl[0]).perform()
   }
 
   /**
@@ -1218,19 +1240,24 @@ class Protractor extends Helper {
    * ```
    */
   async closeOtherTabs() {
-    const client = this.browser;
+    const client = this.browser
 
-    const handles = await client.getAllWindowHandles();
-    const currentHandle = await client.getWindowHandle();
-    const otherHandles = handles.filter(handle => handle !== currentHandle);
+    const handles = await client.getAllWindowHandles()
+    const currentHandle = await client.getWindowHandle()
+    const otherHandles = handles.filter((handle) => handle !== currentHandle)
 
-    if (!otherHandles || !otherHandles.length) return;
-    let p = Promise.resolve();
+    if (!otherHandles || !otherHandles.length) return
+    let p = Promise.resolve()
     otherHandles.forEach((handle) => {
-      p = p.then(() => client.switchTo().window(handle).then(() => client.close()));
-    });
-    p = p.then(() => client.switchTo().window(currentHandle));
-    return p;
+      p = p.then(() =>
+        client
+          .switchTo()
+          .window(handle)
+          .then(() => client.close()),
+      )
+    })
+    p = p.then(() => client.switchTo().window(currentHandle))
+    return p
   }
 
   /**
@@ -1241,14 +1268,14 @@ class Protractor extends Helper {
    * ```
    */
   async closeCurrentTab() {
-    const client = this.browser;
+    const client = this.browser
 
-    const currentHandle = await client.getWindowHandle();
-    const nextHandle = await this._getWindowHandle(-1);
+    const currentHandle = await client.getWindowHandle()
+    const nextHandle = await this._getWindowHandle(-1)
 
-    await client.switchTo().window(currentHandle);
-    await client.close();
-    return client.switchTo().window(nextHandle);
+    await client.switchTo().window(currentHandle)
+    await client.close()
+    return client.switchTo().window(nextHandle)
   }
 
   /**
@@ -1256,12 +1283,12 @@ class Protractor extends Helper {
    * @param {Number} offset Offset from current handle index. i.e. offset < 0 will go to the previous handle and positive number will go to the next window handle in sequence.
    */
   async _getWindowHandle(offset = 0) {
-    const client = this.browser;
-    const handles = await client.getAllWindowHandles();
-    const index = handles.indexOf(await client.getWindowHandle());
-    const nextIndex = index + offset;
+    const client = this.browser
+    const handles = await client.getAllWindowHandles()
+    const index = handles.indexOf(await client.getWindowHandle())
+    const nextIndex = index + offset
 
-    return handles[nextIndex];
+    return handles[nextIndex]
     // return handles[(index + offset) % handles.length];
   }
 
@@ -1273,10 +1300,10 @@ class Protractor extends Helper {
    * ```
    */
   async openNewTab() {
-    const client = this.browser;
-    await this.executeScript('window.open("about:blank")');
-    const handles = await client.getAllWindowHandles();
-    await client.switchTo().window(handles[handles.length - 1]);
+    const client = this.browser
+    await this.executeScript('window.open("about:blank")')
+    const handles = await client.getAllWindowHandles()
+    await client.switchTo().window(handles[handles.length - 1])
   }
 
   /**
@@ -1288,13 +1315,13 @@ class Protractor extends Helper {
    * ```
    */
   async switchToNextTab(num = 1) {
-    const client = this.browser;
-    const newHandle = await this._getWindowHandle(num);
+    const client = this.browser
+    const newHandle = await this._getWindowHandle(num)
 
     if (!newHandle) {
-      throw new Error(`There is no ability to switch to next tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to next tab with offset ${num}`)
     }
-    return client.switchTo().window(newHandle);
+    return client.switchTo().window(newHandle)
   }
 
   /**
@@ -1306,21 +1333,21 @@ class Protractor extends Helper {
    * ```
    */
   async switchToPreviousTab(num = 1) {
-    const client = this.browser;
-    const newHandle = await this._getWindowHandle(-1 * num);
+    const client = this.browser
+    const newHandle = await this._getWindowHandle(-1 * num)
 
     if (!newHandle) {
-      throw new Error(`There is no ability to switch to previous tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to previous tab with offset ${num}`)
     }
-    return client.switchTo().window(newHandle);
+    return client.switchTo().window(newHandle)
   }
 
   /**
    * {{> grabNumberOfOpenTabs }}
    */
   async grabNumberOfOpenTabs() {
-    const pages = await this.browser.getAllWindowHandles();
-    return pages.length;
+    const pages = await this.browser.getAllWindowHandles()
+    return pages.length
   }
 
   /**
@@ -1328,51 +1355,51 @@ class Protractor extends Helper {
    */
   async switchTo(locator) {
     if (Number.isInteger(locator)) {
-      return this.browser.switchTo().frame(locator);
+      return this.browser.switchTo().frame(locator)
     }
     if (!locator) {
-      return this.browser.switchTo().frame(null);
+      return this.browser.switchTo().frame(null)
     }
 
-    const els = await this._locate(withStrictLocator.call(this, locator), true);
-    assertElementExists(els, locator);
-    return this.browser.switchTo().frame(els[0]);
+    const els = await this._locate(withStrictLocator.call(this, locator), true)
+    assertElementExists(els, locator)
+    return this.browser.switchTo().frame(els[0])
   }
 
   /**
    * {{> wait }}
    */
   wait(sec) {
-    return this.browser.sleep(sec * 1000);
+    return this.browser.sleep(sec * 1000)
   }
 
   /**
    * {{> waitForElement }}
    */
   async waitForElement(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
-    return this.browser.wait(EC.presenceOf(el), aSec * 1000);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
+    return this.browser.wait(EC.presenceOf(el), aSec * 1000)
   }
 
   async waitUntilExists(locator, sec = null) {
     console.log(`waitUntilExists deprecated:
     * use 'waitForElement' to wait for element to be attached
-    * use 'waitForDetached to wait for element to be removed'`);
-    return this.waitForDetached(locator, sec);
+    * use 'waitForDetached to wait for element to be removed'`)
+    return this.waitForDetached(locator, sec)
   }
 
   /**
    * {{> waitForDetached }}
    */
   async waitForDetached(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
     return this.browser.wait(EC.not(EC.presenceOf(el)), aSec * 1000).catch((err) => {
       if (err.message && err.message.indexOf('Wait timed out after') > -1) {
-        throw new Error(`element (${JSON.stringify(locator)}) still on page after ${sec} sec`);
-      } else throw err;
-    });
+        throw new Error(`element (${JSON.stringify(locator)}) still on page after ${sec} sec`)
+      } else throw err
+    })
   }
 
   /**
@@ -1383,41 +1410,41 @@ class Protractor extends Helper {
    * ```
    */
   async waitForClickable(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
-    return this.browser.wait(EC.elementToBeClickable(el), aSec * 1000);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
+    return this.browser.wait(EC.elementToBeClickable(el), aSec * 1000)
   }
 
   /**
    * {{> waitForVisible }}
    */
   async waitForVisible(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
-    return this.browser.wait(EC.visibilityOf(el), aSec * 1000);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
+    return this.browser.wait(EC.visibilityOf(el), aSec * 1000)
   }
 
   /**
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec = null) {
-    return this.waitForInvisible(locator, sec);
+    return this.waitForInvisible(locator, sec)
   }
 
   /**
    * {{> waitForInvisible }}
    */
   async waitForInvisible(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
-    return this.browser.wait(EC.invisibilityOf(el), aSec * 1000);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
+    return this.browser.wait(EC.invisibilityOf(el), aSec * 1000)
   }
 
   async waitForStalenessOf(locator, sec = null) {
     console.log(`waitForStalenessOf deprecated.
     * Use waitForDetached to wait for element to be removed from page
-    * Use waitForInvisible to wait for element to be hidden on page`);
-    return this.waitForInvisible(locator, sec);
+    * Use waitForInvisible to wait for element to be hidden on page`)
+    return this.waitForInvisible(locator, sec)
   }
 
   /**
@@ -1426,114 +1453,112 @@ class Protractor extends Helper {
   async waitNumberOfVisibleElements(locator, num, sec = null) {
     function visibilityCountOf(loc, expectedCount) {
       return function () {
-        return global.element.all(loc)
-          .filter(el => el.isDisplayed())
+        return global.element
+          .all(loc)
+          .filter((el) => el.isDisplayed())
           .count()
-          .then(count => count === expectedCount);
-      };
+          .then((count) => count === expectedCount)
+      }
     }
 
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const guessLoc = guessLocator(locator) || global.by.css(locator);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const guessLoc = guessLocator(locator) || global.by.css(locator)
 
-    return this.browser.wait(visibilityCountOf(guessLoc, num), aSec * 1000)
-      .catch(() => {
-        throw Error(`The number of elements (${(new Locator(locator))}) is not ${num} after ${aSec} sec`);
-      });
+    return this.browser.wait(visibilityCountOf(guessLoc, num), aSec * 1000).catch(() => {
+      throw Error(`The number of elements (${new Locator(locator)}) is not ${num} after ${aSec} sec`)
+    })
   }
 
   /**
    * {{> waitForEnabled }}
    */
   async waitForEnabled(locator, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const el = global.element(guessLocator(locator) || global.by.css(locator));
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const el = global.element(guessLocator(locator) || global.by.css(locator))
 
-    return this.browser.wait(EC.elementToBeClickable(el), aSec * 1000)
-      .catch(() => {
-        throw Error(`element (${(new Locator(locator))}) still not enabled after ${aSec} sec`);
-      });
+    return this.browser.wait(EC.elementToBeClickable(el), aSec * 1000).catch(() => {
+      throw Error(`element (${new Locator(locator)}) still not enabled after ${aSec} sec`)
+    })
   }
 
   /**
    * {{> waitForValue }}
    */
   async waitForValue(field, value, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
 
     const valueToBeInElementValue = (loc) => {
       return async () => {
-        const els = await findFields(this.browser, loc);
+        const els = await findFields(this.browser, loc)
 
         if (!els) {
-          return false;
+          return false
         }
-        const values = await Promise.all(els.map(el => el.getAttribute('value')));
-        return values.filter(part => part.indexOf(value) >= 0).length > 0;
-      };
-    };
+        const values = await Promise.all(els.map((el) => el.getAttribute('value')))
+        return values.filter((part) => part.indexOf(value) >= 0).length > 0
+      }
+    }
 
-    return this.browser.wait(valueToBeInElementValue(field, value), aSec * 1000)
-      .catch(() => {
-        throw Error(`element (${field}) is not in DOM or there is no element(${field}) with value "${value}" after ${aSec} sec`);
-      });
+    return this.browser.wait(valueToBeInElementValue(field, value), aSec * 1000).catch(() => {
+      throw Error(
+        `element (${field}) is not in DOM or there is no element(${field}) with value "${value}" 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;
-    return this.browser.wait(() => this.browser.executeScript.call(this.browser, fn, ...args), aSec * 1000);
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    return this.browser.wait(() => this.browser.executeScript.call(this.browser, fn, ...args), aSec * 1000)
   }
 
   /**
    * {{> waitInUrl }}
    */
   async waitInUrl(urlPart, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const waitTimeout = aSec * 1000;
-
-    return this.browser.wait(EC.urlContains(urlPart), waitTimeout)
-      .catch(async (e) => {
-        const currUrl = await this.browser.getCurrentUrl();
-        if (/wait timed out after/i.test(e.message)) {
-          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
-        } else {
-          throw e;
-        }
-      });
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const waitTimeout = aSec * 1000
+
+    return this.browser.wait(EC.urlContains(urlPart), waitTimeout).catch(async (e) => {
+      const currUrl = await this.browser.getCurrentUrl()
+      if (/wait timed out after/i.test(e.message)) {
+        throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+      } else {
+        throw e
+      }
+    })
   }
 
   /**
    * {{> waitUrlEquals }}
    */
   async waitUrlEquals(urlPart, sec = null) {
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    const waitTimeout = aSec * 1000;
-    const baseUrl = this.options.url;
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    const waitTimeout = aSec * 1000
+    const baseUrl = this.options.url
     if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart;
+      urlPart = baseUrl + urlPart
     }
 
-    return this.browser.wait(EC.urlIs(urlPart), waitTimeout)
-      .catch(async (e) => {
-        const currUrl = await this.browser.getCurrentUrl();
-        if (/wait timed out after/i.test(e.message)) {
-          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`);
-        } else {
-          throw e;
-        }
-      });
+    return this.browser.wait(EC.urlIs(urlPart), waitTimeout).catch(async (e) => {
+      const currUrl = await this.browser.getCurrentUrl()
+      if (/wait timed out after/i.test(e.message)) {
+        throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+      } else {
+        throw e
+      }
+    })
   }
 
   /**
@@ -1541,11 +1566,11 @@ class Protractor extends Helper {
    */
   async waitForText(text, sec = null, context = null) {
     if (!context) {
-      context = this.context;
+      context = this.context
     }
-    const el = global.element(guessLocator(context) || global.by.css(context));
-    const aSec = sec || this.options.waitForTimeoutInSeconds;
-    return this.browser.wait(EC.textToBePresentInElement(el, text), aSec * 1000);
+    const el = global.element(guessLocator(context) || global.by.css(context))
+    const aSec = sec || this.options.waitForTimeoutInSeconds
+    return this.browser.wait(EC.textToBePresentInElement(el, text), aSec * 1000)
   }
 
   // ANGULAR SPECIFIC
@@ -1554,22 +1579,22 @@ class Protractor extends Helper {
    * Moves to url
    */
   moveTo(path) {
-    return this.browser.setLocation(path);
+    return this.browser.setLocation(path)
   }
 
   /**
    * {{> refreshPage }}
    */
   refreshPage() {
-    return this.browser.refresh();
+    return this.browser.refresh()
   }
 
   /**
    * Reloads page
    */
   refresh() {
-    console.log('Deprecated in favor of refreshPage');
-    return this.browser.refresh();
+    console.log('Deprecated in favor of refreshPage')
+    return this.browser.refresh()
   }
 
   /**
@@ -1577,25 +1602,37 @@ class Protractor 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(locator, true);
+      const res = await this._locate(locator, true)
       if (!res || res.length === 0) {
-        return truth(`elements of ${(new Locator(locator))}`, 'to be seen').assert(false);
+        return truth(`elements of ${new Locator(locator)}`, 'to be seen').assert(false)
       }
-      const elem = res[0];
-      const location = await elem.getLocation();
+      const elem = res[0]
+      const location = await elem.getLocation()
       /* eslint-disable prefer-arrow-callback */
-      return this.executeScript(function (x, y) { return window.scrollTo(x, y); }, location.x + offsetX, location.y + offsetY);
+      return this.executeScript(
+        function (x, y) {
+          return window.scrollTo(x, y)
+        },
+        location.x + offsetX,
+        location.y + offsetY,
+      )
       /* eslint-enable */
     }
 
     /* eslint-disable prefer-arrow-callback, comma-dangle */
-    return this.executeScript(function (x, y) { return window.scrollTo(x, y); }, offsetX, offsetY);
+    return this.executeScript(
+      function (x, y) {
+        return window.scrollTo(x, y)
+      },
+      offsetX,
+      offsetY,
+    )
     /* eslint-enable */
   }
 
@@ -1603,7 +1640,7 @@ class Protractor extends Helper {
    * {{> scrollPageToTop }}
    */
   async scrollPageToTop() {
-    return this.executeScript('window.scrollTo(0, 0);');
+    return this.executeScript('window.scrollTo(0, 0);')
   }
 
   /**
@@ -1612,16 +1649,13 @@ class Protractor extends Helper {
   async scrollPageToBottom() {
     /* eslint-disable prefer-arrow-callback, comma-dangle */
     return this.executeScript(function () {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight
-      ));
-    });
+      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 */
   }
 
@@ -1633,11 +1667,11 @@ class Protractor extends Helper {
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
+        y: window.pageYOffset,
+      }
     }
     /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
+    return this.executeScript(getScrollPosition)
   }
 
   /**
@@ -1650,7 +1684,7 @@ class Protractor extends Helper {
    * ```
    */
   haveModule(modName, fn) {
-    return this.browser.addMockModule(modName, fn);
+    return this.browser.addMockModule(modName, fn)
   }
 
   /**
@@ -1663,175 +1697,175 @@ class Protractor extends Helper {
    */
   resetModule(modName) {
     if (!modName) {
-      return this.browser.clearMockModules();
+      return this.browser.clearMockModules()
     }
-    return this.browser.removeMockModule(modName);
+    return this.browser.removeMockModule(modName)
   }
 
   /**
    * {{> setCookie }}
    */
   setCookie(cookie) {
-    return this.browser.manage().addCookie(cookie);
+    return this.browser.manage().addCookie(cookie)
   }
 }
 
-module.exports = Protractor;
+module.exports = Protractor
 
 async function findCheckable(client, locator) {
-  const matchedLocator = guessLocator(locator);
+  const matchedLocator = guessLocator(locator)
   if (matchedLocator) {
-    return client.findElements(matchedLocator);
+    return client.findElements(matchedLocator)
   }
-  const literal = xpathLocator.literal(locator);
-  let els = await client.findElements(global.by.xpath(Locator.checkable.byText(literal)));
+  const literal = xpathLocator.literal(locator)
+  let els = await client.findElements(global.by.xpath(Locator.checkable.byText(literal)))
   if (els.length) {
-    return els;
+    return els
   }
-  els = await client.findElements(global.by.xpath(Locator.checkable.byName(literal)));
+  els = await client.findElements(global.by.xpath(Locator.checkable.byName(literal)))
   if (els.length) {
-    return els;
+    return els
   }
-  return client.findElements(global.by.css(locator));
+  return client.findElements(global.by.css(locator))
 }
 
 function withStrictLocator(locator) {
-  locator = new Locator(locator);
-  if (locator.isAccessibilityId()) return withAccessiblitiyLocator.call(this, locator.value);
-  return locator.simplify();
+  locator = new Locator(locator)
+  if (locator.isAccessibilityId()) return withAccessiblitiyLocator.call(this, locator.value)
+  return locator.simplify()
 }
 
 function withAccessiblitiyLocator(locator) {
   if (this.isWeb === false) {
-    return `accessibility id:${locator.slice(1)}`;
+    return `accessibility id:${locator.slice(1)}`
   }
-  return `[aria-label="${locator.slice(1)}"]`;
+  return `[aria-label="${locator.slice(1)}"]`
   // hook before webdriverio supports native ~ locators in web
 }
 
 async function findFields(client, locator) {
-  const matchedLocator = guessLocator(locator);
+  const matchedLocator = guessLocator(locator)
   if (matchedLocator) {
-    return client.findElements(matchedLocator);
+    return client.findElements(matchedLocator)
   }
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await client.findElements(global.by.xpath(Locator.field.labelEquals(literal)));
+  let els = await client.findElements(global.by.xpath(Locator.field.labelEquals(literal)))
   if (els.length) {
-    return els;
+    return els
   }
 
-  els = await client.findElements(global.by.xpath(Locator.field.labelContains(literal)));
+  els = await client.findElements(global.by.xpath(Locator.field.labelContains(literal)))
   if (els.length) {
-    return els;
+    return els
   }
-  els = await client.findElements(global.by.xpath(Locator.field.byName(literal)));
+  els = await client.findElements(global.by.xpath(Locator.field.byName(literal)))
   if (els.length) {
-    return els;
+    return els
   }
-  return client.findElements(global.by.css(locator));
+  return client.findElements(global.by.css(locator))
 }
 
 async function proceedSee(assertType, text, context) {
-  let description;
-  let locator;
+  let description
+  let locator
   if (!context) {
     if (this.context === this.options.rootElement) {
-      locator = guessLocator(this.context) || global.by.css(this.context);
-      description = 'web application';
+      locator = guessLocator(this.context) || global.by.css(this.context)
+      description = 'web application'
     } else {
       // inside within block
-      locator = global.by.xpath('.//*');
-      description = `current context ${(new Locator(context)).toString()}`;
+      locator = global.by.xpath('.//*')
+      description = `current context ${new Locator(context).toString()}`
     }
   } else {
-    locator = guessLocator(context) || global.by.css(context);
-    description = `element ${(new Locator(context)).toString()}`;
-  }
-  const enableSmartWait = !!this.context && assertType === 'assert';
-  const els = await this._smartWait(() => this.browser.findElements(locator), enableSmartWait);
-  const promises = [];
-  let source = '';
-  els.forEach(el => promises.push(el.getText().then(elText => source += `| ${elText}`)));
-  await Promise.all(promises);
-  return stringIncludes(description)[assertType](text, source);
+    locator = guessLocator(context) || global.by.css(context)
+    description = `element ${new Locator(context).toString()}`
+  }
+  const enableSmartWait = !!this.context && assertType === 'assert'
+  const els = await this._smartWait(() => this.browser.findElements(locator), enableSmartWait)
+  const promises = []
+  let source = ''
+  els.forEach((el) => promises.push(el.getText().then((elText) => (source += `| ${elText}`))))
+  await Promise.all(promises)
+  return stringIncludes(description)[assertType](text, source)
 }
 
 async function proceedSeeInField(assertType, field, value) {
-  const els = await findFields(this.browser, field);
-  assertElementExists(els, field, 'Field');
-  const el = els[0];
-  const tag = await el.getTagName();
-  const fieldVal = await el.getAttribute('value');
+  const els = await findFields(this.browser, field)
+  assertElementExists(els, field, 'Field')
+  const el = els[0]
+  const tag = await el.getTagName()
+  const fieldVal = await el.getAttribute('value')
   if (tag === 'select') {
     // locate option by values and check them
-    const literal = xpathLocator.literal(fieldVal);
-    const textEl = await el.findElement(global.by.xpath(Locator.select.byValue(literal)));
-    const text = await textEl.getText();
-    return equals(`select option by ${field}`)[assertType](value, text);
+    const literal = xpathLocator.literal(fieldVal)
+    const textEl = await el.findElement(global.by.xpath(Locator.select.byValue(literal)))
+    const text = await textEl.getText()
+    return equals(`select option by ${field}`)[assertType](value, text)
   }
-  return stringIncludes(`field by ${field}`)[assertType](value, fieldVal);
+  return stringIncludes(`field by ${field}`)[assertType](value, fieldVal)
 }
 
 async function proceedIsChecked(assertType, option) {
-  const els = await findCheckable(this.browser, option);
-  assertElementExists(els, option, 'Option');
-  const elsSelected = [];
-  els.forEach(el => elsSelected.push(el.isSelected()));
-  const values = await Promise.all(elsSelected);
-  const selected = values.reduce((prev, cur) => prev || cur);
-  return truth(`checkable ${option}`, 'to be checked')[assertType](selected);
+  const els = await findCheckable(this.browser, option)
+  assertElementExists(els, option, 'Option')
+  const elsSelected = []
+  els.forEach((el) => elsSelected.push(el.isSelected()))
+  const values = await Promise.all(elsSelected)
+  const selected = values.reduce((prev, cur) => prev || cur)
+  return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
 async function findClickable(matcher, locator) {
-  locator = new Locator(locator);
+  locator = new Locator(locator)
   if (!locator.isFuzzy()) {
-    const els = await this._locate(locator, true);
-    assertElementExists(els, locator.value);
-    return els[0];
+    const els = await this._locate(locator, true)
+    assertElementExists(els, locator.value)
+    return els[0]
   }
-  const literal = xpathLocator.literal(locator.value);
-  const narrowLocator = Locator.clickable.narrow(literal);
-  let els = await matcher.findElements(global.by.xpath(narrowLocator));
+  const literal = xpathLocator.literal(locator.value)
+  const narrowLocator = Locator.clickable.narrow(literal)
+  let els = await matcher.findElements(global.by.xpath(narrowLocator))
   if (els.length) {
-    return els[0];
+    return els[0]
   }
 
-  els = await matcher.findElements(global.by.xpath(Locator.clickable.wide(literal)));
+  els = await matcher.findElements(global.by.xpath(Locator.clickable.wide(literal)))
   if (els.length) {
-    return els[0];
+    return els[0]
   }
-  return matcher.findElement(global.by.css(locator.value));
+  return matcher.findElement(global.by.css(locator.value))
 }
 
 function guessLocator(locator) {
-  const l = new Locator(locator);
-  if (l.isFuzzy()) return false;
-  if (l.type) return global.by[l.type](l.value);
-  return false;
+  const l = new Locator(locator)
+  if (l.isFuzzy()) return false
+  if (l.type) return global.by[l.type](l.value)
+  return false
 }
 
 function assertElementExists(res, locator, prefix, suffix) {
   if (!res.length) {
-    throw new ElementNotFound(locator, prefix, suffix);
+    throw new ElementNotFound(locator, prefix, suffix)
   }
 }
 
 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 isWithin() {
-  return Object.keys(withinStore).length !== 0;
+  return Object.keys(withinStore).length !== 0
 }
 
 function loadGlobals(browser) {
-  global.browser = browser;
-  global.$ = browser.$;
-  global.$$ = browser.$$;
-  global.element = browser.element;
-  global.by = global.By = new ProtractorBy();
-  global.ExpectedConditions = EC = new ProtractorExpectedConditions(browser);
+  global.browser = browser
+  global.$ = browser.$
+  global.$$ = browser.$$
+  global.element = browser.element
+  global.by = global.By = new ProtractorBy()
+  global.ExpectedConditions = EC = new ProtractorExpectedConditions(browser)
 }
diff --git a/lib/helper/Puppeteer.js b/lib/helper/Puppeteer.js
index 2ae747dea..0c219144e 100644
--- a/lib/helper/Puppeteer.js
+++ b/lib/helper/Puppeteer.js
@@ -1,20 +1,20 @@
-const axios = require('axios');
-const fs = require('fs');
-const fsExtra = require('fs-extra');
-const path = require('path');
-
-const Helper = require('@codeceptjs/helper');
-const { v4: uuidv4 } = require('uuid');
-const promiseRetry = require('promise-retry');
-const Locator = require('../locator');
-const recorder = require('../recorder');
-const store = require('../store');
-const stringIncludes = require('../assert/include').includes;
-const { urlEquals } = require('../assert/equal');
-const { equals } = require('../assert/equal');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
-const isElementClickable = require('./scripts/isElementClickable');
+const axios = require('axios')
+const fs = require('fs')
+const fsExtra = require('fs-extra')
+const path = require('path')
+
+const Helper = require('@codeceptjs/helper')
+const { v4: uuidv4 } = require('uuid')
+const promiseRetry = require('promise-retry')
+const Locator = require('../locator')
+const recorder = require('../recorder')
+const store = require('../store')
+const stringIncludes = require('../assert/include').includes
+const { urlEquals } = require('../assert/equal')
+const { equals } = require('../assert/equal')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
+const isElementClickable = require('./scripts/isElementClickable')
 const {
   xpathLocator,
   ucfirst,
@@ -26,29 +26,34 @@ const {
   screenshotOutputFolder,
   getNormalizedKeyAttributeValue,
   isModifierKey,
-  requireWithFallback, normalizeSpacesInString,
-} = require('../utils');
+  requireWithFallback,
+  normalizeSpacesInString,
+} = require('../utils')
+const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
+const ElementNotFound = require('./errors/ElementNotFound')
+const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused')
+const Popup = require('./extras/Popup')
+const Console = require('./extras/Console')
+const { highlightElement } = require('./scripts/highlightElement')
+const { blurElement } = require('./scripts/blurElement')
 const {
-  isColorProperty,
-  convertColorToRGBA,
-} = require('../colorUtils');
-const ElementNotFound = require('./errors/ElementNotFound');
-const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused');
-const Popup = require('./extras/Popup');
-const Console = require('./extras/Console');
-const { highlightElement } = require('./scripts/highlightElement');
-const { blurElement } = require('./scripts/blurElement');
+  dontSeeElementError,
+  seeElementError,
+  dontSeeElementInDOMError,
+  seeElementInDOMError,
+} = require('./errors/ElementAssertion')
 const {
-  dontSeeElementError, seeElementError, dontSeeElementInDOMError, seeElementInDOMError,
-} = require('./errors/ElementAssertion');
-const {
-  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
-} = require('./network/actions');
-
-let puppeteer;
-let perfTiming;
-const popupStore = new Popup();
-const consoleLogStore = new Console();
+  dontSeeTraffic,
+  seeTraffic,
+  grabRecordedNetworkTraffics,
+  stopRecordingTraffic,
+  flushNetworkTraffics,
+} = require('./network/actions')
+
+let puppeteer
+let perfTiming
+const popupStore = new Popup()
+const consoleLogStore = new Console()
 
 /**
  * ## Configuration
@@ -80,7 +85,7 @@ const consoleLogStore = new Console();
  * @prop {object} [chrome] - pass additional [Puppeteer run options](https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions).
  * @prop {boolean} [highlightElement] - highlight the interacting elements. Default: false. Note: only activate under verbose mode (--verbose).
  */
-const config = {};
+const config = {}
 
 /**
  * Uses [Google Chrome's Puppeteer](https://github.com/GoogleChrome/puppeteer) library to run tests inside headless Chrome.
@@ -217,29 +222,29 @@ const config = {};
  */
 class Puppeteer extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
-    puppeteer = requireWithFallback('puppeteer', 'puppeteer-core');
+    puppeteer = requireWithFallback('puppeteer', 'puppeteer-core')
     // set defaults
-    this.isRemoteBrowser = false;
-    this.isRunning = false;
-    this.isAuthenticated = false;
-    this.sessionPages = {};
-    this.activeSessionName = '';
+    this.isRemoteBrowser = false
+    this.isRunning = false
+    this.isAuthenticated = false
+    this.sessionPages = {}
+    this.activeSessionName = ''
 
     // for network stuff
-    this.requests = [];
-    this.recording = false;
-    this.recordedAtLeastOnce = false;
+    this.requests = []
+    this.recording = false
+    this.recordedAtLeastOnce = false
 
     // for websocket messages
-    this.webSocketMessages = [];
-    this.recordingWebSocketMessages = false;
-    this.recordedWebSocketMessagesAtLeastOnce = false;
-    this.cdpSession = null;
+    this.webSocketMessages = []
+    this.recordingWebSocketMessages = false
+    this.recordedWebSocketMessagesAtLeastOnce = false
+    this.cdpSession = null
 
     // override defaults with config
-    this._setConfig(config);
+    this._setConfig(config)
   }
 
   _validateConfig(config) {
@@ -260,156 +265,161 @@ class Puppeteer extends Helper {
       show: false,
       defaultPopupAction: 'accept',
       highlightElement: false,
-    };
+    }
 
-    return Object.assign(defaults, config);
+    return Object.assign(defaults, config)
   }
 
   _getOptions(config) {
-    return config.browser === 'firefox' ? Object.assign(this.options.firefox, { product: 'firefox' }) : this.options.chrome;
+    return config.browser === 'firefox'
+      ? Object.assign(this.options.firefox, { product: 'firefox' })
+      : this.options.chrome
   }
 
   _setConfig(config) {
-    this.options = this._validateConfig(config);
+    this.options = this._validateConfig(config)
     this.puppeteerOptions = {
       headless: !this.options.show,
       ...this._getOptions(config),
-    };
-    if (this.puppeteerOptions.headless) this.puppeteerOptions.headless = 'new';
-    this.isRemoteBrowser = !!this.puppeteerOptions.browserWSEndpoint;
-    popupStore.defaultAction = this.options.defaultPopupAction;
+    }
+    if (this.puppeteerOptions.headless) this.puppeteerOptions.headless = 'new'
+    this.isRemoteBrowser = !!this.puppeteerOptions.browserWSEndpoint
+    popupStore.defaultAction = this.options.defaultPopupAction
   }
 
   static _config() {
     return [
       { name: 'url', message: 'Base url of site to be tested', default: 'http://localhost' },
       {
-        name: 'show', message: 'Show browser window', default: true, type: 'confirm',
+        name: 'show',
+        message: 'Show browser window',
+        default: true,
+        type: 'confirm',
       },
       {
-        name: 'windowSize', message: 'Browser viewport size', default: '1200x900',
+        name: 'windowSize',
+        message: 'Browser viewport size',
+        default: '1200x900',
       },
-    ];
+    ]
   }
 
   static _checkRequirements() {
     try {
-      requireWithFallback('puppeteer', 'puppeteer-core');
+      requireWithFallback('puppeteer', 'puppeteer-core')
     } catch (e) {
-      return ['puppeteer'];
+      return ['puppeteer']
     }
   }
 
-  _init() {
-  }
+  _init() {}
 
   _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()
     }
   }
 
   async _before(test) {
-    this.sessionPages = {};
-    this.currentRunningTest = test;
+    this.sessionPages = {}
+    this.currentRunningTest = test
     recorder.retry({
       retries: process.env.FAILED_STEP_RETRIES || 3,
-      when: err => {
-        if (!err || typeof (err.message) !== 'string') {
-          return false;
+      when: (err) => {
+        if (!err || typeof err.message !== 'string') {
+          return false
         }
         // ignore context errors
-        return err.message.includes('context');
+        return err.message.includes('context')
       },
-    });
-    if (this.options.restart && !this.options.manualStart) return this._startBrowser();
-    if (!this.isRunning && !this.options.manualStart) return this._startBrowser();
-    return this.browser;
+    })
+    if (this.options.restart && !this.options.manualStart) return this._startBrowser()
+    if (!this.isRunning && !this.options.manualStart) return this._startBrowser()
+    return this.browser
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
 
     // close other sessions
-    const contexts = this.browser.browserContexts();
-    const defaultCtx = contexts.shift();
+    const contexts = this.browser.browserContexts()
+    const defaultCtx = contexts.shift()
 
-    await Promise.all(contexts.map(c => c.close()));
+    await Promise.all(contexts.map((c) => c.close()))
 
     if (this.options.restart) {
-      this.isRunning = false;
-      return this._stopBrowser();
+      this.isRunning = false
+      return this._stopBrowser()
     }
 
     // ensure this.page is from default context
     if (this.page) {
-      const existingPages = defaultCtx.targets().filter(t => t.type() === 'page');
-      await this._setPage(await existingPages[0].page());
+      const existingPages = defaultCtx.targets().filter((t) => t.type() === 'page')
+      await this._setPage(await existingPages[0].page())
     }
 
-    if (this.options.keepBrowserState) return;
+    if (this.options.keepBrowserState) return
 
     if (!this.options.keepCookies) {
-      this.debugSection('Session', 'cleaning cookies and localStorage');
-      await this.clearCookie();
+      this.debugSection('Session', 'cleaning cookies and localStorage')
+      await this.clearCookie()
     }
-    const currentUrl = await this.grabCurrentUrl();
+    const currentUrl = await this.grabCurrentUrl()
 
     if (currentUrl.startsWith('http')) {
       await this.executeScript('localStorage.clear();').catch((err) => {
-        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-      });
+        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+      })
       await this.executeScript('sessionStorage.clear();').catch((err) => {
-        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-      });
+        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+      })
     }
-    await this.closeOtherTabs();
-    return this.browser;
+    await this.closeOtherTabs()
+    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() {
     return {
       start: async (name = '') => {
-        this.debugSection('Incognito Tab', 'opened');
-        this.activeSessionName = name;
+        this.debugSection('Incognito Tab', 'opened')
+        this.activeSessionName = name
 
-        const bc = await this.browser.createBrowserContext();
-        await bc.newPage();
+        const bc = await this.browser.createBrowserContext()
+        await bc.newPage()
 
         // Create a new page inside context.
-        return bc;
+        return bc
       },
       stop: async () => {
         // is closed by _after
       },
       loadVars: async (context) => {
-        const existingPages = context.targets().filter(t => t.type() === 'page');
-        this.sessionPages[this.activeSessionName] = await existingPages[0].page();
-        return this._setPage(this.sessionPages[this.activeSessionName]);
+        const existingPages = context.targets().filter((t) => t.type() === 'page')
+        this.sessionPages[this.activeSessionName] = await existingPages[0].page()
+        return this._setPage(this.sessionPages[this.activeSessionName])
       },
       restoreVars: async (session) => {
-        this.withinLocator = null;
+        this.withinLocator = null
 
         if (!session) {
-          this.activeSessionName = '';
+          this.activeSessionName = ''
         } else {
-          this.activeSessionName = session;
+          this.activeSessionName = session
         }
-        const defaultCtx = this.browser.defaultBrowserContext();
-        const existingPages = defaultCtx.targets().filter(t => t.type() === 'page');
-        await this._setPage(await existingPages[0].page());
+        const defaultCtx = this.browser.defaultBrowserContext()
+        const existingPages = defaultCtx.targets().filter((t) => t.type() === 'page')
+        await this._setPage(await existingPages[0].page())
 
-        return this._waitForAction();
+        return this._waitForAction()
       },
-    };
+    }
   }
 
   /**
@@ -430,7 +440,7 @@ class Puppeteer extends Helper {
    * @param {function} fn async function that is executed with Puppeteer as argument
    */
   usePuppeteerTo(description, fn) {
-    return this._useTo(...arguments);
+    return this._useTo(...arguments)
   }
 
   /**
@@ -444,7 +454,7 @@ class Puppeteer extends Helper {
    * ```
    */
   amAcceptingPopups() {
-    popupStore.actionType = 'accept';
+    popupStore.actionType = 'accept'
   }
 
   /**
@@ -453,7 +463,7 @@ class Puppeteer extends Helper {
    * libraries](http://jster.net/category/windows-modals-popups).
    */
   acceptPopup() {
-    popupStore.assertPopupActionType('accept');
+    popupStore.assertPopupActionType('accept')
   }
 
   /**
@@ -467,23 +477,23 @@ class Puppeteer extends Helper {
    * ```
    */
   amCancellingPopups() {
-    popupStore.actionType = 'cancel';
+    popupStore.actionType = 'cancel'
   }
 
   /**
    * Dismisses the active JavaScript popup, as created by window.alert|window.confirm|window.prompt.
    */
   cancelPopup() {
-    popupStore.assertPopupActionType('cancel');
+    popupStore.assertPopupActionType('cancel')
   }
 
   /**
    * {{> seeInPopup }}
    */
   async seeInPopup(text) {
-    popupStore.assertPopupVisible();
-    const popupText = await popupStore.popup.message();
-    stringIncludes('text in popup').assert(text, popupText);
+    popupStore.assertPopupVisible()
+    const popupText = await popupStore.popup.message()
+    stringIncludes('text in popup').assert(text, popupText)
   }
 
   /**
@@ -491,25 +501,25 @@ class Puppeteer extends Helper {
    * @param {object} page page to set
    */
   async _setPage(page) {
-    page = await page;
-    this._addPopupListener(page);
-    this._addErrorListener(page);
-    this.page = page;
-    if (!page) return;
-    page.setDefaultNavigationTimeout(this.options.getPageTimeout);
-    this.context = await this.page.$('body');
+    page = await page
+    this._addPopupListener(page)
+    this._addErrorListener(page)
+    this.page = page
+    if (!page) return
+    page.setDefaultNavigationTimeout(this.options.getPageTimeout)
+    this.context = await this.page.$('body')
     if (this.options.browser === 'chrome') {
-      await page.bringToFront();
+      await page.bringToFront()
     }
   }
 
   async _addErrorListener(page) {
     if (!page) {
-      return;
+      return
     }
     page.on('error', async (error) => {
-      console.error('Puppeteer page error', error);
-    });
+      console.error('Puppeteer page error', error)
+    })
   }
 
   /**
@@ -521,32 +531,32 @@ class Puppeteer extends Helper {
    */
   _addPopupListener(page) {
     if (!page) {
-      return;
+      return
     }
     page.on('dialog', async (dialog) => {
-      popupStore.popup = dialog;
-      const action = popupStore.actionType || this.options.defaultPopupAction;
-      await this._waitForAction();
+      popupStore.popup = dialog
+      const action = popupStore.actionType || this.options.defaultPopupAction
+      await this._waitForAction()
 
       switch (action) {
         case 'accept':
-          return dialog.accept();
+          return dialog.accept()
 
         case 'cancel':
-          return dialog.dismiss();
+          return dialog.dismiss()
 
         default: {
-          throw new Error('Unknown popup action type. Only "accept" or "cancel" are accepted');
+          throw new Error('Unknown popup action type. Only "accept" or "cancel" are accepted')
         }
       }
-    });
+    })
   }
 
   /**
    * Gets page URL including hash.
    */
   async _getPageUrl() {
-    return this.executeScript(() => window.location.href);
+    return this.executeScript(() => window.location.href)
   }
 
   /**
@@ -559,128 +569,134 @@ class Puppeteer extends Helper {
    */
   async grabPopupText() {
     if (popupStore.popup) {
-      return popupStore.popup.message();
+      return popupStore.popup.message()
     }
-    return null;
+    return null
   }
 
   async _startBrowser() {
     if (this.isRemoteBrowser) {
       try {
-        this.browser = await puppeteer.connect(this.puppeteerOptions);
+        this.browser = await puppeteer.connect(this.puppeteerOptions)
       } catch (err) {
         if (err.toString().indexOf('ECONNREFUSED')) {
-          throw new RemoteBrowserConnectionRefused(err);
+          throw new RemoteBrowserConnectionRefused(err)
         }
-        throw err;
+        throw err
       }
     } else {
-      this.browser = await puppeteer.launch(this.puppeteerOptions);
+      this.browser = await puppeteer.launch(this.puppeteerOptions)
     }
 
-    this.browser.on('targetcreated', target => target.page().then(page => targetCreatedHandler.call(this, page)).catch((e) => {
-      console.error('Puppeteer page error', e);
-    }));
+    this.browser.on('targetcreated', (target) =>
+      target
+        .page()
+        .then((page) => targetCreatedHandler.call(this, page))
+        .catch((e) => {
+          console.error('Puppeteer page error', e)
+        }),
+    )
     this.browser.on('targetchanged', (target) => {
-      this.debugSection('Url', target.url());
-    });
+      this.debugSection('Url', target.url())
+    })
 
-    const existingPages = await this.browser.pages();
-    const mainPage = existingPages[0] || await this.browser.newPage();
+    const existingPages = await this.browser.pages()
+    const mainPage = existingPages[0] || (await this.browser.newPage())
 
     if (existingPages.length) {
       // Run the handler as it will not be triggered if the page already exists
-      targetCreatedHandler.call(this, mainPage);
+      targetCreatedHandler.call(this, mainPage)
     }
-    await this._setPage(mainPage);
-    await this.closeOtherTabs();
+    await this._setPage(mainPage)
+    await this.closeOtherTabs()
 
-    this.isRunning = true;
+    this.isRunning = true
   }
 
   async _stopBrowser() {
-    this.withinLocator = null;
-    this._setPage(null);
-    this.context = null;
-    popupStore.clear();
-    this.isAuthenticated = false;
-    await this.browser.close();
+    this.withinLocator = null
+    this._setPage(null)
+    this.context = null
+    popupStore.clear()
+    this.isAuthenticated = false
+    await this.browser.close()
     if (this.isRemoteBrowser) {
-      await this.browser.disconnect();
+      await this.browser.disconnect()
     }
   }
 
   async _evaluateHandeInContext(...args) {
-    const context = await this._getContext();
-    return context.evaluateHandle(...args);
+    const context = await this._getContext()
+    return context.evaluateHandle(...args)
   }
 
   async _withinBegin(locator) {
     if (this.withinLocator) {
-      throw new Error('Can\'t start within block inside another within block');
+      throw new Error("Can't start within block inside another within block")
     }
 
-    const frame = isFrameLocator(locator);
+    const frame = isFrameLocator(locator)
 
     if (frame) {
       if (Array.isArray(frame)) {
-        return this.switchTo(null)
-          .then(() => frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve()));
+        return this.switchTo(null).then(() =>
+          frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve()),
+        )
       }
-      await this.switchTo(frame);
-      this.withinLocator = new Locator(frame);
-      return;
+      await this.switchTo(frame)
+      this.withinLocator = new Locator(frame)
+      return
     }
 
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
-    this.context = els[0];
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
+    this.context = els[0]
 
-    this.withinLocator = new Locator(locator);
+    this.withinLocator = new Locator(locator)
   }
 
   async _withinEnd() {
-    this.withinLocator = null;
-    this.context = await this.page.mainFrame().$('body');
+    this.withinLocator = null
+    this.context = await this.page.mainFrame().$('body')
   }
 
   _extractDataFromPerformanceTiming(timing, ...dataNames) {
-    const navigationStart = timing.navigationStart;
+    const navigationStart = timing.navigationStart
 
-    const extractedData = {};
+    const extractedData = {}
     dataNames.forEach((name) => {
-      extractedData[name] = timing[name] - navigationStart;
-    });
+      extractedData[name] = timing[name] - navigationStart
+    })
 
-    return extractedData;
+    return extractedData
   }
 
   /**
    * {{> amOnPage }}
    */
   async amOnPage(url) {
-    if (!(/^\w+\:\/\//.test(url))) {
-      url = this.options.url + url;
+    if (!/^\w+\:\/\//.test(url)) {
+      url = this.options.url + url
     }
 
-    if (this.options.basicAuth && (this.isAuthenticated !== true)) {
+    if (this.options.basicAuth && this.isAuthenticated !== true) {
       if (url.includes(this.options.url)) {
-        await this.page.authenticate(this.options.basicAuth);
-        this.isAuthenticated = true;
+        await this.page.authenticate(this.options.basicAuth)
+        this.isAuthenticated = true
       }
     }
 
     if (this.options.trace) {
-      const fileName = `${`${global.output_dir}${path.sep}trace${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.json`;
-      const dir = path.dirname(fileName);
-      if (!fileExists(dir)) fs.mkdirSync(dir);
-      await this.page.tracing.start({ screenshots: true, path: fileName });
-      this.currentRunningTest.artifacts.trace = fileName;
+      const fileName = `${`${global.output_dir}${path.sep}trace${path.sep}${uuidv4()}_${clearString(this.currentRunningTest.title)}`.slice(0, 245)}.json`
+      const dir = path.dirname(fileName)
+      if (!fileExists(dir)) fs.mkdirSync(dir)
+      await this.page.tracing.start({ screenshots: true, path: fileName })
+      this.currentRunningTest.artifacts.trace = fileName
     }
 
-    await this.page.goto(url, { waitUntil: this.options.waitForNavigation });
+    await this.page.goto(url, { waitUntil: this.options.waitForNavigation })
 
-    const performanceTiming = JSON.parse(await this.page.evaluate(() => JSON.stringify(window.performance.timing)));
+    const performanceTiming = JSON.parse(await this.page.evaluate(() => JSON.stringify(window.performance.timing)))
 
     perfTiming = this._extractDataFromPerformanceTiming(
       performanceTiming,
@@ -688,9 +704,9 @@ class Puppeteer extends Helper {
       'domInteractive',
       'domContentLoadedEventEnd',
       'loadEventEnd',
-    );
+    )
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -704,11 +720,11 @@ class Puppeteer extends Helper {
    */
   async resizeWindow(width, height) {
     if (width === 'maximize') {
-      throw new Error('Puppeteer can\'t control windows, so it can\'t maximize it');
+      throw new Error("Puppeteer can't control windows, so it can't maximize it")
     }
 
-    await this.page.setViewport({ width, height });
-    return this._waitForAction();
+    await this.page.setViewport({ width, height })
+    return this._waitForAction()
   }
 
   /**
@@ -724,9 +740,9 @@ class Puppeteer extends Helper {
    */
   async setPuppeteerRequestHeaders(customHeaders) {
     if (!customHeaders) {
-      throw new Error('Cannot send empty headers.');
+      throw new Error('Cannot send empty headers.')
     }
-    return this.page.setExtraHTTPHeaders(customHeaders);
+    return this.page.setExtraHTTPHeaders(customHeaders)
   }
 
   /**
@@ -734,13 +750,13 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
 
     // Use manual mouse.move instead of .hover() so the offset can be added to the coordinates
-    const { x, y } = await getClickablePoint(els[0]);
-    await this.page.mouse.move(x + offsetX, y + offsetY);
-    return this._waitForAction();
+    const { x, y } = await getClickablePoint(els[0])
+    await this.page.mouse.move(x + offsetX, y + offsetY)
+    return this._waitForAction()
   }
 
   /**
@@ -748,13 +764,13 @@ class Puppeteer extends Helper {
    *
    */
   async focus(locator) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator, 'Element to focus');
-    const el = els[0];
+    const els = await this._locate(locator)
+    assertElementExists(els, locator, 'Element to focus')
+    const el = els[0]
 
-    await el.click();
-    await el.focus();
-    return this._waitForAction();
+    await el.click()
+    await el.focus()
+    return this._waitForAction()
   }
 
   /**
@@ -762,25 +778,25 @@ class Puppeteer extends Helper {
    *
    */
   async blur(locator) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator, 'Element to blur');
+    const els = await this._locate(locator)
+    assertElementExists(els, locator, 'Element to blur')
 
-    await blurElement(els[0], this.page);
-    return this._waitForAction();
+    await blurElement(els[0], this.page)
+    return this._waitForAction()
   }
 
   /**
    * {{> dragAndDrop }}
    */
   async dragAndDrop(srcElement, destElement) {
-    return proceedDragAndDrop.call(this, srcElement, destElement);
+    return proceedDragAndDrop.call(this, srcElement, destElement)
   }
 
   /**
    * {{> refreshPage }}
    */
   async refreshPage() {
-    return this.page.reload({ timeout: this.options.getPageTimeout, waitUntil: this.options.waitForNavigation });
+    return this.page.reload({ timeout: this.options.getPageTimeout, waitUntil: this.options.waitForNavigation })
   }
 
   /**
@@ -788,8 +804,8 @@ class Puppeteer extends Helper {
    */
   scrollPageToTop() {
     return this.executeScript(() => {
-      window.scrollTo(0, 0);
-    });
+      window.scrollTo(0, 0)
+    })
   }
 
   /**
@@ -797,16 +813,13 @@ class Puppeteer extends Helper {
    */
   scrollPageToBottom() {
     return this.executeScript(() => {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight,
-      ));
-    });
+      const body = document.body
+      const html = document.documentElement
+      window.scrollTo(
+        0,
+        Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
+      )
+    })
   }
 
   /**
@@ -814,30 +827,34 @@ class Puppeteer 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 els = await this._locate(locator);
-      assertElementExists(els, locator, 'Element');
-      const el = els[0];
-      await el.evaluate((el) => el.scrollIntoView());
-      const elementCoordinates = await getClickablePoint(els[0]);
-      await this.executeScript((x, y) => window.scrollBy(x, y), elementCoordinates.x + offsetX, elementCoordinates.y + offsetY);
+      const els = await this._locate(locator)
+      assertElementExists(els, locator, 'Element')
+      const el = els[0]
+      await el.evaluate((el) => el.scrollIntoView())
+      const elementCoordinates = await getClickablePoint(els[0])
+      await this.executeScript(
+        (x, y) => window.scrollBy(x, y),
+        elementCoordinates.x + offsetX,
+        elementCoordinates.y + offsetY,
+      )
     } else {
-      await this.executeScript((x, y) => window.scrollTo(x, y), offsetX, offsetY);
+      await this.executeScript((x, y) => window.scrollTo(x, y), offsetX, offsetY)
     }
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
    * {{> seeInTitle }}
    */
   async seeInTitle(text) {
-    const title = await this.page.title();
-    stringIncludes('web page title').assert(text, title);
+    const title = await this.page.title()
+    stringIncludes('web page title').assert(text, title)
   }
 
   /**
@@ -848,34 +865,34 @@ class Puppeteer extends Helper {
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
+        y: window.pageYOffset,
+      }
     }
     /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
+    return this.executeScript(getScrollPosition)
   }
 
   /**
    * {{> seeTitleEquals }}
    */
   async seeTitleEquals(text) {
-    const title = await this.page.title();
-    return equals('web page title').assert(title, text);
+    const title = await this.page.title()
+    return equals('web page title').assert(title, text)
   }
 
   /**
    * {{> dontSeeInTitle }}
    */
   async dontSeeInTitle(text) {
-    const title = await this.page.title();
-    stringIncludes('web page title').negate(text, title);
+    const title = await this.page.title()
+    stringIncludes('web page title').negate(text, title)
   }
 
   /**
    * {{> grabTitle }}
    */
   async grabTitle() {
-    return this.page.title();
+    return this.page.title()
   }
 
   /**
@@ -889,8 +906,8 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async _locate(locator) {
-    const context = await this.context;
-    return findElements.call(this, context, locator);
+    const context = await this.context
+    return findElements.call(this, context, locator)
   }
 
   /**
@@ -902,10 +919,10 @@ class Puppeteer extends Helper {
    * ```
    */
   async _locateCheckable(locator, providedContext = null) {
-    const context = providedContext || await this._getContext();
-    const els = await findCheckable.call(this, locator, context);
-    assertElementExists(els[0], locator, 'Checkbox or radio');
-    return els[0];
+    const context = providedContext || (await this._getContext())
+    const els = await findCheckable.call(this, locator, context)
+    assertElementExists(els[0], locator, 'Checkbox or radio')
+    return els[0]
   }
 
   /**
@@ -916,8 +933,8 @@ class Puppeteer extends Helper {
    * ```
    */
   async _locateClickable(locator) {
-    const context = await this.context;
-    return findClickable.call(this, context, locator);
+    const context = await this.context
+    return findClickable.call(this, context, locator)
   }
 
   /**
@@ -928,7 +945,7 @@ class Puppeteer extends Helper {
    * ```
    */
   async _locateFields(locator) {
-    return findFields.call(this, locator);
+    return findFields.call(this, locator)
   }
 
   /**
@@ -936,7 +953,7 @@ class Puppeteer extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator);
+    return this._locate(locator)
   }
 
   /**
@@ -950,17 +967,17 @@ class Puppeteer extends Helper {
    * @param {number} [num=1]
    */
   async switchToNextTab(num = 1) {
-    const pages = await this.browser.pages();
-    const index = pages.indexOf(this.page);
-    this.withinLocator = null;
-    const page = pages[index + num];
+    const pages = await this.browser.pages()
+    const index = pages.indexOf(this.page)
+    this.withinLocator = null
+    const page = pages[index + num]
 
     if (!page) {
-      throw new Error(`There is no ability to switch to next tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to next tab with offset ${num}`)
     }
 
-    await this._setPage(page);
-    return this._waitForAction();
+    await this._setPage(page)
+    return this._waitForAction()
   }
 
   /**
@@ -973,17 +990,17 @@ class Puppeteer extends Helper {
    * @param {number} [num=1]
    */
   async switchToPreviousTab(num = 1) {
-    const pages = await this.browser.pages();
-    const index = pages.indexOf(this.page);
-    this.withinLocator = null;
-    const page = pages[index - num];
+    const pages = await this.browser.pages()
+    const index = pages.indexOf(this.page)
+    this.withinLocator = null
+    const page = pages[index - num]
 
     if (!page) {
-      throw new Error(`There is no ability to switch to previous tab with offset ${num}`);
+      throw new Error(`There is no ability to switch to previous tab with offset ${num}`)
     }
 
-    await this._setPage(page);
-    return this._waitForAction();
+    await this._setPage(page)
+    return this._waitForAction()
   }
 
   /**
@@ -994,10 +1011,10 @@ class Puppeteer extends Helper {
    * ```
    */
   async closeCurrentTab() {
-    const oldPage = this.page;
-    await this.switchToPreviousTab();
-    await oldPage.close();
-    return this._waitForAction();
+    const oldPage = this.page
+    await this.switchToPreviousTab()
+    await oldPage.close()
+    return this._waitForAction()
   }
 
   /**
@@ -1008,15 +1025,15 @@ class Puppeteer extends Helper {
    * ```
    */
   async closeOtherTabs() {
-    const pages = await this.browser.pages();
-    const otherPages = pages.filter(page => page !== this.page);
+    const pages = await this.browser.pages()
+    const otherPages = pages.filter((page) => page !== this.page)
 
-    let p = Promise.resolve();
+    let p = Promise.resolve()
     otherPages.forEach((page) => {
-      p = p.then(() => page.close());
-    });
-    await p;
-    return this._waitForAction();
+      p = p.then(() => page.close())
+    })
+    await p
+    return this._waitForAction()
   }
 
   /**
@@ -1027,16 +1044,16 @@ class Puppeteer extends Helper {
    * ```
    */
   async openNewTab() {
-    await this._setPage(await this.browser.newPage());
-    return this._waitForAction();
+    await this._setPage(await this.browser.newPage())
+    return this._waitForAction()
   }
 
   /**
    * {{> grabNumberOfOpenTabs }}
    */
   async grabNumberOfOpenTabs() {
-    const pages = await this.browser.pages();
-    return pages.length;
+    const pages = await this.browser.pages()
+    return pages.length
   }
 
   /**
@@ -1044,14 +1061,22 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeElement(locator) {
-    let els = await this._locate(locator);
-    els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
+    let els = await this._locate(locator)
+    els = (await Promise.all(els.map((el) => el.boundingBox() && el))).filter((v) => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
-    els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
+    els = await Promise.all(
+      els.map(
+        async (el) =>
+          (await el.evaluate(
+            (node) =>
+              window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none',
+          )) && el,
+      ),
+    )
     try {
-      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'));
+      return empty('visible elements').negate(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      dontSeeElementError(locator);
+      dontSeeElementError(locator)
     }
   }
 
@@ -1060,14 +1085,22 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async dontSeeElement(locator) {
-    let els = await this._locate(locator);
-    els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
+    let els = await this._locate(locator)
+    els = (await Promise.all(els.map((el) => el.boundingBox() && el))).filter((v) => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
-    els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
+    els = await Promise.all(
+      els.map(
+        async (el) =>
+          (await el.evaluate(
+            (node) =>
+              window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none',
+          )) && el,
+      ),
+    )
     try {
-      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'));
+      return empty('visible elements').assert(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      seeElementError(locator);
+      seeElementError(locator)
     }
   }
 
@@ -1075,11 +1108,11 @@ class Puppeteer extends Helper {
    * {{> seeElementInDOM }}
    */
   async seeElementInDOM(locator) {
-    const els = await this._locate(locator);
+    const els = await this._locate(locator)
     try {
-      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'));
+      return empty('elements on page').negate(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      dontSeeElementInDOMError(locator);
+      dontSeeElementInDOMError(locator)
     }
   }
 
@@ -1087,11 +1120,11 @@ class Puppeteer extends Helper {
    * {{> dontSeeElementInDOM }}
    */
   async dontSeeElementInDOM(locator) {
-    const els = await this._locate(locator);
+    const els = await this._locate(locator)
     try {
-      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'));
+      return empty('elements on a page').assert(els.filter((v) => v).fill('ELEMENT'))
     } catch (e) {
-      seeElementInDOMError(locator);
+      seeElementInDOMError(locator)
     }
   }
 
@@ -1101,7 +1134,7 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async click(locator, context = null) {
-    return proceedClick.call(this, locator, context);
+    return proceedClick.call(this, locator, context)
   }
 
   /**
@@ -1110,28 +1143,33 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async forceClick(locator, context = null) {
-    let matcher = await this.context;
+    let matcher = await this.context
     if (context) {
-      const els = await this._locate(context);
-      assertElementExists(els, context);
-      matcher = els[0];
+      const els = await this._locate(context)
+      assertElementExists(els, context)
+      matcher = els[0]
     }
 
-    const els = await findClickable.call(this, matcher, locator);
+    const els = await findClickable.call(this, matcher, locator)
     if (context) {
-      assertElementExists(els, locator, 'Clickable element', `was not found inside element ${new Locator(context).toString()}`);
+      assertElementExists(
+        els,
+        locator,
+        'Clickable element',
+        `was not found inside element ${new Locator(context).toString()}`,
+      )
     } else {
-      assertElementExists(els, locator, 'Clickable element');
+      assertElementExists(els, locator, 'Clickable element')
     }
-    const elem = els[0];
+    const elem = els[0]
     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)
   }
 
   /**
@@ -1140,7 +1178,7 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async clickLink(locator, context = null) {
-    return proceedClick.call(this, locator, context, { waitForNavigation: true });
+    return proceedClick.call(this, locator, context, { waitForNavigation: true })
   }
 
   /**
@@ -1161,16 +1199,16 @@ class Puppeteer extends Helper {
    * @param {string} [downloadPath='downloads'] change this parameter to set another directory for saving
    */
   async handleDownloads(downloadPath = 'downloads') {
-    downloadPath = path.join(global.output_dir, downloadPath);
+    downloadPath = path.join(global.output_dir, downloadPath)
     if (!fs.existsSync(downloadPath)) {
-      fs.mkdirSync(downloadPath, '0777');
+      fs.mkdirSync(downloadPath, '0777')
     }
-    fsExtra.emptyDirSync(downloadPath);
+    fsExtra.emptyDirSync(downloadPath)
 
     try {
-      return this.page._client.send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath });
+      return this.page._client.send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath })
     } catch (e) {
-      return this.page._client().send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath });
+      return this.page._client().send('Page.setDownloadBehavior', { behavior: 'allow', downloadPath })
     }
   }
 
@@ -1180,27 +1218,27 @@ class Puppeteer extends Helper {
    * Please use `handleDownloads()` instead.
    */
   async downloadFile(locator, customName) {
-    let fileName;
-    await this.page.setRequestInterception(true);
+    let fileName
+    await this.page.setRequestInterception(true)
 
     const xRequest = await new Promise((resolve) => {
       this.page.on('request', (request) => {
-        console.log('rq', request, customName);
-        const grabbedFileName = request.url().split('/')[request.url().split('/').length - 1];
-        const fileExtension = request.url().split('/')[request.url().split('/').length - 1].split('.')[1];
-        console.log('nm', customName, fileExtension);
+        console.log('rq', request, customName)
+        const grabbedFileName = request.url().split('/')[request.url().split('/').length - 1]
+        const fileExtension = request.url().split('/')[request.url().split('/').length - 1].split('.')[1]
+        console.log('nm', customName, fileExtension)
         if (customName && path.extname(customName) !== fileExtension) {
-          console.log('bypassing a request');
-          request.continue();
-          return;
+          console.log('bypassing a request')
+          request.continue()
+          return
         }
-        customName ? fileName = `${customName}.${fileExtension}` : fileName = grabbedFileName;
-        request.abort();
-        resolve(request);
-      });
-    });
+        customName ? (fileName = `${customName}.${fileExtension}`) : (fileName = grabbedFileName)
+        request.abort()
+        resolve(request)
+      })
+    })
 
-    await this.click(locator);
+    await this.click(locator)
 
     const options = {
       encoding: null,
@@ -1208,10 +1246,10 @@ class Puppeteer extends Helper {
       uri: xRequest._url,
       body: xRequest._postData,
       headers: xRequest._headers,
-    };
+    }
 
-    const cookies = await this.page.cookies();
-    options.headers.Cookie = cookies.map(ck => `${ck.name}=${ck.value}`).join(';');
+    const cookies = await this.page.cookies()
+    options.headers.Cookie = cookies.map((ck) => `${ck.name}=${ck.value}`).join(';')
 
     const response = await axios({
       method: options.method,
@@ -1219,24 +1257,26 @@ class Puppeteer extends Helper {
       headers: options.headers,
       responseType: 'arraybuffer',
       onDownloadProgress(e) {
-        console.log('+', e);
+        console.log('+', e)
       },
-    });
+    })
 
-    const outputFile = path.join(`${global.output_dir}/${fileName}`);
+    const outputFile = path.join(`${global.output_dir}/${fileName}`)
 
     try {
       await new Promise((resolve, reject) => {
-        const wstream = fs.createWriteStream(outputFile);
-        console.log(response);
-        wstream.write(response.data);
-        wstream.end();
-        this.debug(`File is downloaded in ${outputFile}`);
-        wstream.on('finish', () => { resolve(fileName); });
-        wstream.on('error', reject);
-      });
+        const wstream = fs.createWriteStream(outputFile)
+        console.log(response)
+        wstream.write(response.data)
+        wstream.end()
+        this.debug(`File is downloaded in ${outputFile}`)
+        wstream.on('finish', () => {
+          resolve(fileName)
+        })
+        wstream.on('error', reject)
+      })
     } catch (error) {
-      throw new Error(`There is something wrong with downloaded file. ${error}`);
+      throw new Error(`There is something wrong with downloaded file. ${error}`)
     }
   }
 
@@ -1246,7 +1286,7 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async doubleClick(locator, context = null) {
-    return proceedClick.call(this, locator, context, { clickCount: 2 });
+    return proceedClick.call(this, locator, context, { clickCount: 2 })
   }
 
   /**
@@ -1255,20 +1295,19 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async rightClick(locator, context = null) {
-    return proceedClick.call(this, locator, context, { button: 'right' });
+    return proceedClick.call(this, locator, context, { button: 'right' })
   }
 
   /**
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const elm = await this._locateCheckable(field, context);
-    const curentlyChecked = await elm.getProperty('checked')
-      .then(checkedProperty => checkedProperty.jsonValue());
+    const elm = await this._locateCheckable(field, context)
+    const curentlyChecked = await elm.getProperty('checked').then((checkedProperty) => checkedProperty.jsonValue())
     // Only check if NOT currently checked
     if (!curentlyChecked) {
-      await elm.click();
-      return this._waitForAction();
+      await elm.click()
+      return this._waitForAction()
     }
   }
 
@@ -1276,13 +1315,12 @@ class Puppeteer extends Helper {
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const elm = await this._locateCheckable(field, context);
-    const curentlyChecked = await elm.getProperty('checked')
-      .then(checkedProperty => checkedProperty.jsonValue());
+    const elm = await this._locateCheckable(field, context)
+    const curentlyChecked = await elm.getProperty('checked').then((checkedProperty) => checkedProperty.jsonValue())
     // Only uncheck if currently checked
     if (curentlyChecked) {
-      await elm.click();
-      return this._waitForAction();
+      await elm.click()
+      return this._waitForAction()
     }
   }
 
@@ -1290,32 +1328,32 @@ class Puppeteer extends Helper {
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'assert', field);
+    return proceedIsChecked.call(this, 'assert', field)
   }
 
   /**
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'negate', field);
+    return proceedIsChecked.call(this, 'negate', field)
   }
 
   /**
    * {{> pressKeyDown }}
    */
   async pressKeyDown(key) {
-    key = getNormalizedKey.call(this, key);
-    await this.page.keyboard.down(key);
-    return this._waitForAction();
+    key = getNormalizedKey.call(this, key)
+    await this.page.keyboard.down(key)
+    return this._waitForAction()
   }
 
   /**
    * {{> pressKeyUp }}
    */
   async pressKeyUp(key) {
-    key = getNormalizedKey.call(this, key);
-    await this.page.keyboard.up(key);
-    return this._waitForAction();
+    key = getNormalizedKey.call(this, key)
+    await this.page.keyboard.up(key)
+    return this._waitForAction()
   }
 
   /**
@@ -1324,28 +1362,28 @@ class Puppeteer 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.page.keyboard.down(modifier);
+      await this.page.keyboard.down(modifier)
     }
-    await this.page.keyboard.press(key);
+    await this.page.keyboard.press(key)
     for (const modifier of modifiers) {
-      await this.page.keyboard.up(modifier);
+      await this.page.keyboard.up(modifier)
     }
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -1353,13 +1391,13 @@ class Puppeteer extends Helper {
    */
   async type(keys, delay = null) {
     if (!Array.isArray(keys)) {
-      keys = keys.toString();
-      keys = keys.split('');
+      keys = keys.toString()
+      keys = keys.split('')
     }
 
     for (const key of keys) {
-      await this.page.keyboard.press(key);
-      if (delay) await this.wait(delay / 1000);
+      await this.page.keyboard.press(key)
+      if (delay) await this.wait(delay / 1000)
     }
   }
 
@@ -1368,28 +1406,28 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async fillField(field, value) {
-    const els = await findVisibleFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = els[0];
-    const tag = await el.getProperty('tagName').then(el => el.jsonValue());
-    const editable = await el.getProperty('contenteditable').then(el => el.jsonValue());
+    const els = await findVisibleFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = els[0]
+    const tag = await el.getProperty('tagName').then((el) => el.jsonValue())
+    const editable = await el.getProperty('contenteditable').then((el) => el.jsonValue())
     if (tag === 'INPUT' || tag === 'TEXTAREA') {
-      await this._evaluateHandeInContext(el => el.value = '', el);
+      await this._evaluateHandeInContext((el) => (el.value = ''), el)
     } else if (editable) {
-      await this._evaluateHandeInContext(el => el.innerHTML = '', el);
+      await this._evaluateHandeInContext((el) => (el.innerHTML = ''), el)
     }
 
-    highlightActiveElement.call(this, el, await this._getContext());
-    await el.type(value.toString(), { delay: this.options.pressKeyDelay });
+    highlightActiveElement.call(this, el, await this._getContext())
+    await el.type(value.toString(), { delay: this.options.pressKeyDelay })
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
    * {{> clearField }}
    */
   async clearField(field) {
-    return this.fillField(field, '');
+    return this.fillField(field, '')
   }
 
   /**
@@ -1398,28 +1436,28 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async appendField(field, value) {
-    const els = await findVisibleFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    highlightActiveElement.call(this, els[0], await this._getContext());
-    await els[0].press('End');
-    await els[0].type(value.toString(), { delay: this.options.pressKeyDelay });
-    return this._waitForAction();
+    const els = await findVisibleFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    highlightActiveElement.call(this, els[0], await this._getContext())
+    await els[0].press('End')
+    await els[0].type(value.toString(), { delay: this.options.pressKeyDelay })
+    return this._waitForAction()
   }
 
   /**
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'assert', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'assert', field, _value)
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
-    return proceedSeeInField.call(this, 'negate', field, _value);
+    const _value = typeof value === 'boolean' ? value : value.toString()
+    return proceedSeeInField.call(this, 'negate', field, _value)
   }
 
   /**
@@ -1428,48 +1466,48 @@ class Puppeteer extends Helper {
    * {{> attachFile }}
    */
   async attachFile(locator, pathToFile) {
-    const file = path.join(global.codecept_dir, pathToFile);
+    const 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 els = await findFields.call(this, locator);
-    assertElementExists(els, locator, 'Field');
-    await els[0].uploadFile(file);
-    return this._waitForAction();
+    const els = await findFields.call(this, locator)
+    assertElementExists(els, locator, 'Field')
+    await els[0].uploadFile(file)
+    return this._waitForAction()
   }
 
   /**
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const els = await findVisibleFields.call(this, select);
-    assertElementExists(els, select, 'Selectable field');
-    const el = els[0];
-    if (await el.getProperty('tagName').then(t => t.jsonValue()) !== 'SELECT') {
-      throw new Error('Element is not <select>');
+    const els = await findVisibleFields.call(this, select)
+    assertElementExists(els, select, 'Selectable field')
+    const el = els[0]
+    if ((await el.getProperty('tagName').then((t) => t.jsonValue())) !== 'SELECT') {
+      throw new Error('Element is not <select>')
     }
-    highlightActiveElement.call(this, els[0], await this._getContext());
-    if (!Array.isArray(option)) option = [option];
+    highlightActiveElement.call(this, els[0], await this._getContext())
+    if (!Array.isArray(option)) option = [option]
 
     for (const key in option) {
-      const opt = xpathLocator.literal(option[key]);
-      let optEl = await findElements.call(this, el, { xpath: Locator.select.byVisibleText(opt) });
+      const opt = xpathLocator.literal(option[key])
+      let optEl = await findElements.call(this, el, { xpath: Locator.select.byVisibleText(opt) })
       if (optEl.length) {
-        this._evaluateHandeInContext(el => el.selected = true, optEl[0]);
-        continue;
+        this._evaluateHandeInContext((el) => (el.selected = true), optEl[0])
+        continue
       }
-      optEl = await findElements.call(this, el, { xpath: Locator.select.byValue(opt) });
+      optEl = await findElements.call(this, el, { xpath: Locator.select.byValue(opt) })
       if (optEl.length) {
-        this._evaluateHandeInContext(el => el.selected = true, optEl[0]);
+        this._evaluateHandeInContext((el) => (el.selected = true), optEl[0])
       }
     }
     await this._evaluateHandeInContext((element) => {
-      element.dispatchEvent(new Event('input', { bubbles: true }));
-      element.dispatchEvent(new Event('change', { bubbles: true }));
-    }, el);
+      element.dispatchEvent(new Event('input', { bubbles: true }))
+      element.dispatchEvent(new Event('change', { bubbles: true }))
+    }, el)
 
-    return this._waitForAction();
+    return this._waitForAction()
   }
 
   /**
@@ -1477,40 +1515,48 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async grabNumberOfVisibleElements(locator) {
-    let els = await this._locate(locator);
-    els = (await Promise.all(els.map(el => el.boundingBox() && el))).filter(v => v);
+    let els = await this._locate(locator)
+    els = (await Promise.all(els.map((el) => el.boundingBox() && el))).filter((v) => v)
     // Puppeteer visibility was ignored? | Remove when Puppeteer is fixed
-    els = await Promise.all(els.map(async el => (await el.evaluate(node => window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none')) && el));
+    els = await Promise.all(
+      els.map(
+        async (el) =>
+          (await el.evaluate(
+            (node) =>
+              window.getComputedStyle(node).visibility !== 'hidden' && window.getComputedStyle(node).display !== 'none',
+          )) && el,
+      ),
+    )
 
-    return els.filter(v => v).length;
+    return els.filter((v) => v).length
   }
 
   /**
    * {{> seeInCurrentUrl }}
    */
   async seeInCurrentUrl(url) {
-    stringIncludes('url').assert(url, await this._getPageUrl());
+    stringIncludes('url').assert(url, await this._getPageUrl())
   }
 
   /**
    * {{> dontSeeInCurrentUrl }}
    */
   async dontSeeInCurrentUrl(url) {
-    stringIncludes('url').negate(url, await this._getPageUrl());
+    stringIncludes('url').negate(url, await this._getPageUrl())
   }
 
   /**
    * {{> seeCurrentUrlEquals }}
    */
   async seeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).assert(url, await this._getPageUrl());
+    urlEquals(this.options.url).assert(url, await this._getPageUrl())
   }
 
   /**
    * {{> dontSeeCurrentUrlEquals }}
    */
   async dontSeeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).negate(url, await this._getPageUrl());
+    urlEquals(this.options.url).negate(url, await this._getPageUrl())
   }
 
   /**
@@ -1519,14 +1565,14 @@ class Puppeteer 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)
   }
 
   /**
@@ -1535,14 +1581,14 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async dontSee(text, context = null) {
-    return proceedSee.call(this, 'negate', text, context);
+    return proceedSee.call(this, 'negate', text, context)
   }
 
   /**
    * {{> grabSource }}
    */
   async grabSource() {
-    return this.page.content();
+    return this.page.content()
   }
 
   /**
@@ -1555,32 +1601,32 @@ class Puppeteer extends Helper {
    * @return {Promise<any[]>}
    */
   async grabBrowserLogs() {
-    const logs = consoleLogStore.entries;
-    consoleLogStore.clear();
-    return logs;
+    const logs = consoleLogStore.entries
+    consoleLogStore.clear()
+    return logs
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    return this._getPageUrl();
+    return this._getPageUrl()
   }
 
   /**
    * {{> seeInSource }}
    */
   async seeInSource(text) {
-    const source = await this.page.content();
-    stringIncludes('HTML source of a page').assert(text, source);
+    const source = await this.page.content()
+    stringIncludes('HTML source of a page').assert(text, source)
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    const source = await this.page.content();
-    stringIncludes('HTML source of a page').negate(text, source);
+    const source = await this.page.content()
+    stringIncludes('HTML source of a page').negate(text, source)
   }
 
   /**
@@ -1589,8 +1635,10 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeNumberOfElements(locator, num) {
-    const elements = await this._locate(locator);
-    return equals(`expected number of elements (${(new Locator(locator))}) is ${num}, but found ${elements.length}`).assert(elements.length, num);
+    const elements = await this._locate(locator)
+    return equals(
+      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
+    ).assert(elements.length, num)
   }
 
   /**
@@ -1599,8 +1647,11 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const res = await this.grabNumberOfVisibleElements(locator);
-    return equals(`expected number of visible elements (${(new Locator(locator))}) is ${num}, but found ${res}`).assert(res, num);
+    const res = await this.grabNumberOfVisibleElements(locator)
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
+      res,
+      num,
+    )
   }
 
   /**
@@ -1608,9 +1659,9 @@ class Puppeteer extends Helper {
    */
   async setCookie(cookie) {
     if (Array.isArray(cookie)) {
-      return this.page.setCookie(...cookie);
+      return this.page.setCookie(...cookie)
     }
-    return this.page.setCookie(cookie);
+    return this.page.setCookie(cookie)
   }
 
   /**
@@ -1618,16 +1669,16 @@ class Puppeteer extends Helper {
    *
    */
   async seeCookie(name) {
-    const cookies = await this.page.cookies();
-    empty(`cookie ${name} to be set`).negate(cookies.filter(c => c.name === name));
+    const cookies = await this.page.cookies()
+    empty(`cookie ${name} to be set`).negate(cookies.filter((c) => c.name === name))
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    const cookies = await this.page.cookies();
-    empty(`cookie ${name} not to be set`).assert(cookies.filter(c => c.name === name));
+    const cookies = await this.page.cookies()
+    empty(`cookie ${name} not to be set`).assert(cookies.filter((c) => c.name === name))
   }
 
   /**
@@ -1636,10 +1687,10 @@ class Puppeteer extends Helper {
    * Returns cookie in JSON format. If name not passed returns all cookies for this domain.
    */
   async grabCookie(name) {
-    const cookies = await this.page.cookies();
-    if (!name) return cookies;
-    const cookie = cookies.filter(c => c.name === name);
-    if (cookie[0]) return cookie[0];
+    const cookies = await this.page.cookies()
+    if (!name) return cookies
+    const cookie = cookies.filter((c) => c.name === name)
+    if (cookie[0]) return cookie[0]
   }
 
   /**
@@ -1647,44 +1698,47 @@ class Puppeteer extends Helper {
    */
   async waitForCookie(name, sec) {
     // by default, we will retry 3 times
-    let retries = 3;
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    let retries = 3
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
     if (sec) {
-      retries = sec;
+      retries = sec
     } else {
-      retries = Math.ceil(waitTimeout / 1000) - 1;
+      retries = Math.ceil(waitTimeout / 1000) - 1
     }
 
-    return promiseRetry(async (retry, number) => {
-      const _grabCookie = async (name) => {
-        const cookies = await this.page.cookies();
-        const cookie = cookies.filter(c => c.name === 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 cookies = await this.page.cookies()
+          const cookie = cookies.filter((c) => c.name === 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 },
+    )
   }
 
   /**
    * {{> clearCookie }}
    */
   async clearCookie(name) {
-    const cookies = await this.page.cookies();
+    const cookies = await this.page.cookies()
     if (!name) {
-      return this.page.deleteCookie.apply(this.page, cookies);
+      return this.page.deleteCookie.apply(this.page, cookies)
     }
-    const cookie = cookies.filter(c => c.name === name);
-    if (!cookie[0]) return;
-    return this.page.deleteCookie(cookie[0]);
+    const cookie = cookies.filter((c) => c.name === name)
+    if (!cookie[0]) return
+    return this.page.deleteCookie(cookie[0])
   }
 
   /**
@@ -1693,11 +1747,11 @@ class Puppeteer extends Helper {
    * {{> executeScript }}
    */
   async executeScript(...args) {
-    let context = await this._getContext();
+    let context = await this._getContext()
     if (this.context && this.context.constructor.name === 'CdpFrame') {
-      context = this.context; // switching to iframe context
+      context = this.context // switching to iframe context
     }
-    return context.evaluate.apply(context, args);
+    return context.evaluate.apply(context, args)
   }
 
   /**
@@ -1706,16 +1760,16 @@ class Puppeteer extends Helper {
    */
   async executeAsyncScript(...args) {
     const asyncFn = function () {
-      const args = Array.from(arguments);
-      const fn = eval(`(${args.shift()})`); // eslint-disable-line no-eval
+      const args = Array.from(arguments)
+      const fn = eval(`(${args.shift()})`) // eslint-disable-line no-eval
       return new Promise((done) => {
-        args.push(done);
-        fn.apply(null, args);
-      });
-    };
-    args[0] = args[0].toString();
-    args.unshift(asyncFn);
-    return this.page.evaluate.apply(this.page, args);
+        args.push(done)
+        fn.apply(null, args)
+      })
+    }
+    args[0] = args[0].toString()
+    args.unshift(asyncFn)
+    return this.page.evaluate.apply(this.page, args)
   }
 
   /**
@@ -1723,12 +1777,12 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async grabTextFromAll(locator) {
-    const els = await this._locate(locator);
-    const texts = [];
+    const els = await this._locate(locator)
+    const texts = []
     for (const el of els) {
-      texts.push(await (await el.getProperty('innerText')).jsonValue());
+      texts.push(await (await el.getProperty('innerText')).jsonValue())
     }
-    return texts;
+    return texts
   }
 
   /**
@@ -1736,60 +1790,60 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   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]
   }
 
   /**
    * {{> grabValueFromAll }}
    */
   async grabValueFromAll(locator) {
-    const els = await findFields.call(this, locator);
-    const values = [];
+    const els = await findFields.call(this, locator)
+    const values = []
     for (const el of els) {
-      values.push(await (await el.getProperty('value')).jsonValue());
+      values.push(await (await el.getProperty('value')).jsonValue())
     }
-    return values;
+    return values
   }
 
   /**
    * {{> grabValueFrom }}
    */
   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]
   }
 
   /**
    * {{> grabHTMLFromAll }}
    */
   async grabHTMLFromAll(locator) {
-    const els = await this._locate(locator);
-    const values = await Promise.all(els.map(el => el.evaluate(element => element.innerHTML, el)));
-    return values;
+    const els = await this._locate(locator)
+    const values = await Promise.all(els.map((el) => el.evaluate((element) => element.innerHTML, el)))
+    return values
   }
 
   /**
    * {{> grabHTMLFrom }}
    */
   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]
   }
 
   /**
@@ -1797,11 +1851,13 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async grabCssPropertyFromAll(locator, cssProperty) {
-    const els = await this._locate(locator);
-    const res = await Promise.all(els.map(el => el.evaluate(el => JSON.parse(JSON.stringify(getComputedStyle(el))), el)));
-    const cssValues = res.map(props => props[toCamelCase(cssProperty)]);
+    const els = await this._locate(locator)
+    const res = await Promise.all(
+      els.map((el) => el.evaluate((el) => JSON.parse(JSON.stringify(getComputedStyle(el))), el)),
+    )
+    const cssValues = res.map((props) => props[toCamelCase(cssProperty)])
 
-    return cssValues;
+    return cssValues
   }
 
   /**
@@ -1809,14 +1865,14 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   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]
   }
 
   /**
@@ -1824,35 +1880,37 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   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);
+    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)
   }
 
   /**
@@ -1860,34 +1918,40 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async seeAttributesOnElements(locator, attributes) {
-    const elements = await this._locate(locator);
-    assertElementExists(elements, locator);
+    const elements = await this._locate(locator)
+    assertElementExists(elements, locator)
 
-    const expectedAttributes = Object.entries(attributes);
+    const expectedAttributes = Object.entries(attributes)
 
     const valuesPromises = elements.map(async (element) => {
-      const elementAttributes = {};
-      await Promise.all(expectedAttributes.map(async ([attribute, expectedValue]) => {
-        const actualValue = await element.evaluate((el, attr) => el[attr] || el.getAttribute(attr), attribute);
-        elementAttributes[attribute] = actualValue;
-      }));
-      return elementAttributes;
-    });
+      const elementAttributes = {}
+      await Promise.all(
+        expectedAttributes.map(async ([attribute, expectedValue]) => {
+          const actualValue = await element.evaluate((el, attr) => el[attr] || el.getAttribute(attr), attribute)
+          elementAttributes[attribute] = actualValue
+        }),
+      )
+      return elementAttributes
+    })
 
-    const actualAttributes = await Promise.all(valuesPromises);
+    const actualAttributes = await Promise.all(valuesPromises)
 
-    const matchingElements = actualAttributes.filter((attrs) => expectedAttributes.every(([attribute, expectedValue]) => {
-      const actualValue = attrs[attribute];
-      if (!actualValue) return false;
-      if (actualValue.toString().match(new RegExp(expectedValue.toString()))) return true;
-      return expectedValue === actualValue;
-    }));
+    const matchingElements = actualAttributes.filter((attrs) =>
+      expectedAttributes.every(([attribute, expectedValue]) => {
+        const actualValue = attrs[attribute]
+        if (!actualValue) return false
+        if (actualValue.toString().match(new RegExp(expectedValue.toString()))) return true
+        return expectedValue === actualValue
+      }),
+    )
 
-    const elementsCount = elements.length;
-    const matchingCount = matchingElements.length;
+    const elementsCount = elements.length
+    const matchingCount = matchingElements.length
 
-    return equals(`all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`)
-      .assert(matchingCount, elementsCount);
+    return equals(`all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`).assert(
+      matchingCount,
+      elementsCount,
+    )
   }
 
   /**
@@ -1895,21 +1959,21 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async dragSlider(locator, offsetX = 0) {
-    const src = await this._locate(locator);
-    assertElementExists(src, locator, 'Slider Element');
+    const src = await this._locate(locator)
+    assertElementExists(src, locator, 'Slider Element')
 
     // Note: Using public api .getClickablePoint because the .BoundingBox does not take into account iframe offsets
-    const sliderSource = await getClickablePoint(src[0]);
+    const sliderSource = await getClickablePoint(src[0])
 
     // Drag start point
-    await this.page.mouse.move(sliderSource.x, sliderSource.y, { steps: 5 });
-    await this.page.mouse.down();
+    await this.page.mouse.move(sliderSource.x, sliderSource.y, { steps: 5 })
+    await this.page.mouse.down()
 
     // Drag destination
-    await this.page.mouse.move(sliderSource.x + offsetX, sliderSource.y, { steps: 5 });
-    await this.page.mouse.up();
+    await this.page.mouse.move(sliderSource.x + offsetX, sliderSource.y, { steps: 5 })
+    await this.page.mouse.up()
 
-    await this._waitForAction();
+    await this._waitForAction()
   }
 
   /**
@@ -1917,13 +1981,13 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async grabAttributeFromAll(locator, attr) {
-    const els = await this._locate(locator);
-    const array = [];
+    const els = await this._locate(locator)
+    const array = []
     for (let index = 0; index < els.length; index++) {
-      const a = await this._evaluateHandeInContext((el, attr) => el[attr] || el.getAttribute(attr), els[index], attr);
-      array.push(await a.jsonValue());
+      const a = await this._evaluateHandeInContext((el, attr) => el[attr] || el.getAttribute(attr), els[index], attr)
+      array.push(await a.jsonValue())
     }
-    return array;
+    return array
   }
 
   /**
@@ -1931,84 +1995,84 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   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]
   }
 
   /**
    * {{> saveElementScreenshot }}
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = screenshotOutputFolder(fileName);
+    const outputFile = screenshotOutputFolder(fileName)
 
-    const res = await this._locate(locator);
-    assertElementExists(res, locator);
-    if (res.length > 1) this.debug(`[Elements] Using first element out of ${res.length}`);
-    const elem = res[0];
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
-    return elem.screenshot({ path: outputFile, type: 'png' });
+    const res = await this._locate(locator)
+    assertElementExists(res, locator)
+    if (res.length > 1) this.debug(`[Elements] Using first element out of ${res.length}`)
+    const elem = res[0]
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+    return elem.screenshot({ path: outputFile, type: 'png' })
   }
 
   /**
    * {{> saveScreenshot }}
    */
   async saveScreenshot(fileName, fullPage) {
-    const fullPageOption = fullPage || this.options.fullPageScreenshots;
-    let outputFile = screenshotOutputFolder(fileName);
+    const fullPageOption = fullPage || this.options.fullPageScreenshots
+    let outputFile = screenshotOutputFolder(fileName)
 
-    this.debug(`Screenshot is saving to ${outputFile}`);
+    this.debug(`Screenshot is saving to ${outputFile}`)
 
     await this.page.screenshot({
       path: outputFile,
       fullPage: fullPageOption,
       type: 'png',
-    });
+    })
 
     if (this.activeSessionName) {
       for (const sessionName in this.sessionPages) {
-        const activeSessionPage = this.sessionPages[sessionName];
-        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`);
+        const activeSessionPage = this.sessionPages[sessionName]
+        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`)
 
-        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`);
+        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`)
 
         if (activeSessionPage) {
           await activeSessionPage.screenshot({
             path: outputFile,
             fullPage: fullPageOption,
             type: 'png',
-          });
+          })
         }
       }
     }
   }
 
   async _failed(test) {
-    await this._withinEnd();
+    await this._withinEnd()
 
     if (this.options.trace) {
-      await this.page.tracing.stop();
-      const _traceName = this.currentRunningTest.artifacts.trace.replace('.json', '.failed.json');
-      fs.renameSync(this.currentRunningTest.artifacts.trace, _traceName);
-      test.artifacts.trace = _traceName;
+      await this.page.tracing.stop()
+      const _traceName = this.currentRunningTest.artifacts.trace.replace('.json', '.failed.json')
+      fs.renameSync(this.currentRunningTest.artifacts.trace, _traceName)
+      test.artifacts.trace = _traceName
     }
   }
 
   async _passed(test) {
-    await this._withinEnd();
+    await this._withinEnd()
 
     if (this.options.trace) {
-      await this.page.tracing.stop();
+      await this.page.tracing.stop()
       if (this.options.keepTraceForPassedTests) {
-        const _traceName = this.currentRunningTest.artifacts.trace.replace('.json', '.passed.json');
-        fs.renameSync(this.currentRunningTest.artifacts.trace, _traceName);
-        test.artifacts.trace = _traceName;
+        const _traceName = this.currentRunningTest.artifacts.trace.replace('.json', '.passed.json')
+        fs.renameSync(this.currentRunningTest.artifacts.trace, _traceName)
+        test.artifacts.trace = _traceName
       } else {
-        fs.unlinkSync(this.currentRunningTest.artifacts.trace);
+        fs.unlinkSync(this.currentRunningTest.artifacts.trace)
       }
     }
   }
@@ -2017,70 +2081,74 @@ class Puppeteer extends Helper {
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise(((done) => {
-      setTimeout(done, sec * 1000);
-    }));
+    return new Promise((done) => {
+      setTimeout(done, sec * 1000)
+    })
   }
 
   /**
    * {{> waitForEnabled }}
    */
   async waitForEnabled(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    await this.context
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
       const enabledFn = function (locator) {
-        const els = document.querySelectorAll(locator);
+        const els = document.querySelectorAll(locator)
         if (!els || els.length === 0) {
-          return false;
+          return false
         }
-        return Array.prototype.filter.call(els, el => !el.disabled).length > 0;
-      };
-      waiter = context.waitForFunction(enabledFn, { timeout: waitTimeout }, locator.value);
+        return Array.prototype.filter.call(els, (el) => !el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(enabledFn, { timeout: waitTimeout }, locator.value)
     } else {
       const enabledFn = function (locator, $XPath) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => !el.disabled).length > 0;
-      };
-      waiter = context.waitForFunction(enabledFn, { timeout: waitTimeout }, locator.value, $XPath.toString());
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => !el.disabled).length > 0
+      }
+      waiter = context.waitForFunction(enabledFn, { timeout: waitTimeout }, locator.value, $XPath.toString())
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForValue }}
    */
   async waitForValue(field, value, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const locator = new Locator(field, 'css');
-    await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const locator = new Locator(field, 'css')
+    await this.context
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
       const valueFn = function (locator, value) {
-        const els = document.querySelectorAll(locator);
+        const els = document.querySelectorAll(locator)
         if (!els || els.length === 0) {
-          return false;
+          return false
         }
-        return Array.prototype.filter.call(els, el => (el.value.toString() || '').indexOf(value) !== -1).length > 0;
-      };
-      waiter = context.waitForFunction(valueFn, { timeout: waitTimeout }, locator.value, value);
+        return Array.prototype.filter.call(els, (el) => (el.value.toString() || '').indexOf(value) !== -1).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, { timeout: waitTimeout }, locator.value, value)
     } else {
       const valueFn = function (locator, $XPath, value) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => (el.value || '').indexOf(value) !== -1).length > 0;
-      };
-      waiter = context.waitForFunction(valueFn, { timeout: waitTimeout }, locator.value, $XPath.toString(), value);
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => (el.value || '').indexOf(value) !== -1).length > 0
+      }
+      waiter = context.waitForFunction(valueFn, { timeout: waitTimeout }, locator.value, $XPath.toString(), value)
     }
     return waiter.catch((err) => {
-      const loc = locator.toString();
-      throw new Error(`element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      const loc = locator.toString()
+      throw new Error(
+        `element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
@@ -2088,45 +2156,49 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async waitNumberOfVisibleElements(locator, num, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
       const visibleFn = function (locator, num) {
-        const els = document.querySelectorAll(locator);
+        const els = document.querySelectorAll(locator)
         if (!els || els.length === 0) {
-          return false;
+          return false
         }
-        return Array.prototype.filter.call(els, el => el.offsetParent !== null).length === num;
-      };
-      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, num);
+        return Array.prototype.filter.call(els, (el) => el.offsetParent !== null).length === num
+      }
+      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, num)
     } else {
       const visibleFn = function (locator, $XPath, num) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).filter(el => el.offsetParent !== null).length === num;
-      };
-      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, $XPath.toString(), num);
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).filter((el) => el.offsetParent !== null).length === num
+      }
+      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, $XPath.toString(), num)
     }
     return waiter.catch((err) => {
-      throw new Error(`The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForClickable }}
    */
   async waitForClickable(locator, waitTimeout) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
 
     return this.waitForFunction(isElementClickable, [els[0]], waitTimeout).catch(async (e) => {
       if (/Waiting failed/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-        throw new Error(`element ${new Locator(locator).toString()} still not clickable after ${waitTimeout || this.options.waitForTimeout / 1000} sec`);
+        throw new Error(
+          `element ${new Locator(locator).toString()} still not clickable after ${waitTimeout || this.options.waitForTimeout / 1000} sec`,
+        )
       } else {
-        throw e;
+        throw e
       }
-    });
+    })
   }
 
   /**
@@ -2134,19 +2206,21 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async waitForElement(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    let waiter;
-    const context = await this._getContext();
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
-      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout });
+      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout })
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout })
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
@@ -2155,160 +2229,191 @@ class Puppeteer extends Helper {
    * {{ react }}
    */
   async waitForVisible(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    await this.context
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
-      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, visible: true });
+      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, visible: true })
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, visible: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, visible: true })
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `element (${locator.toString()}) still not visible after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForInvisible }}
    */
   async waitForInvisible(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    await this.context;
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    await this.context
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
-      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
+      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true })
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true })
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(`element (${locator.toString()}) still visible after ${waitTimeout / 1000} sec\n${err.message}`)
+    })
   }
 
   /**
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
-    let waiter;
-    const context = await this._getContext();
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
-      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true });
+      waiter = context.waitForSelector(locator.simplify(), { timeout: waitTimeout, hidden: true })
     } else {
-      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true });
+      waiter = _waitForElement.call(this, locator, { timeout: waitTimeout, hidden: true })
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(
+        `element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`,
+      )
+    })
   }
 
   /**
    * {{> waitForNumberOfTabs }}
    */
   async waitForNumberOfTabs(expectedTabs, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    let currentTabs;
-    let count = 0;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    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.`)
   }
 
   async _getContext() {
     if (this.context && this.context.constructor.name === 'CdpFrame') {
-      return this.context;
+      return this.context
     }
-    return this.page;
+    return this.page
   }
 
   /**
    * {{> waitInUrl }}
    */
   async waitInUrl(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-
-    return this.page.waitForFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl.indexOf(urlPart) > -1;
-    }, { timeout: waitTimeout }, urlPart).catch(async (e) => {
-      const currUrl = await this._getPageUrl(); // Required because the waitForFunction can't return data.
-      if (/Waiting failed:/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-        throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
-      } else {
-        throw e;
-      }
-    });
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+
+    return this.page
+      .waitForFunction(
+        (urlPart) => {
+          const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+          return currUrl.indexOf(urlPart) > -1
+        },
+        { timeout: waitTimeout },
+        urlPart,
+      )
+      .catch(async (e) => {
+        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        if (/Waiting failed:/i.test(e.message) || /failed: timeout/i.test(e.message)) {
+          throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+        } else {
+          throw e
+        }
+      })
   }
 
   /**
    * {{> waitUrlEquals }}
    */
   async waitUrlEquals(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    const baseUrl = this.options.url;
+    const baseUrl = this.options.url
     if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart;
-    }
-
-    return this.page.waitForFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl.indexOf(urlPart) > -1;
-    }, { timeout: waitTimeout }, urlPart).catch(async (e) => {
-      const currUrl = await this._getPageUrl(); // Required because the waitForFunction can't return data.
-      if (/Waiting failed/i.test(e.message) || /failed: timeout/i.test(e.message)) {
-        throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`);
-      } else {
-        throw e;
-      }
-    });
+      urlPart = baseUrl + urlPart
+    }
+
+    return this.page
+      .waitForFunction(
+        (urlPart) => {
+          const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+          return currUrl.indexOf(urlPart) > -1
+        },
+        { timeout: waitTimeout },
+        urlPart,
+      )
+      .catch(async (e) => {
+        const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
+        if (/Waiting failed/i.test(e.message) || /failed: timeout/i.test(e.message)) {
+          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+        } else {
+          throw e
+        }
+      })
   }
 
   /**
    * {{> waitForText }}
    */
   async waitForText(text, sec = null, context = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    let waiter;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    let waiter
 
-    const contextObject = await this._getContext();
+    const contextObject = await this._getContext()
 
     if (context) {
-      const locator = new Locator(context, 'css');
+      const locator = new Locator(context, 'css')
       if (locator.isCSS()) {
-        waiter = contextObject.waitForFunction((locator, text) => {
-          const el = document.querySelector(locator);
-          if (!el) return false;
-          return el.innerText.indexOf(text) > -1;
-        }, { timeout: waitTimeout }, locator.value, text);
+        waiter = contextObject.waitForFunction(
+          (locator, text) => {
+            const el = document.querySelector(locator)
+            if (!el) return false
+            return el.innerText.indexOf(text) > -1
+          },
+          { timeout: waitTimeout },
+          locator.value,
+          text,
+        )
       }
 
       if (locator.isXPath()) {
-        waiter = contextObject.waitForFunction((locator, text, $XPath) => {
-          eval($XPath); // eslint-disable-line no-eval
-          const el = $XPath(null, locator);
-          if (!el.length) return false;
-          return el[0].innerText.indexOf(text) > -1;
-        }, { timeout: waitTimeout }, locator.value, text, $XPath.toString());
+        waiter = contextObject.waitForFunction(
+          (locator, text, $XPath) => {
+            eval($XPath) // eslint-disable-line no-eval
+            const el = $XPath(null, locator)
+            if (!el.length) return false
+            return el[0].innerText.indexOf(text) > -1
+          },
+          { timeout: waitTimeout },
+          locator.value,
+          text,
+          $XPath.toString(),
+        )
       }
     } else {
-      waiter = contextObject.waitForFunction(text => document.body && document.body.innerText.indexOf(text) > -1, { timeout: waitTimeout }, text);
+      waiter = contextObject.waitForFunction(
+        (text) => document.body && document.body.innerText.indexOf(text) > -1,
+        { timeout: waitTimeout },
+        text,
+      )
     }
 
     return waiter.catch((err) => {
-      throw new Error(`Text "${text}" was not found on page after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(`Text "${text}" was not found on page after ${waitTimeout / 1000} sec\n${err.message}`)
+    })
   }
 
   /**
@@ -2323,8 +2428,8 @@ class Puppeteer extends Helper {
    * @param {?number} [sec=null] seconds to wait
    */
   async waitForRequest(urlOrPredicate, sec = null) {
-    const timeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.page.waitForRequest(urlOrPredicate, { timeout });
+    const timeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.page.waitForRequest(urlOrPredicate, { timeout })
   }
 
   /**
@@ -2339,8 +2444,8 @@ class Puppeteer extends Helper {
    * @param {?number} [sec=null] number of seconds to wait
    */
   async waitForResponse(urlOrPredicate, sec = null) {
-    const timeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    return this.page.waitForResponse(urlOrPredicate, { timeout });
+    const timeout = sec ? sec * 1000 : this.options.waitForTimeout
+    return this.page.waitForResponse(urlOrPredicate, { timeout })
   }
 
   /**
@@ -2349,37 +2454,37 @@ class Puppeteer extends Helper {
   async switchTo(locator) {
     if (Number.isInteger(locator)) {
       // Select by frame index of current context
-      let frames = [];
+      let frames = []
       if (this.context && typeof this.context.childFrames === 'function') {
-        frames = await this.context.childFrames();
+        frames = await this.context.childFrames()
       } else {
-        frames = await this.page.mainFrame().childFrames();
+        frames = await this.page.mainFrame().childFrames()
       }
 
       if (locator >= 0 && locator < frames.length) {
-        this.context = frames[locator];
+        this.context = frames[locator]
       } else {
-        throw new Error('Frame index out of bounds');
+        throw new Error('Frame index out of bounds')
       }
-      return;
+      return
     }
 
     if (!locator) {
-      this.context = await this.page.mainFrame();
-      return;
+      this.context = await this.page.mainFrame()
+      return
     }
 
     // Select iframe by selector
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
 
-    const iframeElement = els[0];
-    const contentFrame = await iframeElement.contentFrame();
+    const iframeElement = els[0]
+    const contentFrame = await iframeElement.contentFrame()
 
     if (contentFrame) {
-      this.context = contentFrame;
+      this.context = contentFrame
     } else {
-      throw new Error('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
+      throw new Error('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
     }
   }
 
@@ -2387,17 +2492,17 @@ class Puppeteer extends Helper {
    * {{> 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 waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    const context = await this._getContext();
-    return context.waitForFunction(fn, { timeout: waitTimeout }, ...args);
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    const context = await this._getContext()
+    return context.waitForFunction(fn, { timeout: waitTimeout }, ...args)
   }
 
   /**
@@ -2412,63 +2517,63 @@ class Puppeteer extends Helper {
       timeout: this.options.getPageTimeout,
       waitUntil: this.options.waitForNavigation,
       ...opts,
-    };
-    return this.page.waitForNavigation(opts);
+    }
+    return this.page.waitForNavigation(opts)
   }
 
   async waitUntilExists(locator, sec) {
     console.log(`waitUntilExists deprecated:
     * use 'waitForElement' to wait for element to be attached
-    * use 'waitForDetached to wait for element to be removed'`);
-    return this.waitForDetached(locator, sec);
+    * use 'waitForDetached to wait for element to be removed'`)
+    return this.waitForDetached(locator, sec)
   }
 
   /**
    * {{> waitForDetached }}
    */
   async waitForDetached(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
-    locator = new Locator(locator, 'css');
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
+    locator = new Locator(locator, 'css')
 
-    let waiter;
-    const context = await this._getContext();
+    let waiter
+    const context = await this._getContext()
     if (locator.isCSS()) {
       const visibleFn = function (locator) {
-        return document.querySelector(locator) === null;
-      };
-      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value);
+        return document.querySelector(locator) === null
+      }
+      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value)
     } else {
       const visibleFn = function (locator, $XPath) {
-        eval($XPath); // eslint-disable-line no-eval
-        return $XPath(null, locator).length === 0;
-      };
-      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, $XPath.toString());
+        eval($XPath) // eslint-disable-line no-eval
+        return $XPath(null, locator).length === 0
+      }
+      waiter = context.waitForFunction(visibleFn, { timeout: waitTimeout }, locator.value, $XPath.toString())
     }
     return waiter.catch((err) => {
-      throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${err.message}`);
-    });
+      throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${err.message}`)
+    })
   }
 
   async _waitForAction() {
-    return this.wait(this.options.waitForAction / 1000);
+    return this.wait(this.options.waitForAction / 1000)
   }
 
   /**
    * {{> grabDataFromPerformanceTiming }}
    */
   async grabDataFromPerformanceTiming() {
-    return perfTiming;
+    return perfTiming
   }
 
   /**
    * {{> grabElementBoundingRect }}
    */
   async grabElementBoundingRect(locator, prop) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
-    const rect = await els[0].boundingBox();
-    if (prop) return rect[prop];
-    return rect;
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
+    const rect = await els[0].boundingBox()
+    if (prop) return rect[prop]
+    return rect
   }
 
   /**
@@ -2483,16 +2588,16 @@ class Puppeteer extends Helper {
    * @param {function} [handler] a function to process request
    */
   async mockRoute(url, handler) {
-    await this.page.setRequestInterception(true);
+    await this.page.setRequestInterception(true)
 
-    this.page.on('request', interceptedRequest => {
+    this.page.on('request', (interceptedRequest) => {
       if (interceptedRequest.url().match(url)) {
         // @ts-ignore
-        handler(interceptedRequest);
+        handler(interceptedRequest)
       } else {
-        interceptedRequest.continue();
+        interceptedRequest.continue()
       }
-    });
+    })
   }
 
   /**
@@ -2505,18 +2610,18 @@ class Puppeteer extends Helper {
    * @param {string|RegExp} [url] URL, regex or pattern for to match URL
    */
   async stopMockingRoute(url) {
-    await this.page.setRequestInterception(true);
+    await this.page.setRequestInterception(true)
 
-    this.page.off('request');
+    this.page.off('request')
 
     // Resume normal request handling for the given URL
-    this.page.on('request', interceptedRequest => {
+    this.page.on('request', (interceptedRequest) => {
       if (interceptedRequest.url().includes(url)) {
-        interceptedRequest.continue();
+        interceptedRequest.continue()
       } else {
-        interceptedRequest.continue();
+        interceptedRequest.continue()
       }
-    });
+    })
   }
 
   /**
@@ -2524,7 +2629,7 @@ class Puppeteer extends Helper {
    * {{> flushNetworkTraffics }}
    */
   flushNetworkTraffics() {
-    flushNetworkTraffics.call(this);
+    flushNetworkTraffics.call(this)
   }
 
   /**
@@ -2532,7 +2637,7 @@ class Puppeteer extends Helper {
    * {{> stopRecordingTraffic }}
    */
   stopRecordingTraffic() {
-    stopRecordingTraffic.call(this);
+    stopRecordingTraffic.call(this)
   }
 
   /**
@@ -2540,11 +2645,11 @@ class Puppeteer extends Helper {
    *
    */
   async startRecordingTraffic() {
-    this.flushNetworkTraffics();
-    this.recording = true;
-    this.recordedAtLeastOnce = true;
+    this.flushNetworkTraffics()
+    this.recording = true
+    this.recordedAtLeastOnce = true
 
-    await this.page.setRequestInterception(true);
+    await this.page.setRequestInterception(true)
 
     this.page.on('request', (request) => {
       const information = {
@@ -2553,16 +2658,16 @@ class Puppeteer extends Helper {
         requestHeaders: request.headers(),
         requestPostData: request.postData(),
         response: request.response(),
-      };
+      }
 
-      this.debugSection('REQUEST: ', JSON.stringify(information));
+      this.debugSection('REQUEST: ', JSON.stringify(information))
 
       if (typeof information.requestPostData === 'object') {
-        information.requestPostData = JSON.parse(information.requestPostData);
+        information.requestPostData = JSON.parse(information.requestPostData)
       }
-      request.continue();
-      this.requests.push(information);
-    });
+      request.continue()
+      this.requests.push(information)
+    })
   }
 
   /**
@@ -2570,17 +2675,15 @@ class Puppeteer extends Helper {
    * {{> grabRecordedNetworkTraffics }}
    */
   async grabRecordedNetworkTraffics() {
-    return grabRecordedNetworkTraffics.call(this);
+    return grabRecordedNetworkTraffics.call(this)
   }
 
   /**
    *
    * {{> seeTraffic }}
    */
-  async seeTraffic({
-    name, url, parameters, requestPostData, timeout = 10,
-  }) {
-    await seeTraffic.call(this, ...arguments);
+  async seeTraffic({ name, url, parameters, requestPostData, timeout = 10 }) {
+    await seeTraffic.call(this, ...arguments)
   }
 
   /**
@@ -2589,56 +2692,47 @@ class Puppeteer extends Helper {
    *
    */
   dontSeeTraffic({ name, url }) {
-    dontSeeTraffic.call(this, ...arguments);
+    dontSeeTraffic.call(this, ...arguments)
   }
 
   async getNewCDPSession() {
-    const client = await this.page.target().createCDPSession();
-    return client;
+    const client = await this.page.target().createCDPSession()
+    return client
   }
 
   /**
    * {{> startRecordingWebSocketMessages }}
    */
   async startRecordingWebSocketMessages() {
-    this.flushWebSocketMessages();
-    this.recordingWebSocketMessages = true;
-    this.recordedWebSocketMessagesAtLeastOnce = true;
-
-    this.cdpSession = await this.getNewCDPSession();
-    await this.cdpSession.send('Network.enable');
-    await this.cdpSession.send('Page.enable');
-
-    this.cdpSession.on(
-      'Network.webSocketFrameReceived',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload));
-      },
-    );
+    this.flushWebSocketMessages()
+    this.recordingWebSocketMessages = true
+    this.recordedWebSocketMessagesAtLeastOnce = true
 
-    this.cdpSession.on(
-      'Network.webSocketFrameSent',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('SENT', payload));
-      },
-    );
+    this.cdpSession = await this.getNewCDPSession()
+    await this.cdpSession.send('Network.enable')
+    await this.cdpSession.send('Page.enable')
 
-    this.cdpSession.on(
-      'Network.webSocketFrameError',
-      (payload) => {
-        this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload));
-      },
-    );
+    this.cdpSession.on('Network.webSocketFrameReceived', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload))
+    })
+
+    this.cdpSession.on('Network.webSocketFrameSent', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('SENT', payload))
+    })
+
+    this.cdpSession.on('Network.webSocketFrameError', (payload) => {
+      this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload))
+    })
   }
 
   /**
    * {{> stopRecordingWebSocketMessages }}
    */
   async stopRecordingWebSocketMessages() {
-    await this.cdpSession.send('Network.disable');
-    await this.cdpSession.send('Page.disable');
-    this.page.removeAllListeners('Network');
-    this.recordingWebSocketMessages = false;
+    await this.cdpSession.send('Network.disable')
+    await this.cdpSession.send('Page.disable')
+    this.page.removeAllListeners('Network')
+    this.recordingWebSocketMessages = false
   }
 
   /**
@@ -2650,394 +2744,405 @@ class Puppeteer extends Helper {
   grabWebSocketMessages() {
     if (!this.recordingWebSocketMessages) {
       if (!this.recordedWebSocketMessagesAtLeastOnce) {
-        throw new Error('Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.');
+        throw new Error(
+          'Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.',
+        )
       }
     }
-    return this.webSocketMessages;
+    return this.webSocketMessages
   }
 
   /**
    * Resets all recorded WS messages.
    */
   flushWebSocketMessages() {
-    this.webSocketMessages = [];
+    this.webSocketMessages = []
   }
 
   _getWebSocketMessage(payload) {
     if (payload.errorMessage) {
-      return payload.errorMessage;
+      return payload.errorMessage
     }
 
-    return payload.response.payloadData;
+    return payload.response.payloadData
   }
 
   _getWebSocketLog(prefix, payload) {
-    return `${prefix} ID: ${payload.requestId} TIMESTAMP: ${payload.timestamp} (${new Date().toISOString()})\n\n${this._getWebSocketMessage(payload)}\n\n`;
+    return `${prefix} ID: ${payload.requestId} TIMESTAMP: ${payload.timestamp} (${new Date().toISOString()})\n\n${this._getWebSocketMessage(payload)}\n\n`
   }
 
   _logWebsocketMessages(message) {
-    this.webSocketMessages += message;
+    this.webSocketMessages += message
   }
 }
 
-module.exports = Puppeteer;
+module.exports = Puppeteer
 
 async function findElements(matcher, locator) {
-  if (locator.react) return findReactElements.call(this, locator);
-  locator = new Locator(locator, 'css');
-  if (!locator.isXPath()) return matcher.$$(locator.simplify());
+  if (locator.react) return findReactElements.call(this, locator)
+  locator = new Locator(locator, 'css')
+  if (!locator.isXPath()) return matcher.$$(locator.simplify())
   // puppeteer version < 19.4.0 is no longer supported. This one is backward support.
   if (puppeteer.default?.defaultBrowserRevision) {
-    return matcher.$$(`xpath/${locator.value}`);
+    return matcher.$$(`xpath/${locator.value}`)
   }
-  return matcher.$x(locator.value);
+  return matcher.$x(locator.value)
 }
 
 async function proceedClick(locator, context = null, options = {}) {
-  let matcher = await this.context;
+  let matcher = await this.context
   if (context) {
-    const els = await this._locate(context);
-    assertElementExists(els, context);
-    matcher = els[0];
+    const els = await this._locate(context)
+    assertElementExists(els, context)
+    matcher = els[0]
   }
-  const els = await findClickable.call(this, matcher, locator);
+  const els = await findClickable.call(this, matcher, locator)
   if (context) {
-    assertElementExists(els, locator, 'Clickable element', `was not found inside element ${new Locator(context).toString()}`);
+    assertElementExists(
+      els,
+      locator,
+      'Clickable element',
+      `was not found inside element ${new Locator(context).toString()}`,
+    )
   } else {
-    assertElementExists(els, locator, 'Clickable element');
+    assertElementExists(els, locator, 'Clickable element')
   }
 
-  highlightActiveElement.call(this, els[0], await this._getContext());
+  highlightActiveElement.call(this, els[0], await this._getContext())
 
-  await els[0].click(options);
-  const promises = [];
+  await els[0].click(options)
+  const promises = []
   if (options.waitForNavigation) {
-    promises.push(this.waitForNavigation());
+    promises.push(this.waitForNavigation())
   }
-  promises.push(this._waitForAction());
+  promises.push(this._waitForAction())
 
-  return Promise.all(promises);
+  return Promise.all(promises)
 }
 
 async function findClickable(matcher, locator) {
-  if (locator.react) return findReactElements.call(this, locator);
-  locator = new Locator(locator);
-  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator);
+  if (locator.react) return findReactElements.call(this, locator)
+  locator = new Locator(locator)
+  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator)
 
-  let els;
-  const literal = xpathLocator.literal(locator.value);
+  let els
+  const literal = xpathLocator.literal(locator.value)
 
-  els = await findElements.call(this, matcher, Locator.clickable.narrow(literal));
-  if (els.length) return els;
+  els = await findElements.call(this, matcher, Locator.clickable.narrow(literal))
+  if (els.length) return els
 
-  els = await findElements.call(this, matcher, Locator.clickable.wide(literal));
-  if (els.length) return els;
+  els = await findElements.call(this, matcher, Locator.clickable.wide(literal))
+  if (els.length) return els
 
   try {
-    els = await findElements.call(this, matcher, Locator.clickable.self(literal));
-    if (els.length) return els;
+    els = await findElements.call(this, matcher, Locator.clickable.self(literal))
+    if (els.length) return els
   } catch (err) {
     // Do nothing
   }
 
-  return findElements.call(this, matcher, locator.value); // by css or xpath
+  return findElements.call(this, matcher, locator.value) // by css or xpath
 }
 
 async function proceedSee(assertType, text, context, strict = false) {
-  let description;
-  let allText;
+  let description
+  let allText
   if (!context) {
-    let el = await this.context;
+    let el = await this.context
 
     if (el && !el.getProperty) {
       // Fallback to body
-      el = await this.context.$('body');
+      el = await this.context.$('body')
     }
 
-    allText = [await el.getProperty('innerText').then(p => p.jsonValue())];
-    description = 'web application';
+    allText = [await el.getProperty('innerText').then((p) => p.jsonValue())]
+    description = 'web application'
   } else {
-    const locator = new Locator(context, 'css');
-    description = `element ${locator.toString()}`;
-    const els = await this._locate(locator);
-    assertElementExists(els, locator.toString());
-    allText = await Promise.all(els.map(el => el.getProperty('innerText').then(p => p.jsonValue())));
+    const locator = new Locator(context, 'css')
+    description = `element ${locator.toString()}`
+    const els = await this._locate(locator)
+    assertElementExists(els, locator.toString())
+    allText = await Promise.all(els.map((el) => el.getProperty('innerText').then((p) => p.jsonValue())))
   }
 
   if (strict) {
-    return allText.map(elText => equals(description)[assertType](text, elText));
+    return allText.map((elText) => equals(description)[assertType](text, elText))
   }
-  return stringIncludes(description)[assertType](normalizeSpacesInString(text), normalizeSpacesInString(allText.join(' | ')));
+  return stringIncludes(description)[assertType](
+    normalizeSpacesInString(text),
+    normalizeSpacesInString(allText.join(' | ')),
+  )
 }
 
 async function findCheckable(locator, context) {
-  let contextEl = await this.context;
+  let contextEl = await this.context
   if (typeof context === 'string') {
-    contextEl = await findElements.call(this, contextEl, (new Locator(context, 'css')).simplify());
-    contextEl = contextEl[0];
+    contextEl = await findElements.call(this, contextEl, new Locator(context, 'css').simplify())
+    contextEl = contextEl[0]
   }
 
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return findElements.call(this, contextEl, matchedLocator.simplify());
+    return findElements.call(this, contextEl, matchedLocator.simplify())
   }
 
-  const literal = xpathLocator.literal(locator);
-  let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal));
+  const literal = xpathLocator.literal(locator)
+  let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
   if (els.length) {
-    return els;
+    return els
   }
-  els = await findElements.call(this, contextEl, Locator.checkable.byName(literal));
+  els = await findElements.call(this, contextEl, Locator.checkable.byName(literal))
   if (els.length) {
-    return els;
+    return els
   }
-  return findElements.call(this, contextEl, locator);
+  return findElements.call(this, contextEl, locator)
 }
 
 async function proceedIsChecked(assertType, option) {
-  let els = await findCheckable.call(this, option);
-  assertElementExists(els, option, 'Checkable');
-  els = await Promise.all(els.map(el => el.getProperty('checked')));
-  els = await Promise.all(els.map(el => el.jsonValue()));
-  const selected = els.reduce((prev, cur) => prev || cur);
-  return truth(`checkable ${option}`, 'to be checked')[assertType](selected);
+  let els = await findCheckable.call(this, option)
+  assertElementExists(els, option, 'Checkable')
+  els = await Promise.all(els.map((el) => el.getProperty('checked')))
+  els = await Promise.all(els.map((el) => el.jsonValue()))
+  const selected = els.reduce((prev, cur) => prev || cur)
+  return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
 async function findVisibleFields(locator) {
-  const els = await findFields.call(this, locator);
-  const visible = await Promise.all(els.map(el => el.boundingBox()));
-  return els.filter((el, index) => visible[index]);
+  const els = await findFields.call(this, locator)
+  const visible = await Promise.all(els.map((el) => el.boundingBox()))
+  return els.filter((el, index) => visible[index])
 }
 
 async function findFields(locator) {
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this._locate(matchedLocator);
+    return this._locate(matchedLocator)
   }
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) });
+  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) })
   if (els.length) {
-    return els;
+    return els
   }
 
-  els = await this._locate({ xpath: Locator.field.labelContains(literal) });
+  els = await this._locate({ xpath: Locator.field.labelContains(literal) })
   if (els.length) {
-    return els;
+    return els
   }
-  els = await this._locate({ xpath: Locator.field.byName(literal) });
+  els = await this._locate({ xpath: Locator.field.byName(literal) })
   if (els.length) {
-    return els;
+    return els
   }
-  return this._locate({ css: locator });
+  return this._locate({ css: locator })
 }
 
 async function proceedDragAndDrop(sourceLocator, destinationLocator) {
-  const src = await this._locate(sourceLocator);
-  assertElementExists(src, sourceLocator, 'Source Element');
+  const src = await this._locate(sourceLocator)
+  assertElementExists(src, sourceLocator, 'Source Element')
 
-  const dst = await this._locate(destinationLocator);
-  assertElementExists(dst, destinationLocator, 'Destination Element');
+  const dst = await this._locate(destinationLocator)
+  assertElementExists(dst, destinationLocator, 'Destination Element')
 
   // Note: Using public api .getClickablePoint becaues the .BoundingBox does not take into account iframe offsets
-  const dragSource = await getClickablePoint(src[0]);
-  const dragDestination = await getClickablePoint(dst[0]);
+  const dragSource = await getClickablePoint(src[0])
+  const dragDestination = await getClickablePoint(dst[0])
 
   // Drag start point
-  await this.page.mouse.move(dragSource.x, dragSource.y, { steps: 5 });
-  await this.page.mouse.down();
+  await this.page.mouse.move(dragSource.x, dragSource.y, { steps: 5 })
+  await this.page.mouse.down()
 
   // Drag destination
-  await this.page.mouse.move(dragDestination.x, dragDestination.y, { steps: 5 });
-  await this.page.mouse.up();
+  await this.page.mouse.move(dragDestination.x, dragDestination.y, { steps: 5 })
+  await this.page.mouse.up()
 
-  await this._waitForAction();
+  await this._waitForAction()
 }
 
 async function proceedSeeInField(assertType, field, value) {
-  const els = await findVisibleFields.call(this, field);
-  assertElementExists(els, field, 'Field');
-  const el = els[0];
-  const tag = await el.getProperty('tagName').then(el => el.jsonValue());
-  const fieldType = await el.getProperty('type').then(el => el.jsonValue());
+  const els = await findVisibleFields.call(this, field)
+  assertElementExists(els, field, 'Field')
+  const el = els[0]
+  const tag = await el.getProperty('tagName').then((el) => el.jsonValue())
+  const fieldType = await el.getProperty('type').then((el) => el.jsonValue())
 
   const proceedMultiple = async (elements) => {
-    const fields = Array.isArray(elements) ? elements : [elements];
+    const fields = Array.isArray(elements) ? elements : [elements]
 
-    const elementValues = [];
+    const elementValues = []
     for (const element of fields) {
-      elementValues.push(await element.getProperty('value').then(el => el.jsonValue()));
+      elementValues.push(await element.getProperty('value').then((el) => el.jsonValue()))
     }
 
     if (typeof value === 'boolean') {
-      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!elementValues.length);
+      equals(`no. of items matching > 0: ${field}`)[assertType](value, !!elementValues.length)
     } else {
       if (assertType === 'assert') {
-        equals(`select option by ${field}`)[assertType](true, elementValues.length > 0);
+        equals(`select option by ${field}`)[assertType](true, elementValues.length > 0)
       }
-      elementValues.forEach(val => stringIncludes(`fields by ${field}`)[assertType](value, val));
+      elementValues.forEach((val) => stringIncludes(`fields by ${field}`)[assertType](value, val))
     }
-  };
+  }
 
   if (tag === 'SELECT') {
-    const selectedOptions = await el.$$('option:checked');
+    const selectedOptions = await el.$$('option:checked')
     // locate option by values and check them
     if (value === '') {
-      return proceedMultiple(selectedOptions);
+      return proceedMultiple(selectedOptions)
     }
 
-    const options = await filterFieldsByValue(selectedOptions, value, true);
-    return proceedMultiple(options);
+    const options = await filterFieldsByValue(selectedOptions, value, true)
+    return proceedMultiple(options)
   }
 
   if (tag === 'INPUT') {
     if (fieldType === 'checkbox' || fieldType === 'radio') {
       if (typeof value === 'boolean') {
         // Filter by values
-        const options = await filterFieldsBySelectionState(els, true);
-        return proceedMultiple(options);
+        const options = await filterFieldsBySelectionState(els, true)
+        return proceedMultiple(options)
       }
 
-      const options = await filterFieldsByValue(els, value, true);
-      return proceedMultiple(options);
+      const options = await filterFieldsByValue(els, value, true)
+      return proceedMultiple(options)
     }
-    return proceedMultiple(els[0]);
+    return proceedMultiple(els[0])
   }
-  const fieldVal = await el.getProperty('value').then(el => el.jsonValue());
-  return stringIncludes(`fields by ${field}`)[assertType](value, fieldVal);
+  const fieldVal = await el.getProperty('value').then((el) => el.jsonValue())
+  return stringIncludes(`fields by ${field}`)[assertType](value, fieldVal)
 }
 
 async function filterFieldsByValue(elements, value, onlySelected) {
-  const matches = [];
+  const matches = []
   for (const element of elements) {
-    const val = await element.getProperty('value').then(el => el.jsonValue());
-    let isSelected = true;
+    const val = await element.getProperty('value').then((el) => el.jsonValue())
+    let isSelected = true
     if (onlySelected) {
-      isSelected = await elementSelected(element);
+      isSelected = await elementSelected(element)
     }
     if ((value == null || val.indexOf(value) > -1) && isSelected) {
-      matches.push(element);
+      matches.push(element)
     }
   }
-  return matches;
+  return matches
 }
 
 async function filterFieldsBySelectionState(elements, state) {
-  const matches = [];
+  const matches = []
   for (const element of elements) {
-    const isSelected = await elementSelected(element);
+    const isSelected = await elementSelected(element)
     if (isSelected === state) {
-      matches.push(element);
+      matches.push(element)
     }
   }
-  return matches;
+  return matches
 }
 
 async function elementSelected(element) {
-  const type = await element.getProperty('type').then(el => el.jsonValue());
+  const type = await element.getProperty('type').then((el) => el.jsonValue())
 
   if (type === 'checkbox' || type === 'radio') {
-    return element.getProperty('checked').then(el => el.jsonValue());
+    return element.getProperty('checked').then((el) => el.jsonValue())
   }
-  return element.getProperty('selected').then(el => el.jsonValue());
+  return element.getProperty('selected').then((el) => el.jsonValue())
 }
 
 function isFrameLocator(locator) {
-  locator = new Locator(locator);
+  locator = new Locator(locator)
   if (locator.isFrame()) {
-    const _locator = new Locator(locator);
-    return _locator.value;
+    const _locator = new Locator(locator)
+    return _locator.value
   }
-  return false;
+  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 $XPath(element, selector) {
-  const found = document.evaluate(selector, element || document.body, null, 5, null);
-  const res = [];
-  let current = null;
-  while (current = found.iterateNext()) {
-    res.push(current);
+  const found = document.evaluate(selector, element || document.body, null, 5, null)
+  const res = []
+  let current = null
+  while ((current = found.iterateNext())) {
+    res.push(current)
   }
-  return res;
+  return res
 }
 
 async function targetCreatedHandler(page) {
-  if (!page) return;
-  this.withinLocator = null;
+  if (!page) return
+  this.withinLocator = null
   page.on('load', () => {
-    page.$('body')
+    page
+      .$('body')
       .catch(() => null)
-      .then(context => this.context = context);
-  });
+      .then((context) => (this.context = context))
+  })
   page.on('console', (msg) => {
-    this.debugSection(`Browser:${ucfirst(msg.type())}`, (msg._text || '') + msg.args().join(' '));
-    consoleLogStore.add(msg);
-  });
+    this.debugSection(`Browser:${ucfirst(msg.type())}`, (msg._text || '') + msg.args().join(' '))
+    consoleLogStore.add(msg)
+  })
 
   if (this.options.userAgent) {
-    await page.setUserAgent(this.options.userAgent);
+    await page.setUserAgent(this.options.userAgent)
   }
   if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0) {
-    const dimensions = this.options.windowSize.split('x');
-    const width = parseInt(dimensions[0], 10);
-    const height = parseInt(dimensions[1], 10);
-    await page.setViewport({ width, height });
+    const dimensions = this.options.windowSize.split('x')
+    const width = parseInt(dimensions[0], 10)
+    const height = parseInt(dimensions[1], 10)
+    await page.setViewport({ width, height })
   }
 }
 
 // BC compatibility for Puppeteer < 10
 async function getClickablePoint(el) {
-  if (el.clickablePoint) return el.clickablePoint();
-  if (el._clickablePoint) return el._clickablePoint();
-  return null;
+  if (el.clickablePoint) return el.clickablePoint()
+  if (el._clickablePoint) return el._clickablePoint()
+  return null
 }
 
 // List of key values to key definitions
 // https://github.com/GoogleChrome/puppeteer/blob/v1.20.0/lib/USKeyboardLayout.js
 const keyDefinitionMap = {
   /* eslint-disable quote-props */
-  '0': 'Digit0',
-  '1': 'Digit1',
-  '2': 'Digit2',
-  '3': 'Digit3',
-  '4': 'Digit4',
-  '5': 'Digit5',
-  '6': 'Digit6',
-  '7': 'Digit7',
-  '8': 'Digit8',
-  '9': 'Digit9',
-  'a': 'KeyA',
-  'b': 'KeyB',
-  'c': 'KeyC',
-  'd': 'KeyD',
-  'e': 'KeyE',
-  'f': 'KeyF',
-  'g': 'KeyG',
-  'h': 'KeyH',
-  'i': 'KeyI',
-  'j': 'KeyJ',
-  'k': 'KeyK',
-  'l': 'KeyL',
-  'm': 'KeyM',
-  'n': 'KeyN',
-  'o': 'KeyO',
-  'p': 'KeyP',
-  'q': 'KeyQ',
-  'r': 'KeyR',
-  's': 'KeyS',
-  't': 'KeyT',
-  'u': 'KeyU',
-  'v': 'KeyV',
-  'w': 'KeyW',
-  'x': 'KeyX',
-  'y': 'KeyY',
-  'z': 'KeyZ',
+  0: 'Digit0',
+  1: 'Digit1',
+  2: 'Digit2',
+  3: 'Digit3',
+  4: 'Digit4',
+  5: 'Digit5',
+  6: 'Digit6',
+  7: 'Digit7',
+  8: 'Digit8',
+  9: 'Digit9',
+  a: 'KeyA',
+  b: 'KeyB',
+  c: 'KeyC',
+  d: 'KeyD',
+  e: 'KeyE',
+  f: 'KeyF',
+  g: 'KeyG',
+  h: 'KeyH',
+  i: 'KeyI',
+  j: 'KeyJ',
+  k: 'KeyK',
+  l: 'KeyL',
+  m: 'KeyM',
+  n: 'KeyN',
+  o: 'KeyO',
+  p: 'KeyP',
+  q: 'KeyQ',
+  r: 'KeyR',
+  s: 'KeyS',
+  t: 'KeyT',
+  u: 'KeyU',
+  v: 'KeyV',
+  w: 'KeyW',
+  x: 'KeyX',
+  y: 'KeyY',
+  z: 'KeyZ',
   ';': 'Semicolon',
   '=': 'Equal',
   ',': 'Comma',
@@ -3048,91 +3153,94 @@ const keyDefinitionMap = {
   '[': 'BracketLeft',
   '\\': 'Backslash',
   ']': 'BracketRight',
-  '\'': 'Quote',
+  "'": 'Quote',
   /* eslint-enable quote-props */
-};
+}
 
 function getNormalizedKey(key) {
-  const normalizedKey = getNormalizedKeyAttributeValue(key);
+  const normalizedKey = getNormalizedKeyAttributeValue(key)
   if (key !== normalizedKey) {
-    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`);
+    this.debugSection('Input', `Mapping key '${key}' to '${normalizedKey}'`)
   }
   // Use key definition to ensure correct key is displayed when Shift modifier is active
   if (Object.prototype.hasOwnProperty.call(keyDefinitionMap, normalizedKey)) {
-    return keyDefinitionMap[normalizedKey];
+    return keyDefinitionMap[normalizedKey]
   }
-  return normalizedKey;
+  return normalizedKey
 }
 
 function highlightActiveElement(element, context) {
   if (this.options.highlightElement && global.debugMode) {
-    highlightElement(element, context);
+    highlightElement(element, context)
   }
 }
 
 function _waitForElement(locator, options) {
   try {
-    return this.context.waitForXPath(locator.value, options);
+    return this.context.waitForXPath(locator.value, options)
   } catch (e) {
-    return this.context.waitForSelector(`::-p-xpath(${locator.value})`, options);
+    return this.context.waitForSelector(`::-p-xpath(${locator.value})`, options)
   }
 }
 
 async function findReactElements(locator, props = {}, state = {}) {
-  const resqScript = await fs.promises.readFile(require.resolve('resq'), 'utf-8');
-  await this.page.evaluate(resqScript.toString());
-
-  await this.page.evaluate(() => window.resq.waitToLoadReact());
-  const arrayHandle = await this.page.evaluateHandle((obj) => {
-    const { selector, props, state } = obj;
-    let elements = window.resq.resq$$(selector);
-    if (Object.keys(props).length) {
-      elements = elements.byProps(props);
-    }
-    if (Object.keys(state).length) {
-      elements = elements.byState(state);
-    }
-
-    if (!elements.length) {
-      return [];
-    }
-
-    // resq returns an array of HTMLElements if the React component is a fragment
-    // this avoids having nested arrays of nodes which the driver does not understand
-    // [[div, div], [div, div]] => [div, div, div, div]
-    let nodes = [];
-
-    elements.forEach((element) => {
-      let { node, isFragment } = element;
-
-      if (!node) {
-        isFragment = true;
-        node = element.children;
+  const resqScript = await fs.promises.readFile(require.resolve('resq'), 'utf-8')
+  await this.page.evaluate(resqScript.toString())
+
+  await this.page.evaluate(() => window.resq.waitToLoadReact())
+  const arrayHandle = await this.page.evaluateHandle(
+    (obj) => {
+      const { selector, props, state } = obj
+      let elements = window.resq.resq$$(selector)
+      if (Object.keys(props).length) {
+        elements = elements.byProps(props)
+      }
+      if (Object.keys(state).length) {
+        elements = elements.byState(state)
       }
 
-      if (isFragment) {
-        nodes = nodes.concat(node);
-      } else {
-        nodes.push(node);
+      if (!elements.length) {
+        return []
       }
-    });
 
-    return [...nodes];
-  }, {
-    selector: locator.react,
-    props: locator.props || {},
-    state: locator.state || {},
-  });
+      // resq returns an array of HTMLElements if the React component is a fragment
+      // this avoids having nested arrays of nodes which the driver does not understand
+      // [[div, div], [div, div]] => [div, div, div, div]
+      let nodes = []
 
-  const properties = await arrayHandle.getProperties();
-  const result = [];
+      elements.forEach((element) => {
+        let { node, isFragment } = element
+
+        if (!node) {
+          isFragment = true
+          node = element.children
+        }
+
+        if (isFragment) {
+          nodes = nodes.concat(node)
+        } else {
+          nodes.push(node)
+        }
+      })
+
+      return [...nodes]
+    },
+    {
+      selector: locator.react,
+      props: locator.props || {},
+      state: locator.state || {},
+    },
+  )
+
+  const properties = await arrayHandle.getProperties()
+  const result = []
   for (const property of properties.values()) {
-    const elementHandle = property.asElement();
+    const elementHandle = property.asElement()
     if (elementHandle) {
-      result.push(elementHandle);
+      result.push(elementHandle)
     }
   }
 
-  await arrayHandle.dispose();
-  return result;
+  await arrayHandle.dispose()
+  return result
 }
diff --git a/lib/helper/REST.js b/lib/helper/REST.js
index 7e4e3b3c2..bd79b2ce6 100644
--- a/lib/helper/REST.js
+++ b/lib/helper/REST.js
@@ -1,9 +1,9 @@
-const axios = require('axios').default;
-const Helper = require('@codeceptjs/helper');
-const { Agent } = require('https');
-const Secret = require('../secret');
+const axios = require('axios').default
+const Helper = require('@codeceptjs/helper')
+const { Agent } = require('https')
+const Secret = require('../secret')
 
-const { beautify } = require('../utils');
+const { beautify } = require('../utils')
 
 /**
  * ## Configuration
@@ -20,7 +20,7 @@ const { beautify } = require('../utils');
  * @prop {function} [onResponse] - an async function which can update response object.
  * @prop {number} [maxUploadFileSize] - set the max content file size in MB when performing api calls.
  */
-const config = {};
+const config = {}
 
 /**
  * REST helper allows to send additional requests to the REST API during acceptance tests.
@@ -78,7 +78,7 @@ const config = {};
  */
 class REST extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
     this.options = {
       timeout: 10000,
       defaultHeaders: {},
@@ -86,46 +86,51 @@ class REST extends Helper {
       prettyPrintJson: false,
       onRequest: null,
       onResponse: null,
-    };
+    }
 
     if (this.options.maxContentLength) {
-      const maxContentLength = this.options.maxUploadFileSize * 1024 * 1024;
-      this.options.maxContentLength = maxContentLength;
-      this.options.maxBodyLength = maxContentLength;
+      const maxContentLength = this.options.maxUploadFileSize * 1024 * 1024
+      this.options.maxContentLength = maxContentLength
+      this.options.maxBodyLength = maxContentLength
     }
 
     // override defaults with config
-    this._setConfig(config);
+    this._setConfig(config)
 
-    this.headers = { ...this.options.defaultHeaders };
+    this.headers = { ...this.options.defaultHeaders }
 
     // Create an agent with SSL certificate
     if (this.options.httpAgent) {
-      if (!this.options.httpAgent.key || !this.options.httpAgent.cert) throw Error('Please recheck your httpAgent config!');
-      this.httpsAgent = new Agent(this.options.httpAgent);
+      if (!this.options.httpAgent.key || !this.options.httpAgent.cert)
+        throw Error('Please recheck your httpAgent config!')
+      this.httpsAgent = new Agent(this.options.httpAgent)
     }
 
-    this.axios = this.httpsAgent ? axios.create({ httpsAgent: this.httpsAgent }) : axios.create();
+    this.axios = this.httpsAgent ? axios.create({ httpsAgent: this.httpsAgent }) : axios.create()
     // @ts-ignore
-    this.axios.defaults.headers = this.options.defaultHeaders;
+    this.axios.defaults.headers = this.options.defaultHeaders
   }
 
   static _config() {
     return [
-      { name: 'endpoint', message: 'Endpoint of API you are going to test', default: 'http://localhost:3000/api' },
-    ];
+      {
+        name: 'endpoint',
+        message: 'Endpoint of API you are going to test',
+        default: 'http://localhost:3000/api',
+      },
+    ]
   }
 
   static _checkRequirements() {
     try {
-      require('axios');
+      require('axios')
     } catch (e) {
-      return ['axios'];
+      return ['axios']
     }
   }
 
   _before() {
-    this.headers = { ...this.options.defaultHeaders };
+    this.headers = { ...this.options.defaultHeaders }
   }
 
   /**
@@ -134,7 +139,7 @@ class REST extends Helper {
    * @param {object} headers headers list
    */
   haveRequestHeaders(headers) {
-    this.headers = { ...this.headers, ...headers };
+    this.headers = { ...this.headers, ...headers }
   }
 
   /**
@@ -148,7 +153,7 @@ class REST extends Helper {
    * @param {string | CodeceptJS.Secret} accessToken  Bearer access token
    */
   amBearerAuthenticated(accessToken) {
-    this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` });
+    this.haveRequestHeaders({ Authorization: `Bearer ${accessToken}` })
   }
 
   /**
@@ -160,57 +165,65 @@ class REST extends Helper {
    */
   async _executeRequest(request) {
     // Add custom headers. They can be set by amBearerAuthenticated() or haveRequestHeaders()
-    request.headers = { ...this.headers, ...request.headers };
+    request.headers = { ...this.headers, ...request.headers }
 
-    const _debugRequest = { ...request };
-    this.axios.defaults.timeout = request.timeout || this.options.timeout;
+    const _debugRequest = { ...request }
+    this.axios.defaults.timeout = request.timeout || this.options.timeout
 
     if (this.headers && this.headers.auth) {
-      request.auth = this.headers.auth;
+      request.auth = this.headers.auth
     }
 
     if (typeof request.data === 'object') {
-      const returnedValue = {};
+      const returnedValue = {}
       for (const [key, value] of Object.entries(request.data)) {
-        returnedValue[key] = value;
-        if (value instanceof Secret) returnedValue[key] = value.getMasked();
+        returnedValue[key] = value
+        if (value instanceof Secret) returnedValue[key] = value.getMasked()
       }
-      _debugRequest.data = returnedValue;
+      _debugRequest.data = returnedValue
     }
 
     if (request.data instanceof Secret) {
-      _debugRequest.data = '*****';
-      request.data = (typeof request.data === 'object' && !(request.data instanceof Secret)) ? { ...request.data.toString() } : request.data.toString();
+      _debugRequest.data = '*****'
+      request.data =
+        typeof request.data === 'object' && !(request.data instanceof Secret)
+          ? { ...request.data.toString() }
+          : request.data.toString()
     }
 
-    if ((typeof request.data) === 'string') {
+    if (typeof request.data === 'string') {
       if (!request.headers || !request.headers['Content-Type']) {
-        request.headers = { ...request.headers, ...{ 'Content-Type': 'application/x-www-form-urlencoded' } };
+        request.headers = { ...request.headers, ...{ 'Content-Type': 'application/x-www-form-urlencoded' } }
       }
     }
 
     if (this.config.onRequest) {
-      await this.config.onRequest(request);
+      await this.config.onRequest(request)
     }
 
-    this.options.prettyPrintJson ? this.debugSection('Request', beautify(JSON.stringify(_debugRequest))) : this.debugSection('Request', JSON.stringify(_debugRequest));
+    this.options.prettyPrintJson
+      ? this.debugSection('Request', beautify(JSON.stringify(_debugRequest)))
+      : this.debugSection('Request', JSON.stringify(_debugRequest))
+
     if (this.options.printCurl) {
-      this.debugSection('CURL Request', curlize(request));
+      this.debugSection('CURL Request', curlize(request))
     }
 
-    let response;
+    let response
     try {
-      response = await this.axios(request);
+      response = await this.axios(request)
     } catch (err) {
-      if (!err.response) throw err;
-      this.debugSection('Response', `Response error. Status code: ${err.response.status}`);
-      response = err.response;
+      if (!err.response) throw err
+      this.debugSection('Response', `Response error. Status code: ${err.response.status}`)
+      response = err.response
     }
     if (this.config.onResponse) {
-      await this.config.onResponse(response);
+      await this.config.onResponse(response)
     }
-    this.options.prettyPrintJson ? this.debugSection('Response', beautify(JSON.stringify(response.data))) : this.debugSection('Response', JSON.stringify(response.data));
-    return response;
+    this.options.prettyPrintJson
+      ? this.debugSection('Response', beautify(JSON.stringify(response.data)))
+      : this.debugSection('Response', JSON.stringify(response.data))
+    return response
   }
 
   /**
@@ -219,7 +232,7 @@ class REST extends Helper {
    * @param {*} url
    */
   _url(url) {
-    return /^\w+\:\/\//.test(url) ? url : this.options.endpoint + url;
+    return /^\w+\:\/\//.test(url) ? url : this.options.endpoint + url
   }
 
   /**
@@ -232,7 +245,7 @@ class REST extends Helper {
    * @param {number} newTimeout - timeout in milliseconds
    */
   setRequestTimeout(newTimeout) {
-    this.options.timeout = newTimeout;
+    this.options.timeout = newTimeout
   }
 
   /**
@@ -251,8 +264,8 @@ class REST extends Helper {
     const request = {
       baseURL: this._url(url),
       headers,
-    };
-    return this._executeRequest(request);
+    }
+    return this._executeRequest(request)
   }
 
   /**
@@ -278,14 +291,14 @@ class REST extends Helper {
       method: 'POST',
       data: payload,
       headers,
-    };
+    }
 
     if (this.options.maxContentLength) {
-      request.maxContentLength = this.options.maxContentLength;
-      request.maxBodyLength = this.options.maxContentLength;
+      request.maxContentLength = this.options.maxContentLength
+      request.maxBodyLength = this.options.maxContentLength
     }
 
-    return this._executeRequest(request);
+    return this._executeRequest(request)
   }
 
   /**
@@ -311,14 +324,14 @@ class REST extends Helper {
       method: 'PATCH',
       data: payload,
       headers,
-    };
+    }
 
     if (this.options.maxContentLength) {
-      request.maxContentLength = this.options.maxContentLength;
-      request.maxBodyLength = this.options.maxBodyLength;
+      request.maxContentLength = this.options.maxContentLength
+      request.maxBodyLength = this.options.maxBodyLength
     }
 
-    return this._executeRequest(request);
+    return this._executeRequest(request)
   }
 
   /**
@@ -344,14 +357,14 @@ class REST extends Helper {
       method: 'PUT',
       data: payload,
       headers,
-    };
+    }
 
     if (this.options.maxContentLength) {
-      request.maxContentLength = this.options.maxContentLength;
-      request.maxBodyLength = this.options.maxBodyLength;
+      request.maxContentLength = this.options.maxContentLength
+      request.maxBodyLength = this.options.maxBodyLength
     }
 
-    return this._executeRequest(request);
+    return this._executeRequest(request)
   }
 
   /**
@@ -371,29 +384,35 @@ class REST extends Helper {
       baseURL: this._url(url),
       method: 'DELETE',
       headers,
-    };
+    }
 
-    return this._executeRequest(request);
+    return this._executeRequest(request)
   }
 }
-module.exports = REST;
+
+module.exports = REST
 
 function curlize(request) {
-  if (request.data?.constructor.name.toLowerCase() === 'formdata') return 'cURL is not printed as the request body is not a JSON';
-  let curl = `curl --location --request ${request.method ? request.method.toUpperCase() : 'GET'} ${request.baseURL} `.replace("'", '');
+  if (request.data?.constructor.name.toLowerCase() === 'formdata')
+    return 'cURL is not printed as the request body is not a JSON'
+  let curl =
+    `curl --location --request ${request.method ? request.method.toUpperCase() : 'GET'} ${request.baseURL} `.replace(
+      "'",
+      '',
+    )
 
   if (request.headers) {
     Object.entries(request.headers).forEach(([key, value]) => {
-      curl += `-H "${key}: ${value}" `;
-    });
+      curl += `-H "${key}: ${value}" `
+    })
   }
 
   if (!curl.toLowerCase().includes('content-type: application/json')) {
-    curl += '-H "Content-Type: application/json" ';
+    curl += '-H "Content-Type: application/json" '
   }
 
   if (request.data) {
-    curl += `-d '${JSON.stringify(request.data)}'`;
+    curl += `-d '${JSON.stringify(request.data)}'`
   }
-  return curl;
+  return curl
 }
diff --git a/lib/helper/TestCafe.js b/lib/helper/TestCafe.js
index e8ca9a616..86f27bc5b 100644
--- a/lib/helper/TestCafe.js
+++ b/lib/helper/TestCafe.js
@@ -1,34 +1,29 @@
 // @ts-nocheck
-const fs = require('fs');
-const assert = require('assert');
-const path = require('path');
-const qrcode = require('qrcode-terminal');
-const createTestCafe = require('testcafe');
-const { Selector, ClientFunction } = require('testcafe');
-
-const Helper = require('@codeceptjs/helper');
-const ElementNotFound = require('./errors/ElementNotFound');
-const testControllerHolder = require('./testcafe/testControllerHolder');
-const {
-  mapError,
-  createTestFile,
-  createClientFunction,
-} = require('./testcafe/testcafe-utils');
-
-const stringIncludes = require('../assert/include').includes;
-const { urlEquals } = require('../assert/equal');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
-const {
-  xpathLocator, normalizeSpacesInString,
-} = require('../utils');
-const Locator = require('../locator');
+const fs = require('fs')
+const assert = require('assert')
+const path = require('path')
+const qrcode = require('qrcode-terminal')
+const createTestCafe = require('testcafe')
+const { Selector, ClientFunction } = require('testcafe')
+
+const Helper = require('@codeceptjs/helper')
+const ElementNotFound = require('./errors/ElementNotFound')
+const testControllerHolder = require('./testcafe/testControllerHolder')
+const { mapError, createTestFile, createClientFunction } = require('./testcafe/testcafe-utils')
+
+const stringIncludes = require('../assert/include').includes
+const { urlEquals } = require('../assert/equal')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
+const { xpathLocator, normalizeSpacesInString } = require('../utils')
+const Locator = require('../locator')
 
 /**
  * Client Functions
  */
-const getPageUrl = t => ClientFunction(() => document.location.href).with({ boundTestRun: t });
-const getHtmlSource = t => ClientFunction(() => document.getElementsByTagName('html')[0].innerHTML).with({ boundTestRun: t });
+const getPageUrl = (t) => ClientFunction(() => document.location.href).with({ boundTestRun: t })
+const getHtmlSource = (t) =>
+  ClientFunction(() => document.getElementsByTagName('html')[0].innerHTML).with({ boundTestRun: t })
 
 /**
  * Uses [TestCafe](https://github.com/DevExpress/testcafe) library to run cross-browser tests.
@@ -99,16 +94,16 @@ const getHtmlSource = t => ClientFunction(() => document.getElementsByTagName('h
  */
 class TestCafe extends Helper {
   constructor(config) {
-    super(config);
+    super(config)
 
-    this.testcafe = undefined; // testcafe instance
-    this.t = undefined; // testcafe test controller
-    this.dummyTestcafeFile; // generated testcafe test file
+    this.testcafe = undefined // testcafe instance
+    this.t = undefined // testcafe test controller
+    this.dummyTestcafeFile // generated testcafe test file
 
     // context is used for within() function.
     // It requires to have _withinBeginand _withinEnd implemented.
     // Inside _withinBegin we should define that all next element calls should be started from a specific element (this.context).
-    this.context = undefined; // TODO Not sure if this applies to testcafe
+    this.context = undefined // TODO Not sure if this applies to testcafe
 
     this.options = {
       url: 'http://localhost',
@@ -123,15 +118,15 @@ class TestCafe extends Helper {
       disableScreenshots: false,
       windowSize: undefined,
       ...config,
-    };
+    }
   }
 
   // TOOD Do a requirements check
   static _checkRequirements() {
     try {
-      require('testcafe');
+      require('testcafe')
     } catch (e) {
-      return ['testcafe@^1.1.0'];
+      return ['testcafe@^1.1.0']
     }
   }
 
@@ -140,33 +135,36 @@ class TestCafe extends Helper {
       { name: 'url', message: 'Base url of site to be tested', default: 'http://localhost' },
       { name: 'browser', message: 'Browser to be used', default: 'chrome' },
       {
-        name: 'show', message: 'Show browser window', default: true, type: 'confirm',
+        name: 'show',
+        message: 'Show browser window',
+        default: true,
+        type: 'confirm',
       },
-    ];
+    ]
   }
 
   async _configureAndStartBrowser() {
-    this.dummyTestcafeFile = createTestFile(global.output_dir); // create a dummy test file to get hold of the test controller
+    this.dummyTestcafeFile = createTestFile(global.output_dir) // create a dummy test file to get hold of the test controller
 
-    this.iteration += 2; // Use different ports for each test run
+    this.iteration += 2 // Use different ports for each test run
     // @ts-ignore
-    this.testcafe = await createTestCafe('', null, null);
+    this.testcafe = await createTestCafe('', null, null)
 
-    this.debugSection('_before', 'Starting testcafe browser...');
+    this.debugSection('_before', 'Starting testcafe browser...')
 
-    this.isRunning = true;
+    this.isRunning = true
 
     // TODO Do we have to cleanup the runner?
-    const runner = this.testcafe.createRunner();
+    const runner = this.testcafe.createRunner()
 
-    this.options.browser !== 'remote' ? this._startBrowser(runner) : this._startRemoteBrowser(runner);
+    this.options.browser !== 'remote' ? this._startBrowser(runner) : this._startRemoteBrowser(runner)
 
-    this.t = await testControllerHolder.get();
-    assert(this.t, 'Expected to have the testcafe test controller');
+    this.t = await testControllerHolder.get()
+    assert(this.t, 'Expected to have the testcafe test controller')
 
     if (this.options.windowSize && this.options.windowSize.indexOf('x') > 0) {
-      const dimensions = this.options.windowSize.split('x');
-      await this.t.resizeWindow(parseInt(dimensions[0], 10), parseInt(dimensions[1], 10));
+      const dimensions = this.options.windowSize.split('x')
+      await this.t.resizeWindow(parseInt(dimensions[0], 10), parseInt(dimensions[1], 10))
     }
   }
 
@@ -190,16 +188,16 @@ class TestCafe extends Helper {
         takeScreenshotsOnFails: true,
       })
       .catch((err) => {
-        this.debugSection('_before', `Error ${err.toString()}`);
-        this.isRunning = false;
-        this.testcafe.close();
-      });
+        this.debugSection('_before', `Error ${err.toString()}`)
+        this.isRunning = false
+        this.testcafe.close()
+      })
   }
 
   async _startRemoteBrowser(runner) {
-    const remoteConnection = await this.testcafe.createBrowserConnection();
-    console.log('Connect your device to the following URL or scan QR Code: ', remoteConnection.url);
-    qrcode.generate(remoteConnection.url);
+    const remoteConnection = await this.testcafe.createBrowserConnection()
+    console.log('Connect your device to the following URL or scan QR Code: ', remoteConnection.url)
+    qrcode.generate(remoteConnection.url)
     remoteConnection.once('ready', () => {
       runner
         .src(this.dummyTestcafeFile)
@@ -211,70 +209,67 @@ class TestCafe extends Helper {
           skipUncaughtErrors: true,
         })
         .catch((err) => {
-          this.debugSection('_before', `Error ${err.toString()}`);
-          this.isRunning = false;
-          this.testcafe.close();
-        });
-    });
+          this.debugSection('_before', `Error ${err.toString()}`)
+          this.isRunning = false
+          this.testcafe.close()
+        })
+    })
   }
 
   async _stopBrowser() {
-    this.debugSection('_after', 'Stopping testcafe browser...');
+    this.debugSection('_after', 'Stopping testcafe browser...')
 
-    testControllerHolder.free();
+    testControllerHolder.free()
     if (this.testcafe) {
-      this.testcafe.close();
+      this.testcafe.close()
     }
 
-    fs.unlinkSync(this.dummyTestcafeFile); // remove the dummy test
-    this.t = undefined;
+    fs.unlinkSync(this.dummyTestcafeFile) // remove the dummy test
+    this.t = undefined
 
-    this.isRunning = false;
+    this.isRunning = false
   }
 
-  _init() {
-  }
+  _init() {}
 
   async _beforeSuite() {
     if (!this.options.restart && !this.options.manualStart && !this.isRunning) {
-      this.debugSection('Session', 'Starting singleton browser session');
-      return this._configureAndStartBrowser();
+      this.debugSection('Session', 'Starting singleton browser session')
+      return this._configureAndStartBrowser()
     }
   }
 
   async _before() {
-    if (this.options.restart && !this.options.manualStart) return this._configureAndStartBrowser();
-    if (!this.isRunning && !this.options.manualStart) return this._configureAndStartBrowser();
-    this.context = null;
+    if (this.options.restart && !this.options.manualStart) return this._configureAndStartBrowser()
+    if (!this.isRunning && !this.options.manualStart) return this._configureAndStartBrowser()
+    this.context = null
   }
 
   async _after() {
-    if (!this.isRunning) return;
+    if (!this.isRunning) return
 
     if (this.options.restart) {
-      this.isRunning = false;
-      return this._stopBrowser();
+      this.isRunning = false
+      return this._stopBrowser()
     }
 
-    if (this.options.keepBrowserState) return;
+    if (this.options.keepBrowserState) return
 
     if (!this.options.keepCookies) {
-      this.debugSection('Session', 'cleaning cookies and localStorage');
-      await this.clearCookie();
+      this.debugSection('Session', 'cleaning cookies and localStorage')
+      await this.clearCookie()
 
       // TODO IMHO that should only happen when
-      await this.executeScript(() => localStorage.clear())
-        .catch((err) => {
-          if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err;
-        });
+      await this.executeScript(() => localStorage.clear()).catch((err) => {
+        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+      })
     }
   }
 
-  _afterSuite() {
-  }
+  _afterSuite() {}
 
   async _finishTest() {
-    if (!this.options.restart && this.isRunning) return this._stopBrowser();
+    if (!this.options.restart && this.isRunning) return this._stopBrowser()
   }
 
   /**
@@ -297,7 +292,7 @@ class TestCafe extends Helper {
    * @param {function} fn async functuion that executed with TestCafe helper as argument
    */
   useTestCafeTo(description, fn) {
-    return this._useTo(...arguments);
+    return this._useTo(...arguments)
   }
 
   /**
@@ -310,29 +305,28 @@ class TestCafe extends Helper {
    *
    */
   async _locate(locator) {
-    return findElements.call(this, this.context, locator).catch(mapError);
+    return findElements.call(this, this.context, locator).catch(mapError)
   }
 
   async _withinBegin(locator) {
-    const els = await this._locate(locator);
-    assertElementExists(els, locator);
-    this.context = await els.nth(0);
+    const els = await this._locate(locator)
+    assertElementExists(els, locator)
+    this.context = await els.nth(0)
   }
 
   async _withinEnd() {
-    this.context = null;
+    this.context = null
   }
 
   /**
    * {{> amOnPage }}
    */
   async amOnPage(url) {
-    if (!(/^\w+\:\/\//.test(url))) {
-      url = this.options.url + url;
+    if (!/^\w+\:\/\//.test(url)) {
+      url = this.options.url + url
     }
 
-    return this.t.navigateTo(url)
-      .catch(mapError);
+    return this.t.navigateTo(url).catch(mapError)
   }
 
   /**
@@ -340,10 +334,10 @@ class TestCafe extends Helper {
    */
   async resizeWindow(width, height) {
     if (width === 'maximize') {
-      return this.t.maximizeWindow().catch(mapError);
+      return this.t.maximizeWindow().catch(mapError)
     }
 
-    return this.t.resizeWindow(width, height).catch(mapError);
+    return this.t.resizeWindow(width, height).catch(mapError)
   }
 
   /**
@@ -351,13 +345,16 @@ class TestCafe extends Helper {
    *
    */
   async focus(locator) {
-    const els = await this._locate(locator);
-    await assertElementExists(els, locator, 'Element to focus');
-    const element = await els.nth(0);
+    const els = await this._locate(locator)
+    await assertElementExists(els, locator, 'Element to focus')
+    const element = await els.nth(0)
 
-    const focusElement = ClientFunction(() => element().focus(), { boundTestRun: this.t, dependencies: { element } });
+    const focusElement = ClientFunction(() => element().focus(), {
+      boundTestRun: this.t,
+      dependencies: { element },
+    })
 
-    return focusElement();
+    return focusElement()
   }
 
   /**
@@ -365,13 +362,13 @@ class TestCafe extends Helper {
    *
    */
   async blur(locator) {
-    const els = await this._locate(locator);
-    await assertElementExists(els, locator, 'Element to blur');
-    const element = await els.nth(0);
+    const els = await this._locate(locator)
+    await assertElementExists(els, locator, 'Element to blur')
+    const element = await els.nth(0)
 
-    const blurElement = ClientFunction(() => element().blur(), { boundTestRun: this.t, dependencies: { element } });
+    const blurElement = ClientFunction(() => element().blur(), { boundTestRun: this.t, dependencies: { element } })
 
-    return blurElement();
+    return blurElement()
   }
 
   /**
@@ -379,7 +376,7 @@ class TestCafe extends Helper {
    *
    */
   async click(locator, context = null) {
-    return proceedClick.call(this, locator, context);
+    return proceedClick.call(this, locator, context)
   }
 
   /**
@@ -387,7 +384,7 @@ class TestCafe extends Helper {
    */
   async refreshPage() {
     // eslint-disable-next-line no-restricted-globals
-    return this.t.eval(() => location.reload(true), { boundTestRun: this.t }).catch(mapError);
+    return this.t.eval(() => location.reload(true), { boundTestRun: this.t }).catch(mapError)
   }
 
   /**
@@ -395,37 +392,33 @@ class TestCafe extends Helper {
    *
    */
   async waitForVisible(locator, sec) {
-    const timeout = sec ? sec * 1000 : undefined;
+    const timeout = sec ? sec * 1000 : undefined
 
     return (await findElements.call(this, this.context, locator))
       .with({ visibilityCheck: true, timeout })()
-      .catch(mapError);
+      .catch(mapError)
   }
 
   /**
    * {{> fillField }}
    */
   async fillField(field, value) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
-    return this.t
-      .typeText(el, value.toString(), { replace: true })
-      .catch(mapError);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
+    return this.t.typeText(el, value.toString(), { replace: true }).catch(mapError)
   }
 
   /**
    * {{> clearField }}
    */
   async clearField(field) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
 
-    const res = await this.t
-      .selectText(el)
-      .pressKey('delete');
-    return res;
+    const res = await this.t.selectText(el).pressKey('delete')
+    return res
   }
 
   /**
@@ -433,13 +426,11 @@ class TestCafe extends Helper {
    *
    */
   async appendField(field, value) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
 
-    return this.t
-      .typeText(el, value.toString(), { replace: false })
-      .catch(mapError);
+    return this.t.typeText(el, value.toString(), { replace: false }).catch(mapError)
   }
 
   /**
@@ -447,14 +438,12 @@ class TestCafe extends Helper {
    *
    */
   async attachFile(field, pathToFile) {
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
-    const file = path.join(global.codecept_dir, pathToFile);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
+    const file = path.join(global.codecept_dir, pathToFile)
 
-    return this.t
-      .setFilesToUpload(el, [file])
-      .catch(mapError);
+    return this.t.setFilesToUpload(el, [file]).catch(mapError)
   }
 
   /**
@@ -463,11 +452,11 @@ class TestCafe extends Helper {
    * {{ keys }}
    */
   async pressKey(key) {
-    assert(key, 'Expected a sequence of keys or key combinations');
+    assert(key, 'Expected a sequence of keys or key combinations')
 
     return this.t
       .pressKey(key.toLowerCase()) // testcafe keys are lowercase
-      .catch(mapError);
+      .catch(mapError)
   }
 
   /**
@@ -475,12 +464,10 @@ class TestCafe extends Helper {
    *
    */
   async moveCursorTo(locator, offsetX = 0, offsetY = 0) {
-    const els = (await findElements.call(this, this.context, locator)).filterVisible();
-    await assertElementExists(els, locator);
+    const els = (await findElements.call(this, this.context, locator)).filterVisible()
+    await assertElementExists(els, locator)
 
-    return this.t
-      .hover(els.nth(0), { offsetX, offsetY })
-      .catch(mapError);
+    return this.t.hover(els.nth(0), { offsetX, offsetY }).catch(mapError)
   }
 
   /**
@@ -488,17 +475,15 @@ class TestCafe extends Helper {
    *
    */
   async doubleClick(locator, context = null) {
-    let matcher;
+    let matcher
     if (context) {
-      const els = await this._locate(context);
-      await assertElementExists(els, context);
-      matcher = await els.nth(0);
+      const els = await this._locate(context)
+      await assertElementExists(els, context)
+      matcher = await els.nth(0)
     }
 
-    const els = (await findClickable.call(this, matcher, locator)).filterVisible();
-    return this.t
-      .doubleClick(els.nth(0))
-      .catch(mapError);
+    const els = (await findClickable.call(this, matcher, locator)).filterVisible()
+    return this.t.doubleClick(els.nth(0)).catch(mapError)
   }
 
   /**
@@ -506,40 +491,34 @@ class TestCafe extends Helper {
    *
    */
   async rightClick(locator, context = null) {
-    let matcher;
+    let matcher
     if (context) {
-      const els = await this._locate(context);
-      await assertElementExists(els, context);
-      matcher = await els.nth(0);
+      const els = await this._locate(context)
+      await assertElementExists(els, context)
+      matcher = await els.nth(0)
     }
-    const els = (await findClickable.call(this, matcher, locator)).filterVisible();
-    assertElementExists(els, locator);
-    return this.t
-      .rightClick(els.nth(0))
-      .catch(mapError);
+    const els = (await findClickable.call(this, matcher, locator)).filterVisible()
+    assertElementExists(els, locator)
+    return this.t.rightClick(els.nth(0)).catch(mapError)
   }
 
   /**
    * {{> checkOption }}
    */
   async checkOption(field, context = null) {
-    const el = await findCheckable.call(this, field, context);
+    const el = await findCheckable.call(this, field, context)
 
-    return this.t
-      .click(el)
-      .catch(mapError);
+    return this.t.click(el).catch(mapError)
   }
 
   /**
    * {{> uncheckOption }}
    */
   async uncheckOption(field, context = null) {
-    const el = await findCheckable.call(this, field, context);
+    const el = await findCheckable.call(this, field, context)
 
     if (await el.checked) {
-      return this.t
-        .click(el)
-        .catch(mapError);
+      return this.t.click(el).catch(mapError)
     }
   }
 
@@ -547,58 +526,56 @@ class TestCafe extends Helper {
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'assert', field);
+    return proceedIsChecked.call(this, 'assert', field)
   }
 
   /**
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedIsChecked.call(this, 'negate', field);
+    return proceedIsChecked.call(this, 'negate', field)
   }
 
   /**
    * {{> selectOption }}
    */
   async selectOption(select, option) {
-    const els = await findFields.call(this, select);
-    assertElementExists(els, select, 'Selectable field');
+    const els = await findFields.call(this, select)
+    assertElementExists(els, select, 'Selectable field')
 
-    const el = await els.filterVisible().nth(0);
+    const el = await els.filterVisible().nth(0)
 
     if ((await el.tagName).toLowerCase() !== 'select') {
-      throw new Error('Element is not <select>');
+      throw new Error('Element is not <select>')
     }
-    if (!Array.isArray(option)) option = [option];
+    if (!Array.isArray(option)) option = [option]
 
     // TODO As far as I understand the testcafe docs this should do a multi-select
     // but it does not work
     // const clickOpts = { ctrl: option.length > 1 };
-    await this.t.click(el).catch(mapError);
+    await this.t.click(el).catch(mapError)
 
     for (const key of option) {
-      const opt = key;
+      const opt = key
 
-      let optEl;
+      let optEl
       try {
-        optEl = el.child('option').withText(opt);
+        optEl = el.child('option').withText(opt)
         if (await optEl.count) {
-          await this.t.click(optEl).catch(mapError);
-          continue;
+          await this.t.click(optEl).catch(mapError)
+          continue
         }
         // eslint-disable-next-line no-empty
-      } catch (err) {
-      }
+      } catch (err) {}
 
       try {
-        const sel = `[value="${opt}"]`;
-        optEl = el.find(sel);
+        const sel = `[value="${opt}"]`
+        optEl = el.find(sel)
         if (await optEl.count) {
-          await this.t.click(optEl).catch(mapError);
+          await this.t.click(optEl).catch(mapError)
         }
         // eslint-disable-next-line no-empty
-      } catch (err) {
-      }
+      } catch (err) {}
     }
   }
 
@@ -606,28 +583,28 @@ class TestCafe extends Helper {
    * {{> seeInCurrentUrl }}
    */
   async seeInCurrentUrl(url) {
-    stringIncludes('url').assert(url, await getPageUrl(this.t)().catch(mapError));
+    stringIncludes('url').assert(url, await getPageUrl(this.t)().catch(mapError))
   }
 
   /**
    * {{> dontSeeInCurrentUrl }}
    */
   async dontSeeInCurrentUrl(url) {
-    stringIncludes('url').negate(url, await getPageUrl(this.t)().catch(mapError));
+    stringIncludes('url').negate(url, await getPageUrl(this.t)().catch(mapError))
   }
 
   /**
    * {{> seeCurrentUrlEquals }}
    */
   async seeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).assert(url, await getPageUrl(this.t)().catch(mapError));
+    urlEquals(this.options.url).assert(url, await getPageUrl(this.t)().catch(mapError))
   }
 
   /**
    * {{> dontSeeCurrentUrlEquals }}
    */
   async dontSeeCurrentUrlEquals(url) {
-    urlEquals(this.options.url).negate(url, await getPageUrl(this.t)().catch(mapError));
+    urlEquals(this.options.url).negate(url, await getPageUrl(this.t)().catch(mapError))
   }
 
   /**
@@ -635,16 +612,14 @@ class TestCafe extends Helper {
    *
    */
   async see(text, context = null) {
-    let els;
+    let els
     if (context) {
-      els = (await findElements.call(this, this.context, context)).withText(normalizeSpacesInString(text));
+      els = (await findElements.call(this, this.context, context)).withText(normalizeSpacesInString(text))
     } else {
-      els = (await findElements.call(this, this.context, '*')).withText(normalizeSpacesInString(text));
+      els = (await findElements.call(this, this.context, '*')).withText(normalizeSpacesInString(text))
     }
 
-    return this.t
-      .expect(els.filterVisible().count).gt(0, `No element with text "${text}" found`)
-      .catch(mapError);
+    return this.t.expect(els.filterVisible().count).gt(0, `No element with text "${text}" found`).catch(mapError)
   }
 
   /**
@@ -652,56 +627,61 @@ class TestCafe extends Helper {
    *
    */
   async dontSee(text, context = null) {
-    let els;
+    let els
     if (context) {
-      els = (await findElements.call(this, this.context, context)).withText(text);
+      els = (await findElements.call(this, this.context, context)).withText(text)
     } else {
-      els = (await findElements.call(this, this.context, 'body')).withText(text);
+      els = (await findElements.call(this, this.context, 'body')).withText(text)
     }
 
     return this.t
-      .expect(els.filterVisible().count).eql(0, `Element with text "${text}" can still be seen`)
-      .catch(mapError);
+      .expect(els.filterVisible().count)
+      .eql(0, `Element with text "${text}" can still be seen`)
+      .catch(mapError)
   }
 
   /**
    * {{> seeElement }}
    */
   async seeElement(locator) {
-    const exists = (await findElements.call(this, this.context, locator)).filterVisible().exists;
+    const exists = (await findElements.call(this, this.context, locator)).filterVisible().exists
     return this.t
-      .expect(exists).ok(`No element "${(new Locator(locator))}" found`)
-      .catch(mapError);
+      .expect(exists)
+      .ok(`No element "${new Locator(locator)}" found`)
+      .catch(mapError)
   }
 
   /**
    * {{> dontSeeElement }}
    */
   async dontSeeElement(locator) {
-    const exists = (await findElements.call(this, this.context, locator)).filterVisible().exists;
+    const exists = (await findElements.call(this, this.context, locator)).filterVisible().exists
     return this.t
-      .expect(exists).notOk(`Element "${(new Locator(locator))}" is still visible`)
-      .catch(mapError);
+      .expect(exists)
+      .notOk(`Element "${new Locator(locator)}" is still visible`)
+      .catch(mapError)
   }
 
   /**
    * {{> seeElementInDOM }}
    */
   async seeElementInDOM(locator) {
-    const exists = (await findElements.call(this, this.context, locator)).exists;
+    const exists = (await findElements.call(this, this.context, locator)).exists
     return this.t
-      .expect(exists).ok(`No element "${(new Locator(locator))}" found in DOM`)
-      .catch(mapError);
+      .expect(exists)
+      .ok(`No element "${new Locator(locator)}" found in DOM`)
+      .catch(mapError)
   }
 
   /**
    * {{> dontSeeElementInDOM }}
    */
   async dontSeeElementInDOM(locator) {
-    const exists = (await findElements.call(this, this.context, locator)).exists;
+    const exists = (await findElements.call(this, this.context, locator)).exists
     return this.t
-      .expect(exists).notOk(`Element "${(new Locator(locator))}" is still in DOM`)
-      .catch(mapError);
+      .expect(exists)
+      .notOk(`Element "${new Locator(locator)}" is still in DOM`)
+      .catch(mapError)
   }
 
   /**
@@ -709,48 +689,45 @@ class TestCafe extends Helper {
    *
    */
   async seeNumberOfVisibleElements(locator, num) {
-    const count = (await findElements.call(this, this.context, locator)).filterVisible().count;
-    return this.t
-      .expect(count).eql(num)
-      .catch(mapError);
+    const count = (await findElements.call(this, this.context, locator)).filterVisible().count
+    return this.t.expect(count).eql(num).catch(mapError)
   }
 
   /**
    * {{> grabNumberOfVisibleElements }}
    */
   async grabNumberOfVisibleElements(locator) {
-    const count = (await findElements.call(this, this.context, locator)).filterVisible().count;
-    return count;
+    const count = (await findElements.call(this, this.context, locator)).filterVisible().count
+    return count
   }
 
   /**
    * {{> seeInField }}
    */
   async seeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
+    const _value = typeof value === 'boolean' ? value : value.toString()
     // const expectedValue = findElements.call(this, this.context, field).value;
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
 
     return this.t
-      .expect(await el.value).eql(_value)
-      .catch(mapError);
+      .expect(await el.value)
+      .eql(_value)
+      .catch(mapError)
   }
 
   /**
    * {{> dontSeeInField }}
    */
   async dontSeeInField(field, value) {
-    const _value = (typeof value === 'boolean') ? value : value.toString();
+    const _value = typeof value === 'boolean' ? value : value.toString()
     // const expectedValue = findElements.call(this, this.context, field).value;
-    const els = await findFields.call(this, field);
-    assertElementExists(els, field, 'Field');
-    const el = await els.nth(0);
+    const els = await findFields.call(this, field)
+    assertElementExists(els, field, 'Field')
+    const el = await els.nth(0)
 
-    return this.t
-      .expect(el.value).notEql(_value)
-      .catch(mapError);
+    return this.t.expect(el.value).notEql(_value).catch(mapError)
   }
 
   /**
@@ -761,26 +738,24 @@ class TestCafe extends Helper {
    * ```
    */
   async seeTextEquals(text, context = null) {
-    const expectedText = findElements.call(this, context, undefined).textContent;
-    return this.t
-      .expect(expectedText).eql(text)
-      .catch(mapError);
+    const expectedText = findElements.call(this, context, undefined).textContent
+    return this.t.expect(expectedText).eql(text).catch(mapError)
   }
 
   /**
    * {{> seeInSource }}
    */
   async seeInSource(text) {
-    const source = await getHtmlSource(this.t)();
-    stringIncludes('HTML source of a page').assert(text, source);
+    const source = await getHtmlSource(this.t)()
+    stringIncludes('HTML source of a page').assert(text, source)
   }
 
   /**
    * {{> dontSeeInSource }}
    */
   async dontSeeInSource(text) {
-    const source = await getHtmlSource(this.t)();
-    stringIncludes('HTML source of a page').negate(text, source);
+    const source = await getHtmlSource(this.t)()
+    stringIncludes('HTML source of a page').negate(text, source)
   }
 
   /**
@@ -788,14 +763,14 @@ class TestCafe extends Helper {
    *
    */
   async saveElementScreenshot(locator, fileName) {
-    const outputFile = path.join(global.output_dir, fileName);
+    const outputFile = path.join(global.output_dir, fileName)
 
-    const sel = await findElements.call(this, this.context, locator);
-    assertElementExists(sel, locator);
-    const firstElement = await sel.filterVisible().nth(0);
+    const sel = await findElements.call(this, this.context, locator)
+    assertElementExists(sel, locator)
+    const firstElement = await sel.filterVisible().nth(0)
 
-    this.debug(`Screenshot of ${(new Locator(locator))} element has been saved to ${outputFile}`);
-    return this.t.takeElementScreenshot(firstElement, fileName);
+    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+    return this.t.takeElementScreenshot(firstElement, fileName)
   }
 
   /**
@@ -803,20 +778,20 @@ class TestCafe extends Helper {
    */
   // TODO Implement full page screenshots
   async saveScreenshot(fileName) {
-    const outputFile = path.join(global.output_dir, fileName);
-    this.debug(`Screenshot is saving to ${outputFile}`);
+    const outputFile = path.join(global.output_dir, fileName)
+    this.debug(`Screenshot is saving to ${outputFile}`)
 
     // TODO testcafe automatically creates thumbnail images (which cant be turned off)
-    return this.t.takeScreenshot(fileName);
+    return this.t.takeScreenshot(fileName)
   }
 
   /**
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise(((done) => {
-      setTimeout(done, sec * 1000);
-    }));
+    return new Promise((done) => {
+      setTimeout(done, sec * 1000)
+    })
   }
 
   /**
@@ -825,99 +800,99 @@ class TestCafe extends Helper {
    * If a function returns a Promise It will wait for its resolution.
    */
   async executeScript(fn, ...args) {
-    const browserFn = createClientFunction(fn, args).with({ boundTestRun: this.t });
-    return browserFn();
+    const browserFn = createClientFunction(fn, args).with({ boundTestRun: this.t })
+    return browserFn()
   }
 
   /**
    * {{> grabTextFromAll }}
    */
   async grabTextFromAll(locator) {
-    const sel = await findElements.call(this, this.context, locator);
-    const length = await sel.count;
-    const texts = [];
+    const sel = await findElements.call(this, this.context, locator)
+    const length = await sel.count
+    const texts = []
     for (let i = 0; i < length; i++) {
-      texts.push(await sel.nth(i).innerText);
+      texts.push(await sel.nth(i).innerText)
     }
 
-    return texts;
+    return texts
   }
 
   /**
    * {{> grabTextFrom }}
    */
   async grabTextFrom(locator) {
-    const sel = await findElements.call(this, this.context, locator);
-    assertElementExists(sel, locator);
-    const texts = await this.grabTextFromAll(locator);
+    const sel = await findElements.call(this, this.context, locator)
+    assertElementExists(sel, locator)
+    const texts = await this.grabTextFromAll(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]
   }
 
   /**
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFromAll(locator, attr) {
-    const sel = await findElements.call(this, this.context, locator);
-    const length = await sel.count;
-    const attrs = [];
+    const sel = await findElements.call(this, this.context, locator)
+    const length = await sel.count
+    const attrs = []
     for (let i = 0; i < length; i++) {
-      attrs.push(await (await sel.nth(i)).getAttribute(attr));
+      attrs.push(await (await sel.nth(i)).getAttribute(attr))
     }
 
-    return attrs;
+    return attrs
   }
 
   /**
    * {{> grabAttributeFrom }}
    */
   async grabAttributeFrom(locator, attr) {
-    const sel = await findElements.call(this, this.context, locator);
-    assertElementExists(sel, locator);
-    const attrs = await this.grabAttributeFromAll(locator, attr);
+    const sel = await findElements.call(this, this.context, locator)
+    assertElementExists(sel, locator)
+    const attrs = await this.grabAttributeFromAll(locator, attr)
     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]
   }
 
   /**
    * {{> grabValueFromAll }}
    */
   async grabValueFromAll(locator) {
-    const sel = await findElements.call(this, this.context, locator);
-    const length = await sel.count;
-    const values = [];
+    const sel = await findElements.call(this, this.context, locator)
+    const length = await sel.count
+    const values = []
     for (let i = 0; i < length; i++) {
-      values.push(await (await sel.nth(i)).value);
+      values.push(await (await sel.nth(i)).value)
     }
 
-    return values;
+    return values
   }
 
   /**
    * {{> grabValueFrom }}
    */
   async grabValueFrom(locator) {
-    const sel = await findElements.call(this, this.context, locator);
-    assertElementExists(sel, locator);
-    const values = await this.grabValueFromAll(locator);
+    const sel = await findElements.call(this, this.context, locator)
+    assertElementExists(sel, locator)
+    const values = await this.grabValueFromAll(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]
   }
 
   /**
    * {{> grabSource }}
    */
   async grabSource() {
-    return ClientFunction(() => document.documentElement.innerHTML).with({ boundTestRun: this.t })();
+    return ClientFunction(() => document.documentElement.innerHTML).with({ boundTestRun: this.t })()
   }
 
   /**
@@ -930,28 +905,30 @@ class TestCafe extends Helper {
    */
   async grabBrowserLogs() {
     // TODO Must map?
-    return this.t.getBrowserConsoleMessages();
+    return this.t.getBrowserConsoleMessages()
   }
 
   /**
    * {{> grabCurrentUrl }}
    */
   async grabCurrentUrl() {
-    return ClientFunction(() => document.location.href).with({ boundTestRun: this.t })();
+    return ClientFunction(() => document.location.href).with({ boundTestRun: this.t })()
   }
 
   /**
    * {{> grabPageScrollPosition }}
    */
   async grabPageScrollPosition() {
-    return ClientFunction(() => ({ x: window.pageXOffset, y: window.pageYOffset })).with({ boundTestRun: this.t })();
+    return ClientFunction(() => ({ x: window.pageXOffset, y: window.pageYOffset })).with({ boundTestRun: this.t })()
   }
 
   /**
    * {{> scrollPageToTop }}
    */
   scrollPageToTop() {
-    return ClientFunction(() => window.scrollTo(0, 0)).with({ boundTestRun: this.t })().catch(mapError);
+    return ClientFunction(() => window.scrollTo(0, 0))
+      .with({ boundTestRun: this.t })()
+      .catch(mapError)
   }
 
   /**
@@ -959,16 +936,15 @@ class TestCafe extends Helper {
    */
   scrollPageToBottom() {
     return ClientFunction(() => {
-      const body = document.body;
-      const html = document.documentElement;
-      window.scrollTo(0, Math.max(
-        body.scrollHeight,
-        body.offsetHeight,
-        html.clientHeight,
-        html.scrollHeight,
-        html.offsetHeight,
-      ));
-    }).with({ boundTestRun: this.t })().catch(mapError);
+      const body = document.body
+      const html = document.documentElement
+      window.scrollTo(
+        0,
+        Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
+      )
+    })
+      .with({ boundTestRun: this.t })()
+      .catch(mapError)
   }
 
   /**
@@ -976,30 +952,30 @@ class TestCafe 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
     }
 
     const scrollBy = ClientFunction((offset) => {
       if (window && window.scrollBy && offset) {
-        window.scrollBy(offset.x, offset.y);
+        window.scrollBy(offset.x, offset.y)
       }
-    }).with({ boundTestRun: this.t });
+    }).with({ boundTestRun: this.t })
 
     if (locator) {
-      const els = await this._locate(locator);
-      assertElementExists(els, locator, 'Element');
-      const el = await els.nth(0);
-      const x = (await el.offsetLeft) + offsetX;
-      const y = (await el.offsetTop) + offsetY;
+      const els = await this._locate(locator)
+      assertElementExists(els, locator, 'Element')
+      const el = await els.nth(0)
+      const x = (await el.offsetLeft) + offsetX
+      const y = (await el.offsetTop) + offsetY
 
-      return scrollBy({ x, y }).catch(mapError);
+      return scrollBy({ x, y }).catch(mapError)
     }
 
-    const x = offsetX;
-    const y = offsetY;
-    return scrollBy({ x, y }).catch(mapError);
+    const x = offsetX
+    const y = offsetY
+    return scrollBy({ x, y }).catch(mapError)
   }
 
   /**
@@ -1007,15 +983,15 @@ class TestCafe extends Helper {
    */
   async switchTo(locator) {
     if (Number.isInteger(locator)) {
-      throw new Error('Not supported switching to iframe by number');
+      throw new Error('Not supported switching to iframe by number')
     }
 
     if (!locator) {
-      return this.t.switchToMainWindow();
+      return this.t.switchToMainWindow()
     }
 
-    const el = await findElements.call(this, this.context, locator);
-    return this.t.switchToIframe(el);
+    const el = await findElements.call(this, this.context, locator)
+    return this.t.switchToIframe(el)
   }
 
   // TODO Add url assertions
@@ -1025,17 +1001,20 @@ class TestCafe extends Helper {
    */
   async setCookie(cookie) {
     if (Array.isArray(cookie)) {
-      throw new Error('cookie array is not supported');
+      throw new Error('cookie array is not supported')
     }
 
-    cookie.path = cookie.path || '/';
+    cookie.path = cookie.path || '/'
     // cookie.expires = cookie.expires || (new Date()).toUTCString();
 
-    const setCookie = ClientFunction(() => {
-      document.cookie = `${cookie.name}=${cookie.value};path=${cookie.path};expires=${cookie.expires};`;
-    }, { dependencies: { cookie } }).with({ boundTestRun: this.t });
+    const setCookie = ClientFunction(
+      () => {
+        document.cookie = `${cookie.name}=${cookie.value};path=${cookie.path};expires=${cookie.expires};`
+      },
+      { dependencies: { cookie } },
+    ).with({ boundTestRun: this.t })
 
-    return setCookie();
+    return setCookie()
   }
 
   /**
@@ -1043,16 +1022,16 @@ class TestCafe extends Helper {
    *
    */
   async seeCookie(name) {
-    const cookie = await this.grabCookie(name);
-    empty(`cookie ${name} to be set`).negate(cookie);
+    const cookie = await this.grabCookie(name)
+    empty(`cookie ${name} to be set`).negate(cookie)
   }
 
   /**
    * {{> dontSeeCookie }}
    */
   async dontSeeCookie(name) {
-    const cookie = await this.grabCookie(name);
-    empty(`cookie ${name} not to be set`).assert(cookie);
+    const cookie = await this.grabCookie(name)
+    empty(`cookie ${name} not to be set`).assert(cookie)
   }
 
   /**
@@ -1063,141 +1042,153 @@ class TestCafe extends Helper {
   async grabCookie(name) {
     if (!name) {
       const getCookie = ClientFunction(() => {
-        return document.cookie.split(';').map(c => c.split('='));
-      }).with({ boundTestRun: this.t });
-      const cookies = await getCookie();
-      return cookies.map(cookie => ({ name: cookie[0].trim(), value: cookie[1] }));
+        return document.cookie.split(';').map((c) => c.split('='))
+      }).with({ boundTestRun: this.t })
+      const cookies = await getCookie()
+      return cookies.map((cookie) => ({ name: cookie[0].trim(), value: cookie[1] }))
     }
-    const getCookie = ClientFunction(() => {
-      // eslint-disable-next-line prefer-template
-      const v = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
-      return v ? v[2] : null;
-    }, { dependencies: { name } }).with({ boundTestRun: this.t });
-    const value = await getCookie();
-    if (value) return { name, value };
+    const getCookie = ClientFunction(
+      () => {
+        // eslint-disable-next-line prefer-template
+        const v = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)')
+        return v ? v[2] : null
+      },
+      { dependencies: { name } },
+    ).with({ boundTestRun: this.t })
+    const value = await getCookie()
+    if (value) return { name, value }
   }
 
   /**
    * {{> clearCookie }}
    */
   async clearCookie(cookieName) {
-    const clearCookies = ClientFunction(() => {
-      const cookies = document.cookie.split(';');
-
-      for (let i = 0; i < cookies.length; i++) {
-        const cookie = cookies[i];
-        const eqPos = cookie.indexOf('=');
-        const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
-        if (cookieName === undefined || name === cookieName) {
-          document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+    const clearCookies = ClientFunction(
+      () => {
+        const cookies = document.cookie.split(';')
+
+        for (let i = 0; i < cookies.length; i++) {
+          const cookie = cookies[i]
+          const eqPos = cookie.indexOf('=')
+          const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie
+          if (cookieName === undefined || name === cookieName) {
+            document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT`
+          }
         }
-      }
-    }, { dependencies: { cookieName } }).with({ boundTestRun: this.t });
+      },
+      { dependencies: { cookieName } },
+    ).with({ boundTestRun: this.t })
 
-    return clearCookies();
+    return clearCookies()
   }
 
   /**
    * {{> waitInUrl }}
    */
   async waitInUrl(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    const clientFn = createClientFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl.indexOf(urlPart) > -1;
-    }, [urlPart]).with({ boundTestRun: this.t });
+    const clientFn = createClientFunction(
+      (urlPart) => {
+        const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+        return currUrl.indexOf(urlPart) > -1
+      },
+      [urlPart],
+    ).with({ boundTestRun: this.t })
 
     return waitForFunction(clientFn, waitTimeout).catch(async () => {
-      const currUrl = await this.grabCurrentUrl();
-      throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`);
-    });
+      const currUrl = await this.grabCurrentUrl()
+      throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
+    })
   }
 
   /**
    * {{> waitUrlEquals }}
    */
   async waitUrlEquals(urlPart, sec = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    const baseUrl = this.options.url;
+    const baseUrl = this.options.url
     if (urlPart.indexOf('http') < 0) {
-      urlPart = baseUrl + urlPart;
+      urlPart = baseUrl + urlPart
     }
 
-    const clientFn = createClientFunction((urlPart) => {
-      const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)));
-      return currUrl === urlPart;
-    }, [urlPart]).with({ boundTestRun: this.t });
+    const clientFn = createClientFunction(
+      (urlPart) => {
+        const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
+        return currUrl === urlPart
+      },
+      [urlPart],
+    ).with({ boundTestRun: this.t })
 
     return waitForFunction(clientFn, waitTimeout).catch(async () => {
-      const currUrl = await this.grabCurrentUrl();
-      throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`);
-    });
+      const currUrl = await this.grabCurrentUrl()
+      throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+    })
   }
 
   /**
    * {{> 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 waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    const clientFn = createClientFunction(fn, args).with({ boundTestRun: this.t });
+    const clientFn = createClientFunction(fn, args).with({ boundTestRun: this.t })
 
-    return waitForFunction(clientFn, waitTimeout);
+    return waitForFunction(clientFn, waitTimeout)
   }
 
   /**
    * {{> waitNumberOfVisibleElements }}
    */
   async waitNumberOfVisibleElements(locator, num, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
     return this.t
       .expect(createSelector(locator).with({ boundTestRun: this.t }).filterVisible().count)
-      .eql(num, `The number of elements (${(new Locator(locator))}) is not ${num} after ${sec} sec`, { timeout: waitTimeout })
-      .catch(mapError);
+      .eql(num, `The number of elements (${new Locator(locator)}) is not ${num} after ${sec} sec`, {
+        timeout: waitTimeout,
+      })
+      .catch(mapError)
   }
 
   /**
    * {{> waitForElement }}
    */
   async waitForElement(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    return this.t
-      .expect(createSelector(locator).with({ boundTestRun: this.t }).exists)
-      .ok({ timeout: waitTimeout });
+    return this.t.expect(createSelector(locator).with({ boundTestRun: this.t }).exists).ok({ timeout: waitTimeout })
   }
 
   /**
    * {{> waitToHide }}
    */
   async waitToHide(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
     return this.t
       .expect(createSelector(locator).filterHidden().with({ boundTestRun: this.t }).exists)
-      .notOk({ timeout: waitTimeout });
+      .notOk({ timeout: waitTimeout })
   }
 
   /**
    * {{> waitForInvisible }}
    */
   async waitForInvisible(locator, sec) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
     return this.t
       .expect(createSelector(locator).filterVisible().with({ boundTestRun: this.t }).exists)
-      .ok({ timeout: waitTimeout });
+      .ok({ timeout: waitTimeout })
   }
 
   /**
@@ -1205,213 +1196,221 @@ class TestCafe extends Helper {
    *
    */
   async waitForText(text, sec = null, context = null) {
-    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout;
+    const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
 
-    let els;
+    let els
     if (context) {
-      els = (await findElements.call(this, this.context, context));
-      await this.t
-        .expect(els.exists)
-        .ok(`Context element ${context} not found`, { timeout: waitTimeout });
+      els = await findElements.call(this, this.context, context)
+      await this.t.expect(els.exists).ok(`Context element ${context} not found`, { timeout: waitTimeout })
     } else {
-      els = (await findElements.call(this, this.context, '*'));
+      els = await findElements.call(this, this.context, '*')
     }
 
     return this.t
       .expect(els.withText(text).filterVisible().exists)
       .ok(`No element with text "${text}" found in ${context || 'body'}`, { timeout: waitTimeout })
-      .catch(mapError);
+      .catch(mapError)
   }
 }
 
 async function waitForFunction(browserFn, waitTimeout) {
-  const pause = () => new Promise((done => {
-    setTimeout(done, 50);
-  }));
+  const pause = () =>
+    new Promise((done) => {
+      setTimeout(done, 50)
+    })
 
-  const start = Date.now();
+  const start = Date.now()
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    let result;
+    let result
     try {
-      result = await browserFn();
+      result = await browserFn()
       // eslint-disable-next-line no-empty
     } catch (err) {
-      throw new Error(`Error running function ${err.toString()}`);
+      throw new Error(`Error running function ${err.toString()}`)
     }
 
-    if (result) return result;
+    if (result) return result
 
-    const duration = (Date.now() - start);
+    const duration = Date.now() - start
     if (duration > waitTimeout) {
-      throw new Error('waitForFunction timed out');
+      throw new Error('waitForFunction timed out')
     }
-    await pause(); // make polling
+    await pause() // make polling
   }
 }
 
 const createSelector = (locator) => {
-  locator = new Locator(locator, 'css');
-  if (locator.isXPath()) return elementByXPath(locator.value);
-  return Selector(locator.simplify());
-};
+  locator = new Locator(locator, 'css')
+  if (locator.isXPath()) return elementByXPath(locator.value)
+  return Selector(locator.simplify())
+}
 
 const elementByXPath = (xpath) => {
-  assert(xpath, 'xpath is required');
+  assert(xpath, 'xpath is required')
 
-  return Selector(() => {
-    const iterator = document.evaluate(xpath, document, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
-    const items = [];
+  return Selector(
+    () => {
+      const iterator = document.evaluate(xpath, document, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null)
+      const items = []
 
-    let item = iterator.iterateNext();
+      let item = iterator.iterateNext()
 
-    while (item) {
-      items.push(item);
-      item = iterator.iterateNext();
-    }
+      while (item) {
+        items.push(item)
+        item = iterator.iterateNext()
+      }
 
-    return items;
-  }, { dependencies: { xpath } });
-};
+      return items
+    },
+    { dependencies: { xpath } },
+  )
+}
 
 const assertElementExists = async (res, locator, prefix, suffix) => {
   if (!res || !(await res.count) || !(await res.nth(0).tagName)) {
-    throw new ElementNotFound(locator, prefix, suffix);
+    throw new ElementNotFound(locator, prefix, suffix)
   }
-};
+}
 
 async function findElements(matcher, locator) {
-  if (locator && locator.react) throw new Error('react locators are not yet supported');
+  if (locator && locator.react) throw new Error('react locators are not yet supported')
 
-  locator = new Locator(locator, 'css');
+  locator = new Locator(locator, 'css')
 
   if (!locator.isXPath()) {
     return matcher
       ? matcher.find(locator.simplify())
-      : Selector(locator.simplify()).with({ timeout: 0, boundTestRun: this.t });
+      : Selector(locator.simplify()).with({ timeout: 0, boundTestRun: this.t })
   }
 
-  if (!matcher) return elementByXPath(locator.value).with({ timeout: 0, boundTestRun: this.t });
+  if (!matcher) return elementByXPath(locator.value).with({ timeout: 0, boundTestRun: this.t })
 
-  return matcher.find((node, idx, originNode) => {
-    const found = document.evaluate(xpath, originNode, null, 5, null);
-    let current = null;
-    while (current = found.iterateNext()) {
-      if (current === node) return true;
-    }
-    return false;
-  }, { xpath: locator.value });
+  return matcher.find(
+    (node, idx, originNode) => {
+      const found = document.evaluate(xpath, originNode, null, 5, null)
+      let current = null
+      while ((current = found.iterateNext())) {
+        if (current === node) return true
+      }
+      return false
+    },
+    { xpath: locator.value },
+  )
 }
 
 async function proceedClick(locator, context = null) {
-  let matcher;
+  let matcher
 
   if (context) {
-    const els = await this._locate(context);
-    await assertElementExists(els, context);
-    matcher = await els.nth(0);
+    const els = await this._locate(context)
+    await assertElementExists(els, context)
+    matcher = await els.nth(0)
   }
 
-  const els = await findClickable.call(this, matcher, locator);
+  const els = await findClickable.call(this, matcher, locator)
   if (context) {
-    await assertElementExists(els, locator, 'Clickable element', `was not found inside element ${new Locator(context).toString()}`);
+    await assertElementExists(
+      els,
+      locator,
+      'Clickable element',
+      `was not found inside element ${new Locator(context).toString()}`,
+    )
   } else {
-    await assertElementExists(els, locator, 'Clickable element');
+    await assertElementExists(els, locator, 'Clickable element')
   }
 
-  const firstElement = await els.filterVisible().nth(0);
+  const firstElement = await els.filterVisible().nth(0)
 
-  return this.t
-    .click(firstElement)
-    .catch(mapError);
+  return this.t.click(firstElement).catch(mapError)
 }
 
 async function findClickable(matcher, locator) {
-  if (locator && locator.react) throw new Error('react locators are not yet supported');
+  if (locator && locator.react) throw new Error('react locators are not yet supported')
 
-  locator = new Locator(locator);
-  if (!locator.isFuzzy()) return (await findElements.call(this, matcher, locator)).filterVisible();
+  locator = new Locator(locator)
+  if (!locator.isFuzzy()) return (await findElements.call(this, matcher, locator)).filterVisible()
 
-  let els;
+  let els
 
   // try to use native TestCafe locator
-  els = matcher ? matcher.find('a,button') : createSelector('a,button');
-  els = await els.withExactText(locator.value).with({ timeout: 0, boundTestRun: this.t });
-  if (await els.count) return els;
+  els = matcher ? matcher.find('a,button') : createSelector('a,button')
+  els = await els.withExactText(locator.value).with({ timeout: 0, boundTestRun: this.t })
+  if (await els.count) return els
 
-  const literal = xpathLocator.literal(locator.value);
+  const literal = xpathLocator.literal(locator.value)
 
-  els = (await findElements.call(this, matcher, Locator.clickable.narrow(literal))).filterVisible();
-  if (await els.count) return els;
+  els = (await findElements.call(this, matcher, Locator.clickable.narrow(literal))).filterVisible()
+  if (await els.count) return els
 
-  els = (await findElements.call(this, matcher, Locator.clickable.wide(literal))).filterVisible();
-  if (await els.count) return els;
+  els = (await findElements.call(this, matcher, Locator.clickable.wide(literal))).filterVisible()
+  if (await els.count) return els
 
-  els = (await findElements.call(this, matcher, Locator.clickable.self(literal))).filterVisible();
-  if (await els.count) return els;
+  els = (await findElements.call(this, matcher, Locator.clickable.self(literal))).filterVisible()
+  if (await els.count) return els
 
-  return findElements.call(this, matcher, locator.value); // by css or xpath
+  return findElements.call(this, matcher, locator.value) // by css or xpath
 }
 
 async function proceedIsChecked(assertType, option) {
-  const els = await findCheckable.call(this, option);
-  assertElementExists(els, option, 'Checkable');
+  const els = await findCheckable.call(this, option)
+  assertElementExists(els, option, 'Checkable')
 
-  const selected = await els.checked;
+  const selected = await els.checked
 
-  return truth(`checkable ${option}`, 'to be checked')[assertType](selected);
+  return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
 
 async function findCheckable(locator, context) {
-  assert(locator, 'locator is required');
-  assert(this.t, 'this.t is required');
+  assert(locator, 'locator is required')
+  assert(this.t, 'this.t is required')
 
-  let contextEl = await this.context;
+  let contextEl = await this.context
   if (typeof context === 'string') {
-    contextEl = (await findElements.call(this, contextEl, (new Locator(context, 'css')).simplify())).filterVisible();
-    contextEl = await contextEl.nth(0);
+    contextEl = (await findElements.call(this, contextEl, new Locator(context, 'css').simplify())).filterVisible()
+    contextEl = await contextEl.nth(0)
   }
 
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return (await findElements.call(this, contextEl, matchedLocator.simplify())).filterVisible();
+    return (await findElements.call(this, contextEl, matchedLocator.simplify())).filterVisible()
   }
 
-  const literal = xpathLocator.literal(locator);
-  let els = (await findElements.call(this, contextEl, Locator.checkable.byText(literal))).filterVisible();
+  const literal = xpathLocator.literal(locator)
+  let els = (await findElements.call(this, contextEl, Locator.checkable.byText(literal))).filterVisible()
   if (await els.count) {
-    return els;
+    return els
   }
 
-  els = (await findElements.call(this, contextEl, Locator.checkable.byName(literal))).filterVisible();
+  els = (await findElements.call(this, contextEl, Locator.checkable.byName(literal))).filterVisible()
   if (await els.count) {
-    return els;
+    return els
   }
 
-  return (await findElements.call(this, contextEl, locator)).filterVisible();
+  return (await findElements.call(this, contextEl, locator)).filterVisible()
 }
 
 async function findFields(locator) {
-  const matchedLocator = new Locator(locator);
+  const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return this._locate(matchedLocator);
+    return this._locate(matchedLocator)
   }
-  const literal = xpathLocator.literal(locator);
+  const literal = xpathLocator.literal(locator)
 
-  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) });
+  let els = await this._locate({ xpath: Locator.field.labelEquals(literal) })
   if (await els.count) {
-    return els;
+    return els
   }
 
-  els = await this._locate({ xpath: Locator.field.labelContains(literal) });
+  els = await this._locate({ xpath: Locator.field.labelContains(literal) })
   if (await els.count) {
-    return els;
+    return els
   }
-  els = await this._locate({ xpath: Locator.field.byName(literal) });
+  els = await this._locate({ xpath: Locator.field.byName(literal) })
   if (await els.count) {
-    return els;
+    return els
   }
-  return this._locate({ css: locator });
+  return this._locate({ css: locator })
 }
 
-module.exports = TestCafe;
+module.exports = TestCafe
diff --git a/lib/helper/WebDriver.js b/lib/helper/WebDriver.js
index 703f9a2be..9bd253405 100644
--- a/lib/helper/WebDriver.js
+++ b/lib/helper/WebDriver.js
@@ -1,15 +1,15 @@
-let webdriverio;
-
-const assert = require('assert');
-const path = require('path');
-
-const Helper = require('@codeceptjs/helper');
-const promiseRetry = require('promise-retry');
-const stringIncludes = require('../assert/include').includes;
-const { urlEquals, equals } = require('../assert/equal');
-const { debug } = require('../output');
-const { empty } = require('../assert/empty');
-const { truth } = require('../assert/truth');
+let webdriverio
+
+const assert = require('assert')
+const path = require('path')
+
+const Helper = require('@codeceptjs/helper')
+const promiseRetry = require('promise-retry')
+const stringIncludes = require('../assert/include').includes
+const { urlEquals, equals } = require('../assert/equal')
+const { debug } = require('../output')
+const { empty } = require('../assert/empty')
+const { truth } = require('../assert/truth')
 const {
   xpathLocator,
   fileExists,
@@ -19,26 +19,30 @@ const {
   screenshotOutputFolder,
   getNormalizedKeyAttributeValue,
   modifierKeys,
-} = require('../utils');
+} = require('../utils')
+const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
+const ElementNotFound = require('./errors/ElementNotFound')
+const ConnectionRefused = require('./errors/ConnectionRefused')
+const Locator = require('../locator')
+const { highlightElement } = require('./scripts/highlightElement')
+const { focusElement } = require('./scripts/focusElement')
+const { blurElement } = require('./scripts/blurElement')
 const {
-  isColorProperty,
-  convertColorToRGBA,
-} = require('../colorUtils');
-const ElementNotFound = require('./errors/ElementNotFound');
-const ConnectionRefused = require('./errors/ConnectionRefused');
-const Locator = require('../locator');
-const { highlightElement } = require('./scripts/highlightElement');
-const { focusElement } = require('./scripts/focusElement');
-const { blurElement } = require('./scripts/blurElement');
+  dontSeeElementError,
+  seeElementError,
+  seeElementInDOMError,
+  dontSeeElementInDOMError,
+} = require('./errors/ElementAssertion')
 const {
-  dontSeeElementError, seeElementError, seeElementInDOMError, dontSeeElementInDOMError,
-} = require('./errors/ElementAssertion');
-const {
-  dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics,
-} = require('./network/actions');
+  dontSeeTraffic,
+  seeTraffic,
+  grabRecordedNetworkTraffics,
+  stopRecordingTraffic,
+  flushNetworkTraffics,
+} = require('./network/actions')
 
-const SHADOW = 'shadow';
-const webRoot = 'body';
+const SHADOW = 'shadow'
+const webRoot = 'body'
 
 /**
  * ## Configuration
@@ -70,7 +74,7 @@ const webRoot = 'body';
  * @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
@@ -441,34 +445,34 @@ const config = {};
  */
 class WebDriver extends Helper {
   constructor(config) {
-    super(config);
-    webdriverio = require('webdriverio');
+    super(config)
+    webdriverio = require('webdriverio')
 
     // 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) {
@@ -488,41 +492,41 @@ 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
+    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(`
@@ -536,197 +540,201 @@ class WebDriver extends Helper {
               }
             }
           }
-      `);
+      `)
     }
 
-    return config;
+    return config
   }
 
   static _checkRequirements() {
     try {
-      require('webdriverio');
+      require('webdriverio')
     } catch (e) {
-      return ['webdriverio@^6.12.1'];
+      return ['webdriverio@^6.12.1']
     }
   }
 
   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;
+        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';
+          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);
+        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);
-      });
+        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.page = (await this.puppeteerBrowser.pages())[0];
+      this.puppeteerBrowser = await this.browser.getPuppeteer()
+      this.page = (await this.puppeteerBrowser.pages())[0]
     }
 
-    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;
+    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.switchToFrame(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;
+      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+    })
+    await this.closeOtherTabs()
+    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();
+        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;
+        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) => {
         if (!session) {
-          this.activeSessionName = '';
+          this.activeSessionName = ''
         }
-        this.browser = defaultSession;
-        this.$$ = this.browser.$$.bind(this.browser);
+        this.browser = defaultSession
+        this.$$ = this.browser.$$.bind(this.browser)
       },
-    };
+    }
   }
 
   /**
@@ -748,41 +756,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)
   }
 
   /**
@@ -791,7 +799,7 @@ class WebDriver extends Helper {
    * @param {object} locator
    */
   _isShadowLocator(locator) {
-    return locator.type === SHADOW || locator[SHADOW];
+    return locator.type === SHADOW || locator[SHADOW]
   }
 
   /**
@@ -800,35 +808,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
   }
 
   /**
@@ -837,8 +847,11 @@ 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 })
   }
 
   /**
@@ -853,53 +866,53 @@ class WebDriver extends Helper {
    * @param {CodeceptJS.LocatorOrString} locator element located by CSS|XPath|strict locator.
    */
   async _locate(locator, smartWait = false) {
-    if (require('../store').debugMode) smartWait = false;
+    if (require('../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
     }
 
     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
   }
 
   /**
@@ -912,7 +925,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)
   }
 
   /**
@@ -926,8 +939,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)
   }
 
   /**
@@ -940,7 +953,7 @@ 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)
   }
 
   /**
@@ -948,7 +961,7 @@ class WebDriver extends Helper {
    *
    */
   async grabWebElements(locator) {
-    return this._locate(locator);
+    return this._locate(locator)
   }
 
   /**
@@ -964,11 +977,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)
   }
 
   /**
@@ -976,15 +989,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)
   }
 
   /**
@@ -993,18 +1006,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.isW3C ? '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))
   }
 
   /**
@@ -1013,25 +1026,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) => {
       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)
   }
 
   /**
@@ -1040,18 +1053,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()
   }
 
   /**
@@ -1060,24 +1073,24 @@ 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)
   }
 
   /**
@@ -1086,24 +1099,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) => {
       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)
   }
 
   /**
@@ -1113,12 +1126,12 @@ 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)
+    await elem.clearValue()
+    await elem.setValue(value.toString())
   }
 
   /**
@@ -1126,15 +1139,15 @@ 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);
+    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());
+      const curentValue = await elem.getValue()
+      return elem.setValue(curentValue + value.toString())
     }
-    return elem.addValue(value.toString());
+    return elem.addValue(value.toString())
   }
 
   /**
@@ -1142,47 +1155,63 @@ 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);
+    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.setValue('')
     }
-    return elem.clearValue(getElementId(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);
-    };
+      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)
   }
 
   /**
@@ -1191,27 +1220,29 @@ 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) {
       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)
   }
 
   /**
@@ -1219,19 +1250,19 @@ 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.isW3C ? '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 this.browser.isElementSelected(elementId)
+    if (isSelected) return Promise.resolve(true)
+    return this.browser[clickMethod](elementId)
   }
 
   /**
@@ -1239,19 +1270,19 @@ 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.isW3C ? '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 this.browser.isElementSelected(elementId)
+    if (!isSelected) return Promise.resolve(true)
+    return this.browser[clickMethod](elementId)
   }
 
   /**
@@ -1259,10 +1290,10 @@ 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)
+    const val = await forEachAsync(res, (el) => this.browser.getElementText(getElementId(el)))
+    this.debugSection('GrabText', String(val))
+    return val
   }
 
   /**
@@ -1270,13 +1301,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]
   }
 
   /**
@@ -1284,10 +1315,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
   }
 
   /**
@@ -1295,13 +1326,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]
   }
 
   /**
@@ -1309,11 +1340,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
   }
 
   /**
@@ -1321,92 +1352,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
   }
 
   /**
@@ -1415,14 +1446,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)
   }
 
   /**
@@ -1431,7 +1462,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)
   }
 
   /**
@@ -1439,8 +1470,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)
   }
 
   /**
@@ -1448,8 +1479,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)
   }
 
   /**
@@ -1457,7 +1488,7 @@ class WebDriver extends Helper {
    * {{> seeCheckboxIsChecked }}
    */
   async seeCheckboxIsChecked(field) {
-    return proceedSeeCheckbox.call(this, 'assert', field);
+    return proceedSeeCheckbox.call(this, 'assert', field)
   }
 
   /**
@@ -1465,7 +1496,7 @@ class WebDriver extends Helper {
    * {{> dontSeeCheckboxIsChecked }}
    */
   async dontSeeCheckboxIsChecked(field) {
-    return proceedSeeCheckbox.call(this, 'negate', field);
+    return proceedSeeCheckbox.call(this, 'negate', field)
   }
 
   /**
@@ -1474,13 +1505,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)
     }
   }
 
@@ -1489,15 +1520,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)
     }
   }
 
@@ -1506,11 +1537,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)
     }
   }
 
@@ -1519,11 +1550,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)
     }
   }
 
@@ -1532,8 +1563,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)
   }
 
   /**
@@ -1541,7 +1572,7 @@ class WebDriver extends Helper {
    *
    */
   async grabSource() {
-    return this.browser.getPageSource();
+    return this.browser.getPageSource()
   }
 
   /**
@@ -1549,27 +1580,27 @@ class WebDriver extends Helper {
    */
   async grabBrowserLogs() {
     if (this.browser.isW3C) {
-      this.debug('Logs not available in W3C specification');
-      return;
+      this.debug('Logs not available in W3C specification')
+      return
     }
-    return this.browser.getLogs('browser');
+    return this.browser.getLogs('browser')
   }
 
   /**
    * {{> 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)
   }
 
   /**
@@ -1577,8 +1608,12 @@ 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}`,
+    )
   }
 
   /**
@@ -1586,86 +1621,93 @@ 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);
+    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;
+    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));
-    });
+      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);
+    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 true
+    })
     return assert.ok(
       chunked.length === elemAmount,
-      `expected all elements (${(new Locator(locator))}) to have attributes ${JSON.stringify(attributes)}`,
-    );
+      `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
   }
 
   /**
@@ -1673,8 +1715,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))
   }
 
   /**
@@ -1682,8 +1724,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))
   }
 
   /**
@@ -1691,8 +1733,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))
   }
 
   /**
@@ -1700,8 +1742,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))
   }
 
   /**
@@ -1710,7 +1752,7 @@ class WebDriver extends Helper {
    * {{> executeScript }}
    */
   executeScript(...args) {
-    return this.browser.execute.apply(this.browser, args);
+    return this.browser.execute.apply(this.browser, args)
   }
 
   /**
@@ -1718,7 +1760,7 @@ class WebDriver extends Helper {
    *
    */
   executeAsyncScript(...args) {
-    return this.browser.executeAsync.apply(this.browser, args);
+    return this.browser.executeAsync.apply(this.browser, args)
   }
 
   /**
@@ -1726,10 +1768,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)
   }
 
   /**
@@ -1738,28 +1780,40 @@ 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');
+      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);
+      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);
+    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);
+    return this.browser.execute(
+      function (x, y) {
+        return window.scrollTo(x, y)
+      },
+      offsetX,
+      offsetY,
+    )
     /* eslint-enable */
   }
 
@@ -1767,13 +1821,13 @@ class WebDriver extends Helper {
    * {{> 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);
+      debug(e.message)
     }
   }
 
@@ -1782,61 +1836,63 @@ 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) {
-    let 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}`);
+        const activeSessionPage = this.sessionWindows[sessionName]
+        outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`)
 
-        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`);
+        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`)
 
         if (browser) {
-          this.debug(`Screenshot of ${sessionName} session has been saved to ${outputFile}`);
-          return browser.saveScreenshot(outputFile);
+          this.debug(`Screenshot of ${sessionName} session has been saved to ${outputFile}`)
+          return 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}`)
+      return 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);
+    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
+    if (height < 100) height = 500 // errors for very small height
     /* eslint-enable */
 
-    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
   }
 
   /**
@@ -1844,40 +1900,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]
   }
 
   /**
@@ -1885,30 +1941,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 },
+    )
   }
 
   /**
@@ -1919,9 +1978,9 @@ class WebDriver extends Helper {
   async acceptPopup() {
     return this.browser.getAlertText().then((res) => {
       if (res !== null) {
-        return this.browser.acceptAlert();
+        return this.browser.acceptAlert()
       }
-    });
+    })
   }
 
   /**
@@ -1931,9 +1990,9 @@ class WebDriver extends Helper {
   async cancelPopup() {
     return this.browser.getAlertText().then((res) => {
       if (res !== null) {
-        return this.browser.dismissAlert();
+        return this.browser.dismissAlert()
       }
-    });
+    })
   }
 
   /**
@@ -1945,10 +2004,10 @@ class WebDriver extends Helper {
   async seeInPopup(text) {
     return 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)
+    })
   }
 
   /**
@@ -1956,9 +2015,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')
     }
   }
 
@@ -1966,36 +2025,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,
+          },
+        ],
+      },
+    ])
   }
 
   /**
@@ -2004,40 +2071,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)
     }
   }
 
@@ -2046,17 +2118,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)
   }
 
   /**
@@ -2065,27 +2137,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])
     }
   }
 
@@ -2094,11 +2166,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)
   }
 
   /**
@@ -2106,11 +2178,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)
   }
 
   /**
@@ -2118,64 +2190,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()
   }
 
   /**
@@ -2193,125 +2274,140 @@ 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 this.browser.switchToWindow(handle)
+      await this.browser.closeWindow()
+    })
+    await this.browser.switchToWindow(currentHandle)
   }
 
   /**
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise(resolve => {
-      setTimeout(resolve, sec * 1000);
-    });
+    return new Promise((resolve) => {
+      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`,
-    });
+    })
   }
 
   /**
    * {{> 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) => {
         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) => {
+        if (e.message.indexOf('timeout')) {
+          throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
+        }
+        throw e
+      })
   }
 
   /**
@@ -2319,42 +2415,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`,
+      },
+    )
   }
 
   /**
@@ -2362,214 +2464,241 @@ 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;
+    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());
+    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` });
+        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`,
+      },
+    )
   }
 
   /**
    * {{> 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;
+    this.browser.isInsideFrame = true
     if (Number.isInteger(locator)) {
       if (this.options.automationProtocol) {
-        return this.browser.switchToFrame(locator + 1);
+        return this.browser.switchToFrame(locator + 1)
       }
-      return this.browser.switchToFrame(locator);
+      return this.browser.switchToFrame(locator)
     }
     if (!locator) {
-      return this.browser.switchToFrame(null);
+      return this.browser.switchToFrame(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.switchToFrame(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
+    const crypto = require('crypto')
     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;
+    const client = this.browser
     /* eslint-disable prefer-arrow-callback */
     return client.execute(function () {
-      window.scrollTo(0, 0);
-    });
+      window.scrollTo(0, 0)
+    })
     /* eslint-enable */
   }
 
@@ -2577,19 +2706,16 @@ class WebDriver extends Helper {
    * {{> scrollPageToBottom }}
    */
   scrollPageToBottom() {
-    const client = this.browser;
+    const client = this.browser
     /* eslint-disable prefer-arrow-callback, comma-dangle */
     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
-      ));
-    });
+      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 */
   }
 
@@ -2601,11 +2727,11 @@ class WebDriver extends Helper {
     function getScrollPosition() {
       return {
         x: window.pageXOffset,
-        y: window.pageYOffset
-      };
+        y: window.pageYOffset,
+      }
     }
     /* eslint-enable comma-dangle */
-    return this.executeScript(getScrollPosition);
+    return this.executeScript(getScrollPosition)
   }
 
   /**
@@ -2618,15 +2744,15 @@ class WebDriver extends Helper {
     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;
+    * Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration`)
+      return
     }
-    this.geoLocation = { latitude, longitude };
+    this.geoLocation = { latitude, longitude }
 
     await this.browser.call(async () => {
-      const pages = await this.puppeteerBrowser.pages();
-      await pages[0].setGeolocation({ latitude, longitude });
-    });
+      const pages = await this.puppeteerBrowser.pages()
+      await pages[0].setGeolocation({ latitude, longitude })
+    })
   }
 
   /**
@@ -2639,27 +2765,27 @@ class WebDriver extends Helper {
     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;
+    * 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;
+    if (!this.geoLocation) return 'No GeoLocation is set!'
+    return this.geoLocation
   }
 
   /**
    * {{> 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;
+      ...(await el.getLocation()),
+      ...(await el.getSize()),
+    }
+    if (prop) return rect[prop]
+    return rect
   }
 
   /**
@@ -2668,23 +2794,21 @@ class WebDriver extends Helper {
    * @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) {
-  }
+  runOnAndroid(caps, fn) {}
   /* eslint-enable */
 
   /**
    * Placeholder for ~ locator only test case write once run on both Appium and WebDriver.
    */
   runInWeb(fn) {
-    return fn();
+    return fn()
   }
 
   /**
@@ -2695,10 +2819,12 @@ class WebDriver extends Helper {
    */
   flushNetworkTraffics() {
     if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
+      console.log(
+        '* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration',
+      )
+      return
     }
-    this.requests = [];
+    this.requests = []
   }
 
   /**
@@ -2709,11 +2835,13 @@ class WebDriver extends Helper {
    */
   stopRecordingTraffic() {
     if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
+      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;
+    this.page.removeAllListeners('request')
+    this.recording = false
   }
 
   /**
@@ -2725,14 +2853,16 @@ class WebDriver extends Helper {
    */
   async startRecordingTraffic() {
     if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
+      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.flushNetworkTraffics()
+    this.recording = true
+    this.recordedAtLeastOnce = true
 
-    await this.page.setRequestInterception(true);
+    await this.page.setRequestInterception(true)
 
     this.page.on('request', (request) => {
       const information = {
@@ -2741,16 +2871,16 @@ class WebDriver extends Helper {
         requestHeaders: request.headers(),
         requestPostData: request.postData(),
         response: request.response(),
-      };
+      }
 
-      this.debugSection('REQUEST: ', JSON.stringify(information));
+      this.debugSection('REQUEST: ', JSON.stringify(information))
 
       if (typeof information.requestPostData === 'object') {
-        information.requestPostData = JSON.parse(information.requestPostData);
+        information.requestPostData = JSON.parse(information.requestPostData)
       }
-      request.continue();
-      this.requests.push(information);
-    });
+      request.continue()
+      this.requests.push(information)
+    })
   }
 
   /**
@@ -2761,10 +2891,12 @@ class WebDriver extends Helper {
    */
   async grabRecordedNetworkTraffics() {
     if (!this.options.automationProtocol) {
-      console.log('* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration');
-      return;
+      console.log(
+        '* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration',
+      )
+      return
     }
-    return grabRecordedNetworkTraffics.call(this);
+    return grabRecordedNetworkTraffics.call(this)
   }
 
   /**
@@ -2773,14 +2905,14 @@ class WebDriver extends Helper {
    *
    * {{> seeTraffic }}
    */
-  async seeTraffic({
-    name, url, parameters, requestPostData, timeout = 10,
-  }) {
+  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;
+      console.log(
+        '* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration',
+      )
+      return
     }
-    await seeTraffic.call(this, ...arguments);
+    await seeTraffic.call(this, ...arguments)
   }
 
   /**
@@ -2792,38 +2924,40 @@ class WebDriver extends Helper {
    */
   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;
+      console.log(
+        '* Switch to devtools protocol to use this command by setting devtoolsProtocol: true in the configuration',
+      )
+      return
     }
-    dontSeeTraffic.call(this, ...arguments);
+    dontSeeTraffic.call(this, ...arguments)
   }
 }
 
 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);
-  const selected = await forEachAsync(res, async el => this.browser.getElementText(getElementId(el)));
+  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)
 }
 
 /**
@@ -2840,21 +2974,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
 }
 
 /**
@@ -2869,374 +3001,380 @@ 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.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
 
-  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 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.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;
-  return this._locate(locator.value); // by css or xpath
+  els = await this._locate(Locator.field.byName(literal))
+  if (els.length) return els
+  return 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 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 fieldResults = toArray(
+      await forEachAsync(fields, async (el) => {
+        const elementId = getElementId(el)
+        return this.browser.isW3C ? el.getValue() : 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 = el => el.getValue().then((res) => {
-    if (res === null) {
-      throw new Error(`Element ${el.selector} has no value attribute`);
-    }
-    stringIncludes(`fields by ${field}`)[assertType](value, res);
-  });
+  const proceedSingle = (el) =>
+    el.getValue().then((res) => {
+      if (res === null) {
+        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)));
+  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();
+      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()
   if (tag === 'select') {
-    const subOptions = await this.browser.findElementsFromElement(elemId, 'css', 'option');
+    const subOptions = await this.browser.findElementsFromElement(elemId, 'css', '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 => this.browser.isElementSelected(getElementId(el)));
-  return truth(`checkable field "${field}"`, 'to be checked')[assertType](selected);
+  const selected = await forEachAsync(res, async (el) => this.browser.isElementSelected(getElementId(el)))
+  return truth(`checkable field "${field}"`, 'to be checked')[assertType](selected)
 }
 
 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.isFuzzy()) return locateFn(locator, true)
 
-  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;
+  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
 
-  return locateFn(locator.value); // by css or xpath
+  return 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',
+  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 */
-};
+}
 
 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);
+  if (!context) return this._locate.bind(this)
   return (l) => {
-    l = new Locator(l, 'css');
+    l = new Locator(l, 'css')
     return this._locate(context, true).then(async (res) => {
-      assertElementExists(res, context, 'Context element');
+      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())
+    })
+  }
 }
 
-module.exports = WebDriver;
+module.exports = WebDriver
diff --git a/lib/interfaces/bdd.js b/lib/interfaces/bdd.js
index e26c772f9..642cd2591 100644
--- a/lib/interfaces/bdd.js
+++ b/lib/interfaces/bdd.js
@@ -1,86 +1,73 @@
-const { CucumberExpression, ParameterTypeRegistry, ParameterType } = require('@cucumber/cucumber-expressions');
-const Config = require('../config');
+const { CucumberExpression, ParameterTypeRegistry, ParameterType } = require('@cucumber/cucumber-expressions')
+const Config = require('../config')
 
-let steps = {};
+let steps = {}
 
-const STACK_POSITION = 2;
+const STACK_POSITION = 2
 
 /**
  * @param {*} step
  * @param {*} fn
  */
 const addStep = (step, fn) => {
-  const avoidDuplicateSteps = Config.get('gherkin', {}).avoidDuplicateSteps || false;
-  const stack = (new Error()).stack;
+  const avoidDuplicateSteps = Config.get('gherkin', {}).avoidDuplicateSteps || false
+  const stack = new Error().stack
   if (avoidDuplicateSteps && steps[step]) {
-    throw new Error(`Step '${step}' is already defined`);
+    throw new Error(`Step '${step}' is already defined`)
   }
-  steps[step] = fn;
-  fn.line = stack && stack.split('\n')[STACK_POSITION];
+  steps[step] = fn
+  fn.line = stack && stack.split('\n')[STACK_POSITION]
   if (fn.line) {
     fn.line = fn.line
       .trim()
       .replace(/^at (.*?)\(/, '(')
-      .replace(codecept_dir, '.');
+      .replace(codecept_dir, '.')
   }
-};
+}
 
-const parameterTypeRegistry = new ParameterTypeRegistry();
+const parameterTypeRegistry = new ParameterTypeRegistry()
 
 const matchStep = (step) => {
   for (const stepName in steps) {
     if (stepName.indexOf('/') === 0) {
-      const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || [];
-      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]));
+      const regExpArr = stepName.match(/^\/(.*?)\/([gimy]*)$/) || []
+      const res = step.match(new RegExp(regExpArr[1], regExpArr[2]))
       if (res) {
-        const fn = steps[stepName];
-        fn.params = res.slice(1);
-        return fn;
+        const fn = steps[stepName]
+        fn.params = res.slice(1)
+        return fn
       }
-      continue;
+      continue
     }
-    const expression = new CucumberExpression(stepName, parameterTypeRegistry);
-    const res = expression.match(step);
+    const expression = new CucumberExpression(stepName, parameterTypeRegistry)
+    const res = expression.match(step)
     if (res) {
-      const fn = steps[stepName];
-      fn.params = res.map(arg => arg.getValue());
-      return fn;
+      const fn = steps[stepName]
+      fn.params = res.map((arg) => arg.getValue())
+      return fn
     }
   }
-  throw new Error(`No steps matching "${step.toString()}"`);
-};
+  throw new Error(`No steps matching "${step.toString()}"`)
+}
 
 const clearSteps = () => {
-  steps = {};
-};
+  steps = {}
+}
 
 const getSteps = () => {
-  return steps;
-};
+  return steps
+}
 
 const defineParameterType = (options) => {
-  const parameterType = buildParameterType(options);
-  parameterTypeRegistry.defineParameterType(parameterType);
-};
+  const parameterType = buildParameterType(options)
+  parameterTypeRegistry.defineParameterType(parameterType)
+}
 
-const buildParameterType = ({
-  name,
-  regexp,
-  transformer,
-  useForSnippets,
-  preferForRegexpMatch,
-}) => {
-  if (typeof useForSnippets !== 'boolean') useForSnippets = true;
-  if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false;
-  return new ParameterType(
-    name,
-    regexp,
-    null,
-    transformer,
-    useForSnippets,
-    preferForRegexpMatch,
-  );
-};
+const buildParameterType = ({ name, regexp, transformer, useForSnippets, preferForRegexpMatch }) => {
+  if (typeof useForSnippets !== 'boolean') useForSnippets = true
+  if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false
+  return new ParameterType(name, regexp, null, transformer, useForSnippets, preferForRegexpMatch)
+}
 
 module.exports = {
   Given: addStep,
@@ -91,4 +78,4 @@ module.exports = {
   getSteps,
   clearSteps,
   defineParameterType,
-};
+}
diff --git a/lib/interfaces/featureConfig.js b/lib/interfaces/featureConfig.js
index ef301f7f7..ea9853197 100644
--- a/lib/interfaces/featureConfig.js
+++ b/lib/interfaces/featureConfig.js
@@ -1,7 +1,7 @@
 /** @class */
 class FeatureConfig {
   constructor(suite) {
-    this.suite = suite;
+    this.suite = suite
   }
 
   /**
@@ -11,8 +11,8 @@ class FeatureConfig {
    * @returns {this}
    */
   retry(retries) {
-    this.suite.retries(retries);
-    return this;
+    this.suite.retries(retries)
+    return this
   }
 
   /**
@@ -22,11 +22,11 @@ class FeatureConfig {
    * @deprecated
    */
   timeout(timeout) {
-    console.log(`Feature('${this.suite.title}').timeout(${timeout}) is deprecated!`);
-    console.log(`Please use Feature('${this.suite.title}', { timeout: ${timeout / 1000} }) instead`);
-    console.log('Timeout should be set in seconds');
-    this.suite.timeout(timeout);
-    return this;
+    console.log(`Feature('${this.suite.title}').timeout(${timeout}) is deprecated!`)
+    console.log(`Please use Feature('${this.suite.title}', { timeout: ${timeout / 1000} }) instead`)
+    console.log('Timeout should be set in seconds')
+    this.suite.timeout(timeout)
+    return this
   }
 
   /**
@@ -38,17 +38,17 @@ class FeatureConfig {
    */
   config(helper, obj) {
     if (!obj) {
-      obj = helper;
-      helper = 0;
+      obj = helper
+      helper = 0
     }
     if (typeof obj === 'function') {
-      obj = obj(this.suite);
+      obj = obj(this.suite)
     }
     if (!this.suite.config) {
-      this.suite.config = {};
+      this.suite.config = {}
     }
-    this.suite.config[helper] = obj;
-    return this;
+    this.suite.config[helper] = obj
+    return this
   }
 
   /**
@@ -58,12 +58,12 @@ class FeatureConfig {
    */
   tag(tagName) {
     if (tagName[0] !== '@') {
-      tagName = `@${tagName}`;
+      tagName = `@${tagName}`
     }
-    this.suite.tags.push(tagName);
-    this.suite.title = `${this.suite.title.trim()} ${tagName}`;
-    return this;
+    this.suite.tags.push(tagName)
+    this.suite.title = `${this.suite.title.trim()} ${tagName}`
+    return this
   }
 }
 
-module.exports = FeatureConfig;
+module.exports = FeatureConfig
diff --git a/lib/interfaces/gherkin.js b/lib/interfaces/gherkin.js
index f471f5ab6..e8a7a9853 100644
--- a/lib/interfaces/gherkin.js
+++ b/lib/interfaces/gherkin.js
@@ -1,190 +1,201 @@
-const Gherkin = require('@cucumber/gherkin');
-const Messages = require('@cucumber/messages');
-const { Context, Suite, Test } = require('mocha');
-const debug = require('debug')('codeceptjs:bdd');
-
-const { matchStep } = require('./bdd');
-const event = require('../event');
-const scenario = require('../scenario');
-const Step = require('../step');
-const DataTableArgument = require('../data/dataTableArgument');
-const transform = require('../transform');
-
-const uuidFn = Messages.IdGenerator.uuid();
-const builder = new Gherkin.AstBuilder(uuidFn);
-const matcher = new Gherkin.GherkinClassicTokenMatcher();
-const parser = new Gherkin.Parser(builder, matcher);
-parser.stopAtFirstError = false;
+const Gherkin = require('@cucumber/gherkin')
+const Messages = require('@cucumber/messages')
+const { Context, Suite, Test } = require('mocha')
+const debug = require('debug')('codeceptjs:bdd')
+
+const { matchStep } = require('./bdd')
+const event = require('../event')
+const scenario = require('../scenario')
+const Step = require('../step')
+const DataTableArgument = require('../data/dataTableArgument')
+const transform = require('../transform')
+
+const uuidFn = Messages.IdGenerator.uuid()
+const builder = new Gherkin.AstBuilder(uuidFn)
+const matcher = new Gherkin.GherkinClassicTokenMatcher()
+const parser = new Gherkin.Parser(builder, matcher)
+parser.stopAtFirstError = false
 
 module.exports = (text, file) => {
-  const ast = parser.parse(text);
-  let currentLanguage;
+  const ast = parser.parse(text)
+  let currentLanguage
 
   if (ast.feature) {
-    currentLanguage = getTranslation(ast.feature.language);
+    currentLanguage = getTranslation(ast.feature.language)
   }
 
   if (!ast.feature) {
-    throw new Error(`No 'Features' available in Gherkin '${file}' provided!`);
+    throw new Error(`No 'Features' available in Gherkin '${file}' provided!`)
   }
-  const suite = new Suite(ast.feature.name, new Context());
-  const tags = ast.feature.tags.map(t => t.name);
-  suite.title = `${suite.title} ${tags.join(' ')}`.trim();
-  suite.tags = tags || [];
-  suite.comment = ast.feature.description;
-  suite.feature = ast.feature;
-  suite.file = file;
-  suite.timeout(0);
-
-  suite.beforeEach('codeceptjs.before', () => scenario.setup(suite));
-  suite.afterEach('codeceptjs.after', () => scenario.teardown(suite));
-  suite.beforeAll('codeceptjs.beforeSuite', () => scenario.suiteSetup(suite));
-  suite.afterAll('codeceptjs.afterSuite', () => scenario.suiteTeardown(suite));
+  const suite = new Suite(ast.feature.name, new Context())
+  const tags = ast.feature.tags.map((t) => t.name)
+  suite.title = `${suite.title} ${tags.join(' ')}`.trim()
+  suite.tags = tags || []
+  suite.comment = ast.feature.description
+  suite.feature = ast.feature
+  suite.file = file
+  suite.timeout(0)
+
+  suite.beforeEach('codeceptjs.before', () => scenario.setup(suite))
+  suite.afterEach('codeceptjs.after', () => scenario.teardown(suite))
+  suite.beforeAll('codeceptjs.beforeSuite', () => scenario.suiteSetup(suite))
+  suite.afterAll('codeceptjs.afterSuite', () => scenario.suiteTeardown(suite))
 
   const runSteps = async (steps) => {
     for (const step of steps) {
-      const metaStep = new Step.MetaStep(null, step.text);
-      metaStep.actor = step.keyword.trim();
-      let helperStep;
+      const metaStep = new Step.MetaStep(null, step.text)
+      metaStep.actor = step.keyword.trim()
+      let helperStep
       const setMetaStep = (step) => {
-        helperStep = step;
+        helperStep = step
         if (step.metaStep) {
           if (step.metaStep === metaStep) {
-            return;
+            return
           }
-          setMetaStep(step.metaStep);
-          return;
+          setMetaStep(step.metaStep)
+          return
         }
-        step.metaStep = metaStep;
-      };
-      const fn = matchStep(step.text);
+        step.metaStep = metaStep
+      }
+      const fn = matchStep(step.text)
 
       if (step.dataTable) {
         fn.params.push({
           ...step.dataTable,
           parse: () => new DataTableArgument(step.dataTable),
-        });
-        metaStep.comment = `\n${transformTable(step.dataTable)}`;
+        })
+        metaStep.comment = `\n${transformTable(step.dataTable)}`
       }
 
       if (step.docString) {
-        fn.params.push(step.docString);
-        metaStep.comment = `\n"""\n${step.docString.content}\n"""`;
+        fn.params.push(step.docString)
+        metaStep.comment = `\n"""\n${step.docString.content}\n"""`
       }
 
-      step.startTime = Date.now();
-      step.match = fn.line;
-      event.emit(event.bddStep.before, step);
-      event.emit(event.bddStep.started, metaStep);
-      event.dispatcher.prependListener(event.step.before, setMetaStep);
+      step.startTime = Date.now()
+      step.match = fn.line
+      event.emit(event.bddStep.before, step)
+      event.emit(event.bddStep.started, metaStep)
+      event.dispatcher.prependListener(event.step.before, setMetaStep)
       try {
-        debug(`Step '${step.text}' started...`);
-        await fn(...fn.params);
-        debug('Step passed');
-        step.status = 'passed';
+        debug(`Step '${step.text}' started...`)
+        await fn(...fn.params)
+        debug('Step passed')
+        step.status = 'passed'
       } catch (err) {
-        debug(`Step failed: ${err?.message}`);
-        step.status = 'failed';
-        step.err = err;
-        throw err;
+        debug(`Step failed: ${err?.message}`)
+        step.status = 'failed'
+        step.err = err
+        throw err
       } finally {
-        step.endTime = Date.now();
-        event.dispatcher.removeListener(event.step.before, setMetaStep);
+        step.endTime = Date.now()
+        event.dispatcher.removeListener(event.step.before, setMetaStep)
       }
-      event.emit(event.bddStep.finished, metaStep);
-      event.emit(event.bddStep.after, step);
+      event.emit(event.bddStep.finished, metaStep)
+      event.emit(event.bddStep.after, step)
     }
-  };
+  }
 
   for (const child of ast.feature.children) {
     if (child.background) {
-      suite.beforeEach('Before', scenario.injected(async () => runSteps(child.background.steps), suite, 'before'));
-      continue;
+      suite.beforeEach(
+        'Before',
+        scenario.injected(async () => runSteps(child.background.steps), suite, 'before'),
+      )
+      continue
     }
-    if (child.scenario && (currentLanguage ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline : child.scenario.keyword === 'Scenario Outline')) {
+    if (
+      child.scenario &&
+      (currentLanguage
+        ? child.scenario.keyword === currentLanguage.contexts.ScenarioOutline
+        : child.scenario.keyword === 'Scenario Outline')
+    ) {
       for (const examples of child.scenario.examples) {
-        const fields = examples.tableHeader.cells.map(c => c.value);
+        const fields = examples.tableHeader.cells.map((c) => c.value)
         for (const example of examples.tableBody) {
-          let exampleSteps = [...child.scenario.steps];
-          const current = {};
+          let exampleSteps = [...child.scenario.steps]
+          const current = {}
           for (const index in example.cells) {
-            const placeholder = fields[index];
-            const value = transform('gherkin.examples', example.cells[index].value);
-            example.cells[index].value = value;
-            current[placeholder] = value;
+            const placeholder = fields[index]
+            const value = transform('gherkin.examples', example.cells[index].value)
+            example.cells[index].value = value
+            current[placeholder] = value
             exampleSteps = exampleSteps.map((step) => {
-              step = { ...step };
-              step.text = step.text.split(`<${placeholder}>`).join(value);
-              return step;
-            });
+              step = { ...step }
+              step.text = step.text.split(`<${placeholder}>`).join(value)
+              return step
+            })
           }
-          const tags = child.scenario.tags.map(t => t.name).concat(examples.tags.map(t => t.name));
-          let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim();
+          const tags = child.scenario.tags.map((t) => t.name).concat(examples.tags.map((t) => t.name))
+          let title = `${child.scenario.name} ${JSON.stringify(current)} ${tags.join(' ')}`.trim()
 
           for (const [key, value] of Object.entries(current)) {
             if (title.includes(`<${key}>`)) {
-              title = title.replace(JSON.stringify(current), '').replace(`<${key}>`, value);
+              title = title.replace(JSON.stringify(current), '').replace(`<${key}>`, value)
             }
           }
 
-          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)));
-          test.tags = suite.tags.concat(tags);
-          test.file = file;
-          suite.addTest(scenario.test(test));
+          const test = new Test(title, async () => runSteps(addExampleInTable(exampleSteps, current)))
+          test.tags = suite.tags.concat(tags)
+          test.file = file
+          suite.addTest(scenario.test(test))
         }
       }
-      continue;
+      continue
     }
 
     if (child.scenario) {
-      const tags = child.scenario.tags.map(t => t.name);
-      const title = `${child.scenario.name} ${tags.join(' ')}`.trim();
-      const test = new Test(title, async () => runSteps(child.scenario.steps));
-      test.tags = suite.tags.concat(tags);
-      test.file = file;
-      suite.addTest(scenario.test(test));
+      const tags = child.scenario.tags.map((t) => t.name)
+      const title = `${child.scenario.name} ${tags.join(' ')}`.trim()
+      const test = new Test(title, async () => runSteps(child.scenario.steps))
+      test.tags = suite.tags.concat(tags)
+      test.file = file
+      suite.addTest(scenario.test(test))
     }
   }
 
-  return suite;
-};
+  return suite
+}
 
 function transformTable(table) {
-  let str = '';
+  let str = ''
   for (const id in table.rows) {
-    const cells = table.rows[id].cells;
-    str += cells.map(c => c.value).map(c => c.padEnd(15)).join(' | ');
-    str += '\n';
+    const cells = table.rows[id].cells
+    str += cells
+      .map((c) => c.value)
+      .map((c) => c.padEnd(15))
+      .join(' | ')
+    str += '\n'
   }
-  return str;
+  return str
 }
 function addExampleInTable(exampleSteps, placeholders) {
-  const steps = JSON.parse(JSON.stringify(exampleSteps));
+  const steps = JSON.parse(JSON.stringify(exampleSteps))
   for (const placeholder in placeholders) {
     steps.map((step) => {
-      step = { ...step };
+      step = { ...step }
       if (step.dataTable) {
         for (const id in step.dataTable.rows) {
-          const cells = step.dataTable.rows[id].cells;
-          cells.map(c => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])));
+          const cells = step.dataTable.rows[id].cells
+          cells.map((c) => (c.value = c.value.replace(`<${placeholder}>`, placeholders[placeholder])))
         }
       }
-      return step;
-    });
+      return step
+    })
   }
-  return steps;
+  return steps
 }
 
 function getTranslation(language) {
-  const translations = Object.keys(require('../../translations'));
+  const translations = Object.keys(require('../../translations'))
 
   for (const availableTranslation of translations) {
     if (!language) {
-      break;
+      break
     }
 
     if (availableTranslation.includes(language)) {
-      return require('../../translations')[availableTranslation];
+      return require('../../translations')[availableTranslation]
     }
   }
 }
diff --git a/lib/interfaces/scenarioConfig.js b/lib/interfaces/scenarioConfig.js
index cf9910f18..4331fb0e6 100644
--- a/lib/interfaces/scenarioConfig.js
+++ b/lib/interfaces/scenarioConfig.js
@@ -1,7 +1,7 @@
 /** @class */
 class ScenarioConfig {
   constructor(test) {
-    this.test = test;
+    this.test = test
   }
 
   /**
@@ -12,8 +12,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   throws(err) {
-    this.test.throws = err;
-    return this;
+    this.test.throws = err
+    return this
   }
 
   /**
@@ -24,8 +24,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   fails() {
-    this.test.throws = new Error();
-    return this;
+    this.test.throws = new Error()
+    return this
   }
 
   /**
@@ -35,9 +35,9 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries;
-    this.test.retries(retries);
-    return this;
+    if (process.env.SCENARIO_ONLY) retries = -retries
+    this.test.retries(retries)
+    return this
   }
 
   /**
@@ -46,12 +46,12 @@ class ScenarioConfig {
    * @returns {this}
    */
   timeout(timeout) {
-    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`);
-    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`);
-    console.log('Timeout should be set in seconds');
+    console.log(`Scenario('${this.test.title}', () => {}).timeout(${timeout}) is deprecated!`)
+    console.log(`Please use Scenario('${this.test.title}', { timeout: ${timeout / 1000} }, () => {}) instead`)
+    console.log('Timeout should be set in seconds')
 
-    this.test.timeout(timeout);
-    return this;
+    this.test.timeout(timeout)
+    return this
   }
 
   /**
@@ -60,8 +60,8 @@ class ScenarioConfig {
    * @returns {this}
    */
   inject(obj) {
-    this.test.inject = obj;
-    return this;
+    this.test.inject = obj
+    return this
   }
 
   /**
@@ -73,17 +73,17 @@ class ScenarioConfig {
    */
   async config(helper, obj) {
     if (!obj) {
-      obj = helper;
-      helper = 0;
+      obj = helper
+      helper = 0
     }
     if (typeof obj === 'function') {
-      obj = await obj(this.test);
+      obj = await obj(this.test)
     }
     if (!this.test.config) {
-      this.test.config = {};
+      this.test.config = {}
     }
-    this.test.config[helper] = obj;
-    return this;
+    this.test.config[helper] = obj
+    return this
   }
 
   /**
@@ -92,10 +92,10 @@ class ScenarioConfig {
    * @returns {this}
    */
   tag(tagName) {
-    if (tagName[0] !== '@') tagName = `@${tagName}`;
-    this.test.tags.push(tagName);
-    this.test.title = `${this.test.title.trim()} ${tagName}`;
-    return this;
+    if (tagName[0] !== '@') tagName = `@${tagName}`
+    this.test.tags.push(tagName)
+    this.test.title = `${this.test.title.trim()} ${tagName}`
+    return this
   }
 
   /**
@@ -105,10 +105,10 @@ class ScenarioConfig {
    */
   injectDependencies(dependencies) {
     Object.keys(dependencies).forEach((key) => {
-      this.test.inject[key] = dependencies[key];
-    });
-    return this;
+      this.test.inject[key] = dependencies[key]
+    })
+    return this
   }
 }
 
-module.exports = ScenarioConfig;
+module.exports = ScenarioConfig
diff --git a/lib/listener/artifacts.js b/lib/listener/artifacts.js
index 17a09e399..8e22799ff 100644
--- a/lib/listener/artifacts.js
+++ b/lib/listener/artifacts.js
@@ -1,19 +1,19 @@
-const event = require('../event');
-const recorder = require('../recorder');
+const event = require('../event')
+const recorder = require('../recorder')
 
 /**
  * Create and clean up empty artifacts
  */
 module.exports = function () {
   event.dispatcher.on(event.test.before, (test) => {
-    test.artifacts = {};
-  });
+    test.artifacts = {}
+  })
 
   event.dispatcher.on(event.test.after, (test) => {
     recorder.add('clean up empty artifacts', () => {
-      for (const key in (test.artifacts || {})) {
-        if (!test.artifacts[key]) delete test.artifacts[key];
+      for (const key in test.artifacts || {}) {
+        if (!test.artifacts[key]) delete test.artifacts[key]
       }
-    });
-  });
-};
+    })
+  })
+}
diff --git a/lib/listener/config.js b/lib/listener/config.js
index ec114e12a..738262104 100644
--- a/lib/listener/config.js
+++ b/lib/listener/config.js
@@ -1,45 +1,46 @@
-const event = require('../event');
-const container = require('../container');
-const recorder = require('../recorder');
-const { deepMerge, deepClone, ucfirst } = require('../utils');
-const { debug } = require('../output');
+const event = require('../event')
+const container = require('../container')
+const recorder = require('../recorder')
+const { deepMerge, deepClone, ucfirst } = require('../utils')
+const { debug } = require('../output')
 /**
  * Enable Helpers to listen to test events
  */
 module.exports = function () {
-  const helpers = container.helpers();
+  const helpers = container.helpers()
 
-  enableDynamicConfigFor('suite');
-  enableDynamicConfigFor('test');
+  enableDynamicConfigFor('suite')
+  enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
       function updateHelperConfig(helper, config) {
-        const oldConfig = { ...helper.options };
+        const oldConfig = { ...helper.options }
         try {
-          helper._setConfig(deepMerge(deepClone(oldConfig), config));
-          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`);
+          helper._setConfig(deepMerge(deepClone(oldConfig), config))
+          debug(`[${ucfirst(type)} Config] ${helper.constructor.name} ${JSON.stringify(config)}`)
         } catch (err) {
-          recorder.throw(err);
-          return;
+          recorder.throw(err)
+          return
         }
         event.dispatcher.once(event[type].after, () => {
-          helper._setConfig(oldConfig);
-          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`);
-        });
+          helper._setConfig(oldConfig)
+          debug(`[${ucfirst(type)} Config] Reverted for ${helper.constructor.name}`)
+        })
       }
 
       // change config
       if (context.config) {
         for (let name in context.config) {
-          const config = context.config[name];
-          if (name === '0') { // first helper
-            name = Object.keys(helpers)[0];
+          const config = context.config[name]
+          if (name === '0') {
+            // first helper
+            name = Object.keys(helpers)[0]
           }
-          const helper = helpers[name];
-          updateHelperConfig(helper, config);
+          const helper = helpers[name]
+          updateHelperConfig(helper, config)
         }
       }
-    });
+    })
   }
-};
+}
diff --git a/lib/listener/exit.js b/lib/listener/exit.js
index 7ccc0e171..801f9c4d0 100644
--- a/lib/listener/exit.js
+++ b/lib/listener/exit.js
@@ -1,30 +1,30 @@
-const event = require('../event');
+const event = require('../event')
 
 module.exports = function () {
-  let failedTests = [];
+  let failedTests = []
 
   event.dispatcher.on(event.test.failed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
-    failedTests.push(id);
-  });
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+    failedTests.push(id)
+  })
 
   // if test was successful after retries
   event.dispatcher.on(event.test.passed, (testOrSuite) => {
     // NOTE When an error happens in one of the hooks (BeforeAll/BeforeEach...) the event object
     // is a suite and not a test
-    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty';
-    failedTests = failedTests.filter(failed => id !== failed);
-  });
+    const id = testOrSuite.uid || (testOrSuite.ctx && testOrSuite.ctx.test.uid) || 'empty'
+    failedTests = failedTests.filter((failed) => id !== failed)
+  })
 
   process.on('beforeExit', (code) => {
     if (failedTests.length) {
-      code = 1;
+      code = 1
     }
 
     if (code) {
-      process.exit(code);
+      process.exit(code)
     }
-  });
-};
+  })
+}
diff --git a/lib/listener/helpers.js b/lib/listener/helpers.js
index 6776e8680..5bb55a3a7 100644
--- a/lib/listener/helpers.js
+++ b/lib/listener/helpers.js
@@ -1,79 +1,79 @@
-const path = require('path');
-const event = require('../event');
-const container = require('../container');
-const recorder = require('../recorder');
-const store = require('../store');
-const { error } = require('../output');
+const path = require('path')
+const event = require('../event')
+const container = require('../container')
+const recorder = require('../recorder')
+const store = require('../store')
+const { error } = require('../output')
 /**
  * Enable Helpers to listen to test events
  */
 module.exports = function () {
-  const helpers = container.helpers();
+  const helpers = container.helpers()
 
   const runHelpersHook = (hook, param) => {
-    if (store.dryRun) return;
+    if (store.dryRun) return
     Object.values(helpers).forEach((helper) => {
       if (helper[hook]) {
-        helper[hook](param);
+        helper[hook](param)
       }
-    });
-  };
+    })
+  }
 
   const runAsyncHelpersHook = (hook, param, force) => {
-    if (store.dryRun) return;
+    if (store.dryRun) return
     Object.keys(helpers).forEach((key) => {
-      if (!helpers[key][hook]) return;
-      recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false);
-    });
-  };
+      if (!helpers[key][hook]) return
+      recorder.add(`hook ${key}.${hook}()`, () => helpers[key][hook](param), force, false)
+    })
+  }
 
   event.dispatcher.on(event.suite.before, (suite) => {
     // if (suite.parent) return; // only for root suite
-    runAsyncHelpersHook('_beforeSuite', suite, true);
-  });
+    runAsyncHelpersHook('_beforeSuite', suite, true)
+  })
 
   event.dispatcher.on(event.suite.after, (suite) => {
     // if (suite.parent) return; // only for root suite
-    runAsyncHelpersHook('_afterSuite', suite, true);
-  });
+    runAsyncHelpersHook('_afterSuite', suite, true)
+  })
 
   event.dispatcher.on(event.test.started, (test) => {
-    runHelpersHook('_test', test);
-    recorder.catch(e => error(e));
-  });
+    runHelpersHook('_test', test)
+    recorder.catch((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
     // schedule config to revert changes
-    runAsyncHelpersHook('_before', test, true);
-    recorder.catchWithoutStop(e => error(e));
-  });
+    runAsyncHelpersHook('_before', test, true)
+    recorder.catchWithoutStop((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.passed, (test) => {
-    runAsyncHelpersHook('_passed', test, true);
+    runAsyncHelpersHook('_passed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => error(e));
-  });
+    recorder.catchWithoutStop((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.failed, (test) => {
-    runAsyncHelpersHook('_failed', test, true);
+    runAsyncHelpersHook('_failed', test, true)
     // should not fail test execution, so errors should be caught
-    recorder.catchWithoutStop(e => error(e));
-  });
+    recorder.catchWithoutStop((e) => error(e))
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    runAsyncHelpersHook('_after', {}, true);
-    recorder.catchWithoutStop(e => error(e));
-  });
+    runAsyncHelpersHook('_after', {}, true)
+    recorder.catchWithoutStop((e) => error(e))
+  })
 
   event.dispatcher.on(event.step.before, (step) => {
-    runAsyncHelpersHook('_beforeStep', step);
-  });
+    runAsyncHelpersHook('_beforeStep', step)
+  })
 
   event.dispatcher.on(event.step.after, (step) => {
-    runAsyncHelpersHook('_afterStep', step);
-  });
+    runAsyncHelpersHook('_afterStep', step)
+  })
 
   event.dispatcher.on(event.all.result, () => {
-    runAsyncHelpersHook('_finishTest', {}, true);
-  });
-};
+    runAsyncHelpersHook('_finishTest', {}, true)
+  })
+}
diff --git a/lib/listener/mocha.js b/lib/listener/mocha.js
index 503ae75da..b7fd1fa8d 100644
--- a/lib/listener/mocha.js
+++ b/lib/listener/mocha.js
@@ -1,19 +1,19 @@
-const event = require('../event');
-const container = require('../container');
+const event = require('../event')
+const container = require('../container')
 
 module.exports = function () {
-  let mocha;
+  let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = container.mocha();
-  });
+    mocha = container.mocha()
+  })
 
   event.dispatcher.on(event.test.passed, (test) => {
-    mocha.Runner.emit('pass', test);
-  });
+    mocha.Runner.emit('pass', test)
+  })
 
   event.dispatcher.on(event.test.failed, (test, err) => {
-    test.state = 'failed';
-    mocha.Runner.emit('fail', test, err);
-  });
-};
+    test.state = 'failed'
+    mocha.Runner.emit('fail', test, err)
+  })
+}
diff --git a/lib/listener/retry.js b/lib/listener/retry.js
index 1b165c769..1664fc6ef 100644
--- a/lib/listener/retry.js
+++ b/lib/listener/retry.js
@@ -1,68 +1,70 @@
-const event = require('../event');
-const output = require('../output');
-const Config = require('../config');
-const { isNotSet } = require('../utils');
+const event = require('../event')
+const output = require('../output')
+const Config = require('../config')
+const { isNotSet } = require('../utils')
 
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite'];
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
 module.exports = function () {
   event.dispatcher.on(event.suite.before, (suite) => {
-    let retryConfig = Config.get('retry');
-    if (!retryConfig) return;
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
       // is number
-      const retryNum = +retryConfig;
-      output.log(`Retries: ${retryNum}`);
-      suite.retries(retryNum);
-      return;
+      const retryNum = +retryConfig
+      output.log(`Retries: ${retryNum}`)
+      suite.retries(retryNum)
+      return
     }
 
     if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig];
+      retryConfig = [retryConfig]
     }
 
     for (const config of retryConfig) {
       if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue;
+        if (!suite.title.includes(config.grep)) continue
       }
 
-      hooks.filter(hook => !!config[hook]).forEach((hook) => {
-        if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook];
-      });
+      hooks
+        .filter((hook) => !!config[hook])
+        .forEach((hook) => {
+          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
+        })
 
       if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature);
+        if (isNotSet(suite.retries())) suite.retries(config.Feature)
       }
 
-      output.log(`Retries: ${JSON.stringify(config)}`);
+      output.log(`Retries: ${JSON.stringify(config)}`)
     }
-  });
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
-    let retryConfig = Config.get('retry');
-    if (!retryConfig) return;
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig);
-      return;
+      if (test.retries() === -1) test.retries(retryConfig)
+      return
     }
 
     if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig];
+      retryConfig = [retryConfig]
     }
 
-    retryConfig = retryConfig.filter(config => !!config.Scenario);
+    retryConfig = retryConfig.filter((config) => !!config.Scenario)
 
     for (const config of retryConfig) {
       if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue;
+        if (!test.fullTitle().includes(config.grep)) continue
       }
 
       if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario);
-        output.log(`Retries: ${config.Scenario}`);
+        if (test.retries() === -1) test.retries(config.Scenario)
+        output.log(`Retries: ${config.Scenario}`)
       }
     }
-  });
-};
+  })
+}
diff --git a/lib/listener/steps.js b/lib/listener/steps.js
index e73ec80de..ef5443a07 100644
--- a/lib/listener/steps.js
+++ b/lib/listener/steps.js
@@ -1,84 +1,83 @@
-const debug = require('debug')('codeceptjs:steps');
-const event = require('../event');
-const store = require('../store');
-const output = require('../output');
+const debug = require('debug')('codeceptjs:steps')
+const event = require('../event')
+const store = require('../store')
+const output = require('../output')
 
-let currentTest;
-let currentHook;
+let currentTest
+let currentHook
 
 /**
  * Register steps inside tests
  */
 module.exports = function () {
   event.dispatcher.on(event.test.before, (test) => {
-    test.startedAt = +new Date();
-    test.artifacts = {};
-  });
+    test.startedAt = +new Date()
+    test.artifacts = {}
+  })
 
   event.dispatcher.on(event.test.started, (test) => {
-    currentTest = test;
-    currentTest.steps = [];
-    if (!('retryNum' in currentTest)) currentTest.retryNum = 0;
-    else currentTest.retryNum += 1;
-  });
+    currentTest = test
+    currentTest.steps = []
+    if (!('retryNum' in currentTest)) currentTest.retryNum = 0
+    else currentTest.retryNum += 1
+  })
 
   event.dispatcher.on(event.test.after, (test) => {
-    currentTest = null;
-  });
+    currentTest = null
+  })
 
-  event.dispatcher.on(event.test.finished, (test) => {
-  });
+  event.dispatcher.on(event.test.finished, (test) => {})
 
   event.dispatcher.on(event.hook.started, (suite) => {
-    currentHook = suite.ctx.test;
-    currentHook.steps = [];
+    currentHook = suite.ctx.test
+    currentHook.steps = []
 
-    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`);
-  });
+    if (suite.ctx && suite.ctx.test) output.log(`--- STARTED ${suite.ctx.test.title} ---`)
+  })
 
   event.dispatcher.on(event.hook.passed, (suite) => {
-    currentHook = null;
-    if (suite.ctx && suite.ctx.test) output.log(`--- ENDED ${suite.ctx.test.title} ---`);
-  });
+    currentHook = null
+    if (suite.ctx && suite.ctx.test) output.log(`--- ENDED ${suite.ctx.test.title} ---`)
+  })
 
   event.dispatcher.on(event.test.failed, () => {
     const cutSteps = function (current) {
-      const failureIndex = current.steps.findIndex(el => el.status === 'failed');
+      const failureIndex = current.steps.findIndex((el) => el.status === 'failed')
       // To be sure that failed test will be failed in report
-      current.state = 'failed';
-      current.steps.length = failureIndex + 1;
-      return current;
-    };
+      current.state = 'failed'
+      current.steps.length = failureIndex + 1
+      return current
+    }
     if (currentHook && Array.isArray(currentHook.steps) && currentHook.steps.length) {
-      currentHook = cutSteps(currentHook);
-      return currentHook = null;
+      currentHook = cutSteps(currentHook)
+      return (currentHook = null)
     }
-    if (!currentTest) return;
+    if (!currentTest) return
     // last step is failing step
-    if (!currentTest.steps.length) return;
-    return currentTest = cutSteps(currentTest);
-  });
+    if (!currentTest.steps.length) return
+    return (currentTest = cutSteps(currentTest))
+  })
 
   event.dispatcher.on(event.test.passed, () => {
-    if (!currentTest) return;
+    if (!currentTest) return
     // To be sure that passed test will be passed in report
-    delete currentTest.err;
-    currentTest.state = 'passed';
-  });
+    delete currentTest.err
+    currentTest.state = 'passed'
+  })
 
   event.dispatcher.on(event.step.started, (step) => {
-    step.startedAt = +new Date();
-    step.test = currentTest;
+    step.startedAt = +new Date()
+    step.test = currentTest
     if (currentHook && Array.isArray(currentHook.steps)) {
-      return currentHook.steps.push(step);
+      return currentHook.steps.push(step)
     }
-    if (!currentTest || !currentTest.steps) return;
-    currentTest.steps.push(step);
-  });
+    if (!currentTest || !currentTest.steps) return
+    currentTest.steps.push(step)
+  })
 
   event.dispatcher.on(event.step.finished, (step) => {
-    step.finishedAt = +new Date();
-    if (step.startedAt) step.duration = step.finishedAt - step.startedAt;
-    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`);
-  });
-};
+    step.finishedAt = +new Date()
+    if (step.startedAt) step.duration = step.finishedAt - step.startedAt
+    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`)
+  })
+}
diff --git a/lib/listener/timeout.js b/lib/listener/timeout.js
index 3b3a3d1c4..4d554f960 100644
--- a/lib/listener/timeout.js
+++ b/lib/listener/timeout.js
@@ -1,109 +1,109 @@
-const event = require('../event');
-const output = require('../output');
-const recorder = require('../recorder');
-const Config = require('../config');
-const { timeouts } = require('../store');
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER;
+const event = require('../event')
+const output = require('../output')
+const recorder = require('../recorder')
+const Config = require('../config')
+const { timeouts } = require('../store')
+const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
 
 module.exports = function () {
-  let timeout;
-  let suiteTimeout = [];
-  let currentTest;
-  let currentTimeout;
+  let timeout
+  let suiteTimeout = []
+  let currentTest
+  let currentTimeout
 
   if (!timeouts) {
-    console.log('Timeouts were disabled');
-    return;
+    console.log('Timeouts were disabled')
+    return
   }
 
   event.dispatcher.on(event.suite.before, (suite) => {
-    suiteTimeout = [];
-    let timeoutConfig = Config.get('timeout');
+    suiteTimeout = []
+    let timeoutConfig = Config.get('timeout')
 
     if (timeoutConfig) {
       if (!Number.isNaN(+timeoutConfig)) {
-        checkForSeconds(timeoutConfig);
-        suiteTimeout.push(timeoutConfig);
+        checkForSeconds(timeoutConfig)
+        suiteTimeout.push(timeoutConfig)
       }
 
       if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig];
+        timeoutConfig = [timeoutConfig]
       }
 
-      for (const config of timeoutConfig.filter(c => !!c.Feature)) {
+      for (const config of timeoutConfig.filter((c) => !!c.Feature)) {
         if (config.grep) {
-          if (!suite.title.includes(config.grep)) continue;
+          if (!suite.title.includes(config.grep)) continue
         }
-        suiteTimeout.push(config.Feature);
+        suiteTimeout.push(config.Feature)
       }
     }
 
-    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout);
-    output.log(`Timeouts: ${suiteTimeout}`);
-  });
+    if (suite.totalTimeout) suiteTimeout.push(suite.totalTimeout)
+    output.log(`Timeouts: ${suiteTimeout}`)
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test;
-    let testTimeout = null;
+    currentTest = test
+    let testTimeout = null
 
-    let timeoutConfig = Config.get('timeout');
+    let timeoutConfig = Config.get('timeout')
 
     if (typeof timeoutConfig === 'object' || Array.isArray(timeoutConfig)) {
       if (!Array.isArray(timeoutConfig)) {
-        timeoutConfig = [timeoutConfig];
+        timeoutConfig = [timeoutConfig]
       }
 
-      for (const config of timeoutConfig.filter(c => !!c.Scenario)) {
-        console.log('Test Timeout', config, test.title.includes(config.grep));
+      for (const config of timeoutConfig.filter((c) => !!c.Scenario)) {
+        console.log('Test Timeout', config, test.title.includes(config.grep))
         if (config.grep) {
-          if (!test.title.includes(config.grep)) continue;
+          if (!test.title.includes(config.grep)) continue
         }
-        testTimeout = config.Scenario;
+        testTimeout = config.Scenario
       }
     }
 
-    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1];
-    if (!timeout) return;
-    currentTimeout = timeout;
-    output.debug(`Test Timeout: ${timeout}s`);
-    timeout *= 1000;
-  });
+    timeout = test.totalTimeout || testTimeout || suiteTimeout[suiteTimeout.length - 1]
+    if (!timeout) return
+    currentTimeout = timeout
+    output.debug(`Test Timeout: ${timeout}s`)
+    timeout *= 1000
+  })
 
   event.dispatcher.on(event.test.passed, (test) => {
-    currentTest = null;
-  });
+    currentTest = null
+  })
 
   event.dispatcher.on(event.test.failed, (test) => {
-    currentTest = null;
-  });
+    currentTest = null
+  })
 
   event.dispatcher.on(event.step.before, (step) => {
-    if (typeof timeout !== 'number') return;
+    if (typeof timeout !== 'number') return
 
     if (timeout < 0) {
-      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite);
+      step.setTimeout(0.01, TIMEOUT_ORDER.testOrSuite)
     } else {
-      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite);
+      step.setTimeout(timeout, TIMEOUT_ORDER.testOrSuite)
     }
-  });
+  })
 
   event.dispatcher.on(event.step.finished, (step) => {
-    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration;
+    if (typeof timeout === 'number' && !Number.isNaN(timeout)) timeout -= step.duration
 
     if (typeof timeout === 'number' && timeout <= 0 && recorder.isRunning()) {
       if (currentTest && currentTest.callback) {
-        recorder.reset();
+        recorder.reset()
         // replace mocha timeout with custom timeout
-        currentTest.timeout(0);
-        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`));
-        currentTest.timedOut = true;
+        currentTest.timeout(0)
+        currentTest.callback(new Error(`Timeout ${currentTimeout}s exceeded (with Before hook)`))
+        currentTest.timedOut = true
       }
     }
-  });
-};
+  })
+}
 
 function checkForSeconds(timeout) {
   if (timeout >= 1000) {
-    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`);
+    console.log(`Warning: Timeout was set to ${timeout}secs.\nGlobal timeout should be specified in seconds.`)
   }
 }
diff --git a/lib/locator.js b/lib/locator.js
index 1c958b9d9..f10a94399 100644
--- a/lib/locator.js
+++ b/lib/locator.js
@@ -175,7 +175,7 @@ class Locator {
    */
   toXPath(pseudoSelector = '') {
     const locator = `${this.value}${pseudoSelector}`;
-    const limitation = [':nth-of-type', ':first-of-type', ':last-of-type', ':nth-last-child', ':nth-last-of-type', ':checked', ':disabled', ':enabled', ':required', ':lang', ':nth-child'];
+    const limitation = [':nth-of-type', ':first-of-type', ':last-of-type', ':nth-last-child', ':nth-last-of-type', ':checked', ':disabled', ':enabled', ':required', ':lang', ':nth-child', ':has'];
 
     if (limitation.some(item => locator.includes(item))) {
       cssToXPath = require('css-to-xpath');
diff --git a/lib/plugin/allure.js b/lib/plugin/allure.js
index dec5c9038..2b180c827 100644
--- a/lib/plugin/allure.js
+++ b/lib/plugin/allure.js
@@ -1,15 +1,15 @@
 module.exports = () => {
-  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config');
-  console.log();
-  console.log('npm install @codeceptjs/allure-legacy --save-dev');
-  console.log();
-  console.log('Then update your config to use it:');
-  console.log();
-  console.log('plugins: {');
-  console.log('  allure: {');
-  console.log('    enabled: true,');
-  console.log('    require: \'@codeceptjs/allure-legacy\',');
-  console.log('  }');
-  console.log('}');
-  console.log();
-};
+  console.log('Allure plugin was moved to @codeceptjs/allure-legacy. Please install it and update your config')
+  console.log()
+  console.log('npm install @codeceptjs/allure-legacy --save-dev')
+  console.log()
+  console.log('Then update your config to use it:')
+  console.log()
+  console.log('plugins: {')
+  console.log('  allure: {')
+  console.log('    enabled: true,')
+  console.log("    require: '@codeceptjs/allure-legacy',")
+  console.log('  }')
+  console.log('}')
+  console.log()
+}
diff --git a/lib/plugin/autoDelay.js b/lib/plugin/autoDelay.js
index bb4db9b86..190ba71a0 100644
--- a/lib/plugin/autoDelay.js
+++ b/lib/plugin/autoDelay.js
@@ -1,24 +1,17 @@
-const Container = require('../container');
-const store = require('../store');
-const recorder = require('../recorder');
-const event = require('../event');
-const log = require('../output').log;
-const supportedHelpers = require('./standardActingHelpers').slice();
+const Container = require('../container')
+const store = require('../store')
+const recorder = require('../recorder')
+const event = require('../event')
+const log = require('../output').log
+const supportedHelpers = require('./standardActingHelpers').slice()
 
-const methodsToDelay = [
-  'click',
-  'fillField',
-  'checkOption',
-  'pressKey',
-  'doubleClick',
-  'rightClick',
-];
+const methodsToDelay = ['click', 'fillField', 'checkOption', 'pressKey', 'doubleClick', 'rightClick']
 
 const defaultConfig = {
   methods: methodsToDelay,
   delayBefore: 100,
   delayAfter: 200,
-};
+}
 
 /**
  *
@@ -59,41 +52,41 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  supportedHelpers.push('REST');
-  const helpers = Container.helpers();
-  let helper;
+  supportedHelpers.push('REST')
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for auto-delay
+  if (!helper) return // no helpers for auto-delay
 
   event.dispatcher.on(event.step.before, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return; // no need to delay in debug
-      log(`Delaying for ${config.delayBefore}ms`);
+      if (store.debugMode) return // no need to delay in debug
+      log(`Delaying for ${config.delayBefore}ms`)
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayBefore);
-      });
-    });
-  });
+        setTimeout(resolve, config.delayBefore)
+      })
+    })
+  })
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (config.methods.indexOf(step.helperMethod) < 0) return; // skip non-actions
+    if (config.methods.indexOf(step.helperMethod) < 0) return // skip non-actions
 
     recorder.add('auto-delay', async () => {
-      if (store.debugMode) return; // no need to delay in debug
-      log(`Delaying for ${config.delayAfter}ms`);
+      if (store.debugMode) return // no need to delay in debug
+      log(`Delaying for ${config.delayAfter}ms`)
       return new Promise((resolve) => {
-        setTimeout(resolve, config.delayAfter);
-      });
-    });
-  });
-};
+        setTimeout(resolve, config.delayAfter)
+      })
+    })
+  })
+}
diff --git a/lib/plugin/autoLogin.js b/lib/plugin/autoLogin.js
index 2a410a48a..b10290edf 100644
--- a/lib/plugin/autoLogin.js
+++ b/lib/plugin/autoLogin.js
@@ -1,25 +1,25 @@
-const fs = require('fs');
-const path = require('path');
-const { fileExists } = require('../utils');
-const container = require('../container');
-const store = require('../store');
-const recorder = require('../recorder');
-const { debug } = require('../output');
-const isAsyncFunction = require('../utils').isAsyncFunction;
+const fs = require('fs')
+const path = require('path')
+const { fileExists } = require('../utils')
+const container = require('../container')
+const store = require('../store')
+const recorder = require('../recorder')
+const { debug } = require('../output')
+const isAsyncFunction = require('../utils').isAsyncFunction
 
 const defaultUser = {
-  fetch: I => I.grabCookie(),
+  fetch: (I) => I.grabCookie(),
   check: () => {},
   restore: (I, cookies) => {
-    I.amOnPage('/'); // open a page
-    I.setCookie(cookies);
+    I.amOnPage('/') // open a page
+    I.setCookie(cookies)
   },
-};
+}
 
 const defaultConfig = {
   saveToFile: false,
   inject: 'login',
-};
+}
 
 /**
  * Logs user in for the first test and reuses session for next tests.
@@ -249,88 +249,92 @@ const defaultConfig = {
  * })
  *
  *
-*/
+ */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
-  Object.keys(config.users).map(u => config.users[u] = {
-    ...defaultUser,
-    ...config.users[u],
-  });
+  config = Object.assign(defaultConfig, config)
+  Object.keys(config.users).map(
+    (u) =>
+      (config.users[u] = {
+        ...defaultUser,
+        ...config.users[u],
+      }),
+  )
 
   if (config.saveToFile) {
     // loading from file
     for (const name in config.users) {
-      const fileName = path.join(global.output_dir, `${name}_session.json`);
-      if (!fileExists(fileName)) continue;
-      const data = fs.readFileSync(fileName).toString();
+      const fileName = path.join(global.output_dir, `${name}_session.json`)
+      if (!fileExists(fileName)) continue
+      const data = fs.readFileSync(fileName).toString()
       try {
-        store[`${name}_session`] = JSON.parse(data);
+        store[`${name}_session`] = JSON.parse(data)
       } catch (err) {
-        throw new Error(`Could not load session from ${fileName}\n${err}`);
+        throw new Error(`Could not load session from ${fileName}\n${err}`)
       }
-      debug(`Loaded user session for ${name}`);
+      debug(`Loaded user session for ${name}`)
     }
   }
 
   const loginFunction = async (name) => {
-    const userSession = config.users[name];
-    const I = container.support('I');
-    const cookies = store[`${name}_session`];
-    const shouldAwait = isAsyncFunction(userSession.login)
-      || isAsyncFunction(userSession.restore)
-      || isAsyncFunction(userSession.check);
+    const userSession = config.users[name]
+    const I = container.support('I')
+    const cookies = store[`${name}_session`]
+    const shouldAwait =
+      isAsyncFunction(userSession.login) || isAsyncFunction(userSession.restore) || isAsyncFunction(userSession.check)
 
     const loginAndSave = async () => {
       if (shouldAwait) {
-        await userSession.login(I);
+        await userSession.login(I)
       } else {
-        userSession.login(I);
+        userSession.login(I)
       }
 
-      const cookies = await userSession.fetch(I);
+      const cookies = await userSession.fetch(I)
       if (!cookies) {
-        debug('Cannot save user session with empty cookies from auto login\'s fetch method');
-        return;
+        debug("Cannot save user session with empty cookies from auto login's fetch method")
+        return
       }
       if (config.saveToFile) {
-        debug(`Saved user session into file for ${name}`);
-        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies));
+        debug(`Saved user session into file for ${name}`)
+        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies))
       }
-      store[`${name}_session`] = cookies;
-    };
+      store[`${name}_session`] = cookies
+    }
 
-    if (!cookies) return loginAndSave();
+    if (!cookies) return loginAndSave()
 
-    recorder.session.start('check login');
+    recorder.session.start('check login')
     if (shouldAwait) {
-      await userSession.restore(I, cookies);
-      await userSession.check(I, cookies);
+      await userSession.restore(I, cookies)
+      await userSession.check(I, cookies)
     } else {
-      userSession.restore(I, cookies);
-      userSession.check(I, cookies);
+      userSession.restore(I, cookies)
+      userSession.check(I, cookies)
     }
     recorder.session.catch((err) => {
-      debug(`Failed auto login for ${name} due to ${err}`);
-      debug('Logging in again');
-      recorder.session.start('auto login');
-      return loginAndSave().then(() => {
-        recorder.add(() => recorder.session.restore('auto login'));
-        recorder.catch(() => debug('continue'));
-      }).catch((err) => {
-        recorder.session.restore('auto login');
-        recorder.session.restore('check login');
-        recorder.throw(err);
-      });
-    });
+      debug(`Failed auto login for ${name} due to ${err}`)
+      debug('Logging in again')
+      recorder.session.start('auto login')
+      return loginAndSave()
+        .then(() => {
+          recorder.add(() => recorder.session.restore('auto login'))
+          recorder.catch(() => debug('continue'))
+        })
+        .catch((err) => {
+          recorder.session.restore('auto login')
+          recorder.session.restore('check login')
+          recorder.throw(err)
+        })
+    })
     recorder.add(() => {
-      recorder.session.restore('check login');
-    });
+      recorder.session.restore('check login')
+    })
 
-    return recorder.promise();
-  };
+    return recorder.promise()
+  }
 
   // adding this to DI container
-  const support = {};
-  support[config.inject] = loginFunction;
-  container.append({ support });
-};
+  const support = {}
+  support[config.inject] = loginFunction
+  container.append({ support })
+}
diff --git a/lib/plugin/commentStep.js b/lib/plugin/commentStep.js
index de8caa5a3..a693fffd4 100644
--- a/lib/plugin/commentStep.js
+++ b/lib/plugin/commentStep.js
@@ -1,10 +1,10 @@
-const event = require('../event');
-const recorder = require('../recorder');
-const { MetaStep } = require('../step');
+const event = require('../event')
+const recorder = require('../recorder')
+const { MetaStep } = require('../step')
 
-let currentCommentStep;
+let currentCommentStep
 
-const defaultGlobalName = '__';
+const defaultGlobalName = '__'
 
 /**
  * Add descriptive nested steps for your tests:
@@ -101,36 +101,36 @@ const defaultGlobalName = '__';
  */
 module.exports = function (config) {
   event.dispatcher.on(event.test.started, () => {
-    currentCommentStep = null;
-  });
+    currentCommentStep = null
+  })
 
   event.dispatcher.on(event.step.started, (step) => {
     if (currentCommentStep) {
-      const metaStep = getRootMetaStep(step);
+      const metaStep = getRootMetaStep(step)
 
       if (metaStep !== currentCommentStep) {
-        metaStep.metaStep = currentCommentStep;
+        metaStep.metaStep = currentCommentStep
       }
     }
-  });
+  })
 
   if (config.registerGlobal) {
     if (config.registerGlobal === true) {
-      config.registerGlobal = defaultGlobalName;
+      config.registerGlobal = defaultGlobalName
     }
-    global[config.registerGlobal] = setCommentString;
+    global[config.registerGlobal] = setCommentString
   }
 
-  return setCommentString;
-};
+  return setCommentString
+}
 
 function getRootMetaStep(step) {
-  if (step.metaStep) return getRootMetaStep(step.metaStep);
-  return step;
+  if (step.metaStep) return getRootMetaStep(step.metaStep)
+  return step
 }
 
 function setCommentString(string) {
   recorder.add('set comment metastep', () => {
-    currentCommentStep = new MetaStep(String.raw(string), '');
-  });
+    currentCommentStep = new MetaStep(String.raw(string), '')
+  })
 }
diff --git a/lib/plugin/coverage.js b/lib/plugin/coverage.js
index 176f8cf1d..d4e8da72d 100644
--- a/lib/plugin/coverage.js
+++ b/lib/plugin/coverage.js
@@ -1,17 +1,17 @@
-const debugModule = require('debug');
-const { CoverageReport } = require('monocart-coverage-reports');
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const { deepMerge } = require('../utils');
+const debugModule = require('debug')
+const { CoverageReport } = require('monocart-coverage-reports')
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const { deepMerge } = require('../utils')
 
 const defaultConfig = {
   name: 'CodeceptJS Coverage Report',
   outputDir: 'output/coverage',
-};
+}
 
-const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver'];
+const supportedHelpers = ['Puppeteer', 'Playwright', 'WebDriver']
 
 const v8CoverageHelpers = {
   Playwright: {
@@ -23,15 +23,15 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
-      const coverageList = [...jsCoverage, ...cssCoverage];
-      await coverageReport.add(coverageList);
+      ])
+      const coverageList = [...jsCoverage, ...cssCoverage]
+      await coverageReport.add(coverageList)
     },
   },
   Puppeteer: {
@@ -44,21 +44,24 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
+      ])
       // to raw V8 script coverage
-      const coverageList = [...jsCoverage.map((it) => {
-        return {
-          source: it.text,
-          ...it.rawScriptCoverage,
-        };
-      }), ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const coverageList = [
+        ...jsCoverage.map((it) => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
     },
   },
   WebDriver: {
@@ -71,24 +74,27 @@ const v8CoverageHelpers = {
         page.coverage.startCSSCoverage({
           resetOnNavigation: false,
         }),
-      ]);
+      ])
     },
     takeCoverage: async (page, coverageReport) => {
       const [jsCoverage, cssCoverage] = await Promise.all([
         page.coverage.stopJSCoverage(),
         page.coverage.stopCSSCoverage(),
-      ]);
+      ])
       // to raw V8 script coverage
-      const coverageList = [...jsCoverage.map((it) => {
-        return {
-          source: it.text,
-          ...it.rawScriptCoverage,
-        };
-      }), ...cssCoverage];
-      await coverageReport.add(coverageList);
+      const coverageList = [
+        ...jsCoverage.map((it) => {
+          return {
+            source: it.text,
+            ...it.rawScriptCoverage,
+          }
+        }),
+        ...cssCoverage,
+      ]
+      await coverageReport.add(coverageList)
     },
   },
-};
+}
 
 /**
  * Dumps code coverage from Playwright/Puppeteer after every test.
@@ -117,72 +123,81 @@ const v8CoverageHelpers = {
  *
  */
 module.exports = function (config) {
-  config = deepMerge(defaultConfig, config);
+  config = deepMerge(defaultConfig, config)
 
-  if (config.debug) config.logging = 'debug';
+  if (config.debug) config.logging = 'debug'
 
-  const helpers = Container.helpers();
-  let coverageRunning = false;
+  const helpers = Container.helpers()
+  let coverageRunning = false
 
-  const v8Names = Object.keys(v8CoverageHelpers);
-  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it));
+  const v8Names = Object.keys(v8CoverageHelpers)
+  const helperName = Object.keys(helpers).find((it) => v8Names.includes(it))
   if (!helperName) {
-    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`);
+    console.error(`Coverage is only supported in ${supportedHelpers.join(' or ')}`)
     // no helpers for screenshot
-    return;
+    return
   }
 
-  config.name = `${config.name} - in ${helperName}`;
-  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`);
+  config.name = `${config.name} - in ${helperName}`
+  const debug = debugModule(`codeceptjs:plugin:${helperName.toLowerCase()}Coverage`)
 
-  const helper = helpers[helperName];
+  const helper = helpers[helperName]
 
-  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol) throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.');
+  if (helperName === 'WebDriver' && !helper.config.devtoolsProtocol)
+    throw Error('Coverage is currently supporting the WebDriver running with Devtools protocol.')
 
-  const v8Helper = v8CoverageHelpers[helperName];
+  const v8Helper = v8CoverageHelpers[helperName]
 
   const coverageOptions = {
     ...config,
-  };
+  }
 
-  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8';
+  if (helperName === 'WebDriver') coverageOptions.coverageProvider = 'v8'
 
-  const coverageReport = new CoverageReport(coverageOptions);
-  coverageReport.cleanCache();
+  const coverageReport = new CoverageReport(coverageOptions)
+  coverageReport.cleanCache()
 
   event.dispatcher.on(event.all.after, async () => {
-    output.print(`writing ${coverageOptions.outputDir}`);
-    await coverageReport.generate();
-  });
+    output.print(`writing ${coverageOptions.outputDir}`)
+    await coverageReport.generate()
+  })
 
   //  we're going to try to "start" coverage before each step because this is
   //  when the browser is already up and is ready to start coverage.
   event.dispatcher.on(event.step.before, () => {
-    recorder.add('start coverage', async () => {
-      if (coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = true;
-      debug('--> starting coverage <--');
-      await v8Helper.startCoverage(helper.page);
-    }, true);
-  });
+    recorder.add(
+      'start coverage',
+      async () => {
+        if (coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = true
+        debug('--> starting coverage <--')
+        await v8Helper.startCoverage(helper.page)
+      },
+      true,
+    )
+  })
 
   // Save coverage data after every test run
   event.dispatcher.on(event.test.after, (test) => {
-    recorder.add('take coverage', async () => {
-      if (!coverageRunning) {
-        return;
-      }
-      if (!helper.page || !helper.page.coverage) {
-        return;
-      }
-      coverageRunning = false;
-      debug('--> stopping coverage <--');
-      await v8Helper.takeCoverage(helper.page, coverageReport);
-    }, true);
-  });
-};
+    recorder.add(
+      'take coverage',
+      async () => {
+        if (!coverageRunning) {
+          return
+        }
+        if (!helper.page || !helper.page.coverage) {
+          return
+        }
+        coverageRunning = false
+        debug('--> stopping coverage <--')
+        await v8Helper.takeCoverage(helper.page, coverageReport)
+      },
+      true,
+    )
+  })
+}
diff --git a/lib/plugin/customLocator.js b/lib/plugin/customLocator.js
index acc812396..4d944f9af 100644
--- a/lib/plugin/customLocator.js
+++ b/lib/plugin/customLocator.js
@@ -1,12 +1,12 @@
-const Locator = require('../locator');
-const { xpathLocator } = require('../utils');
+const Locator = require('../locator')
+const { xpathLocator } = require('../utils')
 
 const defaultConfig = {
   prefix: '$',
   attribute: 'data-test-id',
   strategy: 'xpath',
   showActual: false,
-};
+}
 
 /**
  * Creates a [custom locator](https://codecept.io/locators#custom-locators) by using special attributes in HTML.
@@ -112,33 +112,34 @@ const defaultConfig = {
  * ```
  */
 module.exports = (config) => {
-  config = { ...defaultConfig, ...config };
+  config = { ...defaultConfig, ...config }
 
   Locator.addFilter((value, locatorObj) => {
-    if (typeof value !== 'string') return;
-    if (!value.startsWith(config.prefix)) return;
+    if (typeof value !== 'string') return
+    if (!value.startsWith(config.prefix)) return
 
-    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return;
+    if (!['String', 'Array'].includes(config.attribute.constructor.name)) return
 
-    const val = value.substr(config.prefix.length);
+    const val = value.substr(config.prefix.length)
 
     if (config.strategy.toLowerCase() === 'xpath') {
-      locatorObj.value = `.//*[${
-        [].concat(config.attribute)
-          .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
-          .join(' or ')}]`;
-      locatorObj.type = 'xpath';
+      locatorObj.value = `.//*[${[]
+        .concat(config.attribute)
+        .map((attr) => `@${attr}=${xpathLocator.literal(val)}`)
+        .join(' or ')}]`
+      locatorObj.type = 'xpath'
     }
 
     if (config.strategy.toLowerCase() === 'css') {
-      locatorObj.value = [].concat(config.attribute)
+      locatorObj.value = []
+        .concat(config.attribute)
         .map((attr) => `[${attr}=${val}]`)
-        .join(',');
-      locatorObj.type = 'css';
+        .join(',')
+      locatorObj.type = 'css'
     }
 
     if (config.showActual) {
-      locatorObj.output = locatorObj.value;
+      locatorObj.output = locatorObj.value
     }
-  });
-};
+  })
+}
diff --git a/lib/plugin/debugErrors.js b/lib/plugin/debugErrors.js
index 7b45d2f1d..40948893a 100644
--- a/lib/plugin/debugErrors.js
+++ b/lib/plugin/debugErrors.js
@@ -1,13 +1,13 @@
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const supportedHelpers = require('./standardActingHelpers');
-const { scanForErrorMessages } = require('../html');
-const { output } = require('..');
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const supportedHelpers = require('./standardActingHelpers')
+const { scanForErrorMessages } = require('../html')
+const { output } = require('..')
 
 const defaultConfig = {
   errorClasses: ['error', 'warning', 'alert', 'danger'],
-};
+}
 
 /**
  * Prints errors found in HTML code after each failed test.
@@ -30,38 +30,38 @@ const defaultConfig = {
  *
  */
 module.exports = function (config = {}) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for screenshot
+  if (!helper) return // no helpers for screenshot
 
   event.dispatcher.on(event.test.failed, (test) => {
     recorder.add('HTML snapshot failed test', async () => {
       try {
-        const currentOutputLevel = output.level();
-        output.level(0);
-        const html = await helper.grabHTMLFrom('body');
-        output.level(currentOutputLevel);
+        const currentOutputLevel = output.level()
+        output.level(0)
+        const html = await helper.grabHTMLFrom('body')
+        output.level(currentOutputLevel)
 
-        if (!html) return;
+        if (!html) return
 
-        const errors = scanForErrorMessages(html, config.errorClasses);
+        const errors = scanForErrorMessages(html, config.errorClasses)
         if (errors.length) {
-          output.debug('Detected errors in HTML code');
-          errors.forEach((error) => output.debug(error));
-          test.artifacts.errors = errors;
+          output.debug('Detected errors in HTML code')
+          errors.forEach((error) => output.debug(error))
+          test.artifacts.errors = errors
         }
       } catch (err) {
         // not really needed
       }
-    });
-  });
-};
+    })
+  })
+}
diff --git a/lib/plugin/eachElement.js b/lib/plugin/eachElement.js
index 1ab51a57b..466247b59 100644
--- a/lib/plugin/eachElement.js
+++ b/lib/plugin/eachElement.js
@@ -1,14 +1,14 @@
-const output = require('../output');
-const store = require('../store');
-const recorder = require('../recorder');
-const container = require('../container');
-const event = require('../event');
-const Step = require('../step');
-const { isAsyncFunction } = require('../utils');
+const output = require('../output')
+const store = require('../store')
+const recorder = require('../recorder')
+const container = require('../container')
+const event = require('../event')
+const Step = require('../step')
+const { isAsyncFunction } = require('../utils')
 
 const defaultConfig = {
   registerGlobal: true,
-};
+}
 
 /**
  * Provides `eachElement` global function to iterate over found elements to perform actions on them.
@@ -69,59 +69,59 @@ const defaultConfig = {
  * @return {Promise<*> | undefined}
  */
 function eachElement(purpose, locator, fn) {
-  if (store.dryRun) return;
-  const helpers = Object.values(container.helpers());
+  if (store.dryRun) return
+  const helpers = Object.values(container.helpers())
 
-  const helper = helpers.filter(h => !!h._locate)[0];
+  const helper = helpers.filter((h) => !!h._locate)[0]
 
   if (!helper) {
-    throw new Error('No helper enabled with _locate method with returns a list of elements.');
+    throw new Error('No helper enabled with _locate method with returns a list of elements.')
   }
 
   if (!isAsyncFunction(fn)) {
-    throw new Error('Async function should be passed into each element');
+    throw new Error('Async function should be passed into each element')
   }
 
-  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`);
-  step.helperMethod = '_locate';
+  const step = new Step(helper, `${purpose || 'each element'} within "${locator}"`)
+  step.helperMethod = '_locate'
   // eachElement('select all users', 'locator', async (el) => {
-  event.dispatcher.emit(event.step.before, step);
+  event.dispatcher.emit(event.step.before, step)
 
   return recorder.add('register each element wrapper', async () => {
-    event.emit(event.step.started, step);
-    const els = await helper._locate(locator);
-    output.debug(`Found ${els.length} elements for each elements to iterate`);
+    event.emit(event.step.started, step)
+    const els = await helper._locate(locator)
+    output.debug(`Found ${els.length} elements for each elements to iterate`)
 
-    const errs = [];
-    let i = 0;
+    const errs = []
+    let i = 0
     for (const el of els) {
       try {
-        await fn(el, i);
+        await fn(el, i)
       } catch (err) {
-        output.error(`eachElement: failed operation on element #${i} ${el}`);
-        errs.push(err);
+        output.error(`eachElement: failed operation on element #${i} ${el}`)
+        errs.push(err)
       }
-      i++;
+      i++
     }
 
     if (errs.length) {
-      event.dispatcher.emit(event.step.after, step);
-      event.emit(event.step.failed, step, errs[0]);
-      event.emit(event.step.finished, step);
-      throw errs[0];
+      event.dispatcher.emit(event.step.after, step)
+      event.emit(event.step.failed, step, errs[0])
+      event.emit(event.step.finished, step)
+      throw errs[0]
     }
 
-    event.dispatcher.emit(event.step.after, step);
-    event.emit(event.step.passed, step, null);
-    event.emit(event.step.finished, step);
-  });
+    event.dispatcher.emit(event.step.after, step)
+    event.emit(event.step.passed, step, null)
+    event.emit(event.step.finished, step)
+  })
 }
 
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   if (config.registerGlobal) {
-    global.eachElement = eachElement;
+    global.eachElement = eachElement
   }
-  return eachElement;
-};
+  return eachElement
+}
diff --git a/lib/plugin/fakerTransform.js b/lib/plugin/fakerTransform.js
index 654d07e90..79a721d08 100644
--- a/lib/plugin/fakerTransform.js
+++ b/lib/plugin/fakerTransform.js
@@ -1,5 +1,5 @@
-const { faker } = require('@faker-js/faker');
-const transform = require('../transform');
+const { faker } = require('@faker-js/faker')
+const transform = require('../transform')
 
 /**
  * Use the `@faker-js/faker` package to generate fake data inside examples on your gherkin tests
@@ -42,8 +42,8 @@ const transform = require('../transform');
 module.exports = function (config) {
   transform.addTransformerBeforeAll('gherkin.examples', (value) => {
     if (typeof value === 'string' && value.length > 0) {
-      return faker.helpers.fake(value);
+      return faker.helpers.fake(value)
     }
-    return value;
-  });
-};
+    return value
+  })
+}
diff --git a/lib/plugin/heal.js b/lib/plugin/heal.js
index 43053fe89..1aa2a3626 100644
--- a/lib/plugin/heal.js
+++ b/lib/plugin/heal.js
@@ -1,14 +1,14 @@
-const debug = require('debug')('codeceptjs:heal');
-const colors = require('chalk');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const heal = require('../heal');
-const store = require('../store');
+const debug = require('debug')('codeceptjs:heal')
+const colors = require('chalk')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const heal = require('../heal')
+const store = require('../store')
 
 const defaultConfig = {
   healLimit: 2,
-};
+}
 
 /**
  * Self-healing tests with AI.
@@ -31,88 +31,91 @@ const defaultConfig = {
 module.exports = function (config = {}) {
   if (store.debugMode && !process.env.DEBUG) {
     event.dispatcher.on(event.test.failed, () => {
-      output.plugin('heal', 'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode');
-    });
-    return;
+      output.plugin(
+        'heal',
+        'Healing is disabled in --debug mode, use DEBUG="codeceptjs:heal" to enable it in debug mode',
+      )
+    })
+    return
   }
 
-  let currentTest = null;
-  let currentStep = null;
-  let healedSteps = 0;
-  let caughtError;
-  let healTries = 0;
-  let isHealing = false;
+  let currentTest = null
+  let currentStep = null
+  let healedSteps = 0
+  let caughtError
+  let healTries = 0
+  let isHealing = false
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   event.dispatcher.on(event.test.before, (test) => {
-    currentTest = test;
-    healedSteps = 0;
-    caughtError = null;
-  });
+    currentTest = test
+    healedSteps = 0
+    caughtError = null
+  })
 
-  event.dispatcher.on(event.step.started, step => currentStep = step);
+  event.dispatcher.on(event.step.started, (step) => (currentStep = step))
 
   event.dispatcher.on(event.step.after, (step) => {
-    if (isHealing) return;
-    if (healTries >= config.healLimit) return; // out of limit
+    if (isHealing) return
+    if (healTries >= config.healLimit) return // out of limit
 
-    if (!heal.hasCorrespondingRecipes(step)) return;
+    if (!heal.hasCorrespondingRecipes(step)) return
 
     recorder.catchWithoutStop(async (err) => {
-      isHealing = true;
-      if (caughtError === err) throw err; // avoid double handling
-      caughtError = err;
+      isHealing = true
+      if (caughtError === err) throw err // avoid double handling
+      caughtError = err
 
-      const test = currentTest;
+      const test = currentTest
 
-      recorder.session.start('heal');
+      recorder.session.start('heal')
 
-      debug('Self-healing started', step.toCode());
+      debug('Self-healing started', step.toCode())
 
-      await heal.healStep(step, err, { test });
+      await heal.healStep(step, err, { test })
 
-      healTries++;
+      healTries++
 
       recorder.add('close healing session', () => {
-        recorder.reset();
-        recorder.session.restore('heal');
-        recorder.ignoreErr(err);
-      });
-      await recorder.promise();
+        recorder.reset()
+        recorder.session.restore('heal')
+        recorder.ignoreErr(err)
+      })
+      await recorder.promise()
 
-      isHealing = false;
-    });
-  });
+      isHealing = false
+    })
+  })
 
   event.dispatcher.on(event.all.result, () => {
-    if (!heal.fixes?.length) return;
+    if (!heal.fixes?.length) return
 
-    const { print } = output;
+    const { print } = output
 
-    print('');
-    print('===================');
-    print(colors.bold.green('Self-Healing Report:'));
+    print('')
+    print('===================')
+    print(colors.bold.green('Self-Healing Report:'))
 
-    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`);
+    print(`${colors.bold(heal.fixes.length)} ${heal.fixes.length === 1 ? 'step was' : 'steps were'} healed`)
 
-    const suggestions = heal.fixes.filter(fix => fix.recipe && heal.recipes[fix.recipe].suggest);
+    const suggestions = heal.fixes.filter((fix) => fix.recipe && heal.recipes[fix.recipe].suggest)
 
-    if (!suggestions.length) return;
+    if (!suggestions.length) return
 
-    let i = 1;
-    print('');
-    print('Suggested changes:');
-    print('');
+    let i = 1
+    print('')
+    print('Suggested changes:')
+    print('')
 
     for (const suggestion of suggestions) {
-      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`);
-      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`));
-      print(colors.red(`- ${suggestion.step.toCode()}`));
-      print(colors.green(`+ ${suggestion.snippet}`));
-      print(suggestion.step.line());
-      print('');
-      i++;
+      print(`${i}. To fix ${colors.bold.magenta(suggestion.test?.title)}`)
+      print('  Replace the failed code:', colors.gray(`(suggested by ${colors.bold(suggestion.recipe)})`))
+      print(colors.red(`- ${suggestion.step.toCode()}`))
+      print(colors.green(`+ ${suggestion.snippet}`))
+      print(suggestion.step.line())
+      print('')
+      i++
     }
-  });
-};
+  })
+}
diff --git a/lib/plugin/pauseOnFail.js b/lib/plugin/pauseOnFail.js
index 5ab06dc49..a36cdd441 100644
--- a/lib/plugin/pauseOnFail.js
+++ b/lib/plugin/pauseOnFail.js
@@ -1,5 +1,5 @@
-const event = require('../event');
-const pause = require('../pause');
+const event = require('../event')
+const pause = require('../pause')
 
 /**
  * Automatically launches [interactive pause](/basics/#pause) when a test fails.
@@ -22,17 +22,17 @@ const pause = require('../pause');
  *
  */
 module.exports = () => {
-  let failed = false;
+  let failed = false
 
   event.dispatcher.on(event.test.started, () => {
-    failed = false;
-  });
+    failed = false
+  })
 
   event.dispatcher.on(event.step.failed, () => {
-    failed = true;
-  });
+    failed = true
+  })
 
   event.dispatcher.on(event.test.after, () => {
-    if (failed) pause();
-  });
-};
+    if (failed) pause()
+  })
+}
diff --git a/lib/plugin/retryFailedStep.js b/lib/plugin/retryFailedStep.js
index 4ba90acdd..8cb148634 100644
--- a/lib/plugin/retryFailedStep.js
+++ b/lib/plugin/retryFailedStep.js
@@ -1,21 +1,14 @@
-const event = require('../event');
-const recorder = require('../recorder');
-const container = require('../container');
-const { log } = require('../output');
+const event = require('../event')
+const recorder = require('../recorder')
+const container = require('../container')
+const { log } = require('../output')
 
 const defaultConfig = {
   retries: 3,
-  defaultIgnoredSteps: [
-    'amOnPage',
-    'wait*',
-    'send*',
-    'execute*',
-    'run*',
-    'have*',
-  ],
+  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
   factor: 1.5,
   ignoredSteps: [],
-};
+}
 
 /**
  * Retries each failed step in a test.
@@ -84,45 +77,45 @@ const defaultConfig = {
  *
  */
 module.exports = (config) => {
-  config = Object.assign(defaultConfig, config);
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps);
-  const customWhen = config.when;
+  config = Object.assign(defaultConfig, config)
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
+  const customWhen = config.when
 
-  let enableRetry = false;
+  let enableRetry = false
 
   const when = (err) => {
-    if (!enableRetry) return;
-    const store = require('../store');
-    if (store.debugMode) return false;
-    if (customWhen) return customWhen(err);
-    return true;
-  };
-  config.when = when;
+    if (!enableRetry) return
+    const store = require('../store')
+    if (store.debugMode) return false
+    if (customWhen) return customWhen(err)
+    return true
+  }
+  config.when = when
 
   event.dispatcher.on(event.step.started, (step) => {
     if (process.env.TRY_TO === 'true') {
-      log('Info: RetryFailedStep plugin is disabled inside tryTo block');
-      return;
+      log('Info: RetryFailedStep plugin is disabled inside tryTo block')
+      return
     }
 
     // if a step is ignored - return
     for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return;
+      if (step.name === ignored) return
       if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return;
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return;
+        if (step.name.match(ignored)) return
+      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
     }
-    enableRetry = true; // enable retry for a step
-  });
+    enableRetry = true // enable retry for a step
+  })
 
   event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false;
-  });
+    enableRetry = false
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
-    if (test && test.disableRetryFailedStep) return; // disable retry when a test is not active
+    if (test && test.disableRetryFailedStep) return // disable retry when a test is not active
     // this env var is used to set the retries inside _before() block of helpers
-    process.env.FAILED_STEP_RETRIES = config.retries;
-    recorder.retry(config);
-  });
-};
+    process.env.FAILED_STEP_RETRIES = config.retries
+    recorder.retry(config)
+  })
+}
diff --git a/lib/plugin/retryTo.js b/lib/plugin/retryTo.js
index 4c93b56c9..58e0551e9 100644
--- a/lib/plugin/retryTo.js
+++ b/lib/plugin/retryTo.js
@@ -1,10 +1,10 @@
-const recorder = require('../recorder');
-const { debug } = require('../output');
+const recorder = require('../recorder')
+const { debug } = require('../output')
 
 const defaultConfig = {
   registerGlobal: true,
   pollInterval: 200,
-};
+}
 
 /**
  *
@@ -74,54 +74,54 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
   function retryTo(callback, maxTries, pollInterval = config.pollInterval) {
     return new Promise((done, reject) => {
-      let tries = 1;
+      let tries = 1
 
       function handleRetryException(err) {
-        recorder.throw(err);
-        reject(err);
+        recorder.throw(err)
+        reject(err)
       }
 
       const tryBlock = async () => {
-        tries++;
-        recorder.session.start(`retryTo ${tries}`);
+        tries++
+        recorder.session.start(`retryTo ${tries}`)
         try {
-          await callback(tries);
+          await callback(tries)
         } catch (err) {
-          handleRetryException(err);
+          handleRetryException(err)
         }
 
         // Call done if no errors
         recorder.add(() => {
-          recorder.session.restore(`retryTo ${tries}`);
-          done(null);
-        });
+          recorder.session.restore(`retryTo ${tries}`)
+          done(null)
+        })
 
         // Catch errors and retry
         recorder.session.catch((err) => {
-          recorder.session.restore(`retryTo ${tries}`);
+          recorder.session.restore(`retryTo ${tries}`)
           if (tries <= maxTries) {
-            debug(`Error ${err}... Retrying`);
-            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval));
+            debug(`Error ${err}... Retrying`)
+            recorder.add(`retryTo ${tries}`, () => setTimeout(tryBlock, pollInterval))
           } else {
             // if maxTries reached
-            handleRetryException(err);
+            handleRetryException(err)
           }
-        });
-      };
+        })
+      }
 
-      recorder.add('retryTo', tryBlock).catch(err => {
-        console.error('An error occurred:', err);
-        done(null);
-      });
-    });
+      recorder.add('retryTo', tryBlock).catch((err) => {
+        console.error('An error occurred:', err)
+        done(null)
+      })
+    })
   }
 
   if (config.registerGlobal) {
-    global.retryTo = retryTo;
+    global.retryTo = retryTo
   }
 
-  return retryTo;
-};
+  return retryTo
+}
diff --git a/lib/plugin/screenshotOnFail.js b/lib/plugin/screenshotOnFail.js
index 501ce2777..5c1d857d9 100644
--- a/lib/plugin/screenshotOnFail.js
+++ b/lib/plugin/screenshotOnFail.js
@@ -1,20 +1,20 @@
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs')
+const path = require('path')
 
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const { fileExists, clearString } = require('../utils');
-const Codeceptjs = require('../index');
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const { fileExists, clearString } = require('../utils')
+const Codeceptjs = require('../index')
 
 const defaultConfig = {
   uniqueScreenshotNames: false,
   disableScreenshots: false,
   fullPageScreenshots: false,
-};
+}
 
-const supportedHelpers = require('./standardActingHelpers');
+const supportedHelpers = require('./standardActingHelpers')
 
 /**
  * Creates screenshot on failure. Screenshot is saved into `output` directory.
@@ -43,118 +43,139 @@ const supportedHelpers = require('./standardActingHelpers');
  *
  */
 module.exports = function (config) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for screenshot
+  if (!helper) return // no helpers for screenshot
 
-  const options = Object.assign(defaultConfig, helper.options, config);
+  const options = Object.assign(defaultConfig, helper.options, config)
 
   if (helpers.Mochawesome) {
     if (helpers.Mochawesome.config) {
-      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames;
+      options.uniqueScreenshotNames = helpers.Mochawesome.config.uniqueScreenshotNames
     }
   }
 
   if (Codeceptjs.container.mocha()) {
-    options.reportDir = Codeceptjs.container.mocha().options.reporterOptions
-      && Codeceptjs.container.mocha().options.reporterOptions.reportDir;
+    options.reportDir =
+      Codeceptjs.container.mocha().options.reporterOptions &&
+      Codeceptjs.container.mocha().options.reporterOptions.reportDir
   }
 
   if (options.disableScreenshots) {
     // old version of disabling screenshots
-    return;
+    return
   }
 
   event.dispatcher.on(event.test.failed, (test) => {
     if (test.ctx?._runnable.title.includes('hook: ')) {
-      output.plugin('screenshotOnFail', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
-      return;
+      output.plugin(
+        'screenshotOnFail',
+        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
+      )
+      return
     }
-    recorder.add('screenshot of failed test', async () => {
-      let fileName = clearString(test.title);
-      const dataType = 'image/png';
-      // This prevents data driven to be included in the failed screenshot file name
-      if (fileName.indexOf('{') !== -1) {
-        fileName = fileName.substr(0, (fileName.indexOf('{') - 3)).trim();
-      }
-      if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook') fileName = clearString(`${test.title}_${test.ctx.test.title}`);
-      if (options.uniqueScreenshotNames && test) {
-        const uuid = _getUUID(test);
-        fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`;
-      } else {
-        fileName += '.failed.png';
-      }
-      output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot');
-
-      try {
-        if (options.reportDir) {
-          fileName = path.join(options.reportDir, fileName);
-          const mochaReportDir = path.resolve(process.cwd(), options.reportDir);
-          if (!fileExists(mochaReportDir)) {
-            fs.mkdirSync(mochaReportDir);
-          }
+    recorder.add(
+      'screenshot of failed test',
+      async () => {
+        let fileName = clearString(test.title)
+        const dataType = 'image/png'
+        // This prevents data driven to be included in the failed screenshot file name
+        if (fileName.indexOf('{') !== -1) {
+          fileName = fileName.substr(0, fileName.indexOf('{') - 3).trim()
         }
-        await helper.saveScreenshot(fileName, options.fullPageScreenshots);
-
-        if (!test.artifacts) test.artifacts = {};
-        test.artifacts.screenshot = path.join(global.output_dir, fileName);
-        if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {
-          test.attachments = [path.join(global.output_dir, fileName)];
+        if (test.ctx && test.ctx.test && test.ctx.test.type === 'hook')
+          fileName = clearString(`${test.title}_${test.ctx.test.title}`)
+        if (options.uniqueScreenshotNames && test) {
+          const uuid = _getUUID(test)
+          fileName = `${fileName.substring(0, 10)}_${uuid}.failed.png`
+        } else {
+          fileName += '.failed.png'
         }
+        output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
+
+        try {
+          if (options.reportDir) {
+            fileName = path.join(options.reportDir, fileName)
+            const mochaReportDir = path.resolve(process.cwd(), options.reportDir)
+            if (!fileExists(mochaReportDir)) {
+              fs.mkdirSync(mochaReportDir)
+            }
+          }
+          await helper.saveScreenshot(fileName, options.fullPageScreenshots)
+
+          if (!test.artifacts) test.artifacts = {}
+          test.artifacts.screenshot = path.join(global.output_dir, fileName)
+          if (
+            Container.mocha().options.reporterOptions['mocha-junit-reporter'] &&
+            Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments
+          ) {
+            test.attachments = [path.join(global.output_dir, fileName)]
+          }
 
-        const allureReporter = Container.plugins('allure');
-        if (allureReporter) {
-          allureReporter.addAttachment('Main session - Last Seen Screenshot', fs.readFileSync(path.join(global.output_dir, fileName)), dataType);
-
-          if (helper.activeSessionName) {
-            const sessions = helper.sessionPages || helper.sessionWindows;
-            for (const sessionName in sessions) {
-              const screenshotFileName = `${sessionName}_${fileName}`;
-              test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(global.output_dir, screenshotFileName);
-              allureReporter.addAttachment(`${sessionName} - Last Seen Screenshot`, fs.readFileSync(path.join(global.output_dir, screenshotFileName)), dataType);
+          const allureReporter = Container.plugins('allure')
+          if (allureReporter) {
+            allureReporter.addAttachment(
+              'Main session - Last Seen Screenshot',
+              fs.readFileSync(path.join(global.output_dir, fileName)),
+              dataType,
+            )
+
+            if (helper.activeSessionName) {
+              const sessions = helper.sessionPages || helper.sessionWindows
+              for (const sessionName in sessions) {
+                const screenshotFileName = `${sessionName}_${fileName}`
+                test.artifacts[`${sessionName.replace(/ /g, '_')}_screenshot`] = path.join(
+                  global.output_dir,
+                  screenshotFileName,
+                )
+                allureReporter.addAttachment(
+                  `${sessionName} - Last Seen Screenshot`,
+                  fs.readFileSync(path.join(global.output_dir, screenshotFileName)),
+                  dataType,
+                )
+              }
             }
           }
-        }
 
-        const cucumberReporter = Container.plugins('cucumberJsonReporter');
-        if (cucumberReporter) {
-          cucumberReporter.addScreenshot(test.artifacts.screenshot);
-        }
-      } catch (err) {
-        output.plugin(err);
-        if (
-          err
-          && err.type
-          && err.type === 'RuntimeError'
-          && err.message
-          && (
-            err.message.indexOf('was terminated due to') > -1
-            || err.message.indexOf('no such window: target window already closed') > -1
-          )
-        ) {
-          output.log(`Can't make screenshot, ${err}`);
-          helper.isRunning = false;
+          const cucumberReporter = Container.plugins('cucumberJsonReporter')
+          if (cucumberReporter) {
+            cucumberReporter.addScreenshot(test.artifacts.screenshot)
+          }
+        } catch (err) {
+          output.plugin(err)
+          if (
+            err &&
+            err.type &&
+            err.type === 'RuntimeError' &&
+            err.message &&
+            (err.message.indexOf('was terminated due to') > -1 ||
+              err.message.indexOf('no such window: target window already closed') > -1)
+          ) {
+            output.log(`Can't make screenshot, ${err}`)
+            helper.isRunning = false
+          }
         }
-      }
-    }, true);
-  });
+      },
+      true,
+    )
+  })
 
   function _getUUID(test) {
     if (test.uuid) {
-      return test.uuid;
+      return test.uuid
     }
 
     if (test.ctx && test.ctx.test.uuid) {
-      return test.ctx.test.uuid;
+      return test.ctx.test.uuid
     }
 
-    return Math.floor(new Date().getTime() / 1000);
+    return Math.floor(new Date().getTime() / 1000)
   }
-};
+}
diff --git a/lib/plugin/selenoid.js b/lib/plugin/selenoid.js
index 670c9ed7b..1c59e9492 100644
--- a/lib/plugin/selenoid.js
+++ b/lib/plugin/selenoid.js
@@ -1,12 +1,10 @@
-const util = require('util');
-const path = require('path');
-const fs = require('fs');
-const axios = require('axios').default;
-const exec = util.promisify(require('child_process').exec);
-const { clearString, deepMerge } = require('../utils');
-const {
-  container, event, recorder, output,
-} = require('../index');
+const util = require('util')
+const path = require('path')
+const fs = require('fs')
+const axios = require('axios').default
+const exec = util.promisify(require('child_process').exec)
+const { clearString, deepMerge } = require('../utils')
+const { container, event, recorder, output } = require('../index')
 
 const defaultBrowserConfig = {
   chrome: {
@@ -29,7 +27,7 @@ const defaultBrowserConfig = {
       },
     },
   },
-};
+}
 
 const dockerCreateScriptArr = [
   'docker create --rm --name $name$',
@@ -41,29 +39,30 @@ const dockerCreateScriptArr = [
   `-e OVERRIDE_VIDEO_OUTPUT_DIR=${global.output_dir}/video/`,
   '$additionalParams$',
   'aerokube/selenoid:latest-release -log-output-dir /opt/selenoid/logs',
-];
+]
 
 const dockerImageCheckScript = [
   'docker images',
-  '--filter reference=\'selenoid/video-recorder\'',
-  '--filter reference=\'selenoid/chrome:latest\'',
-  '--filter reference=\'selenoid/firefox:latest\'',
-].join(' ');
-
-let dockerCreateScript = dockerCreateScriptArr.join(' ');
-let dockerStartScript = 'docker start $name$';
-let dockerStopScript = 'docker stop $name$';
-let seleniumUrl = 'http://localhost:$port$';
-
-const supportedHelpers = ['WebDriver'];
-const SELENOID_START_TIMEOUT = 2000;
-const SELENOID_STOP_TIMEOUT = 10000;
-const wait = time => new Promise((res) => {
-  setTimeout(() => {
-    // @ts-ignore
-    res();
-  }, time);
-});
+  "--filter reference='selenoid/video-recorder'",
+  "--filter reference='selenoid/chrome:latest'",
+  "--filter reference='selenoid/firefox:latest'",
+].join(' ')
+
+let dockerCreateScript = dockerCreateScriptArr.join(' ')
+let dockerStartScript = 'docker start $name$'
+let dockerStopScript = 'docker stop $name$'
+let seleniumUrl = 'http://localhost:$port$'
+
+const supportedHelpers = ['WebDriver']
+const SELENOID_START_TIMEOUT = 2000
+const SELENOID_STOP_TIMEOUT = 10000
+const wait = (time) =>
+  new Promise((res) => {
+    setTimeout(() => {
+      // @ts-ignore
+      res()
+    }, time)
+  })
 
 /**
  * [Selenoid](https://aerokube.com/selenoid/) plugin automatically starts browsers and video recording.
@@ -181,18 +180,18 @@ const wait = time => new Promise((res) => {
  */
 
 const selenoid = (config) => {
-  const helpers = container.helpers();
-  let helperName;
+  const helpers = container.helpers()
+  let helperName
 
   for (const name of supportedHelpers) {
     if (Object.keys(helpers).indexOf(name) > -1) {
-      helperName = name;
+      helperName = name
     }
   }
 
   if (!helperName) {
-    output.print(`Selenoid plugin supported only for: ${supportedHelpers.toString()}`);
-    return; // no helpers for Selenoid
+    output.print(`Selenoid plugin supported only for: ${supportedHelpers.toString()}`)
+    return // no helpers for Selenoid
   }
 
   const {
@@ -202,169 +201,184 @@ const selenoid = (config) => {
     additionalParams = '',
     autoCreate = true,
     port = 4444,
-  } = config;
-  const passedTests = [];
+  } = config
+  const passedTests = []
 
-  recorder.startUnlessRunning();
-  replaceScriptConfig({ name, additionalParams, port });
+  recorder.startUnlessRunning()
+  replaceScriptConfig({ name, additionalParams, port })
 
   if (autoStart) {
     event.dispatcher.on(event.all.before, () => {
       recorder.add('Starting selenoid', () => {
-        output.debug('Staring Selenoid... ');
+        output.debug('Staring Selenoid... ')
         return createAndStart(autoCreate)
           .then(() => output.debug('Selenoid started'))
-          .catch((err) => { throw new Error(err.stack); });
-      });
-    });
+          .catch((err) => {
+            throw new Error(err.stack)
+          })
+      })
+    })
 
     event.dispatcher.on(event.all.after, () => {
       recorder.add('Stopping selenoid', () => {
-        output.debug('Stopping Selenoid...');
+        output.debug('Stopping Selenoid...')
         return wait(SELENOID_STOP_TIMEOUT)
           .then(() => deletePassedTests(passedTests))
           .then(stopSelenoid)
           .then(() => output.debug('Selenoid stopped'))
-          .catch((err) => { throw new Error(err.stack); });
-      });
-    });
+          .catch((err) => {
+            throw new Error(err.stack)
+          })
+      })
+    })
   }
 
   event.dispatcher.on(event.all.before, () => {
     switch (helperName) {
-      case 'WebDriver': setOptionsForWebdriver(config); break;
+      case 'WebDriver':
+        setOptionsForWebdriver(config)
+        break
     }
-  });
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
     switch (helperName) {
-      case 'WebDriver': setTestConfigForWebdriver(test); break;
+      case 'WebDriver':
+        setTestConfigForWebdriver(test)
+        break
     }
-  });
+  })
 
   if (config.enableVideo) {
     event.dispatcher.on(event.test.passed, (test) => {
       if (deletePassed) {
-        passedTests.push(test.title);
+        passedTests.push(test.title)
       } else {
-        test.artifacts.video = videoSaved(test);
+        test.artifacts.video = videoSaved(test)
       }
-    });
+    })
 
     event.dispatcher.on(event.test.failed, (test) => {
-      test.artifacts.video = videoSaved(test);
-    });
+      test.artifacts.video = videoSaved(test)
+    })
   }
-};
+}
 
-module.exports = selenoid;
+module.exports = selenoid
 
 function videoSaved(test) {
-  const fileName = `${clearString(test.title)}.mp4`;
-  const videoFile = path.join(global.output_dir, 'video', fileName);
-  output.debug(`Video has been saved to file://${videoFile}`);
-  const allureReporter = container.plugins('allure');
+  const fileName = `${clearString(test.title)}.mp4`
+  const videoFile = path.join(global.output_dir, 'video', fileName)
+  output.debug(`Video has been saved to file://${videoFile}`)
+  const allureReporter = container.plugins('allure')
   if (allureReporter) {
-    allureReporter.addAttachment('Video', fs.readFileSync(videoFile), 'video/mp4');
+    allureReporter.addAttachment('Video', fs.readFileSync(videoFile), 'video/mp4')
   }
-  return videoFile;
+  return videoFile
 }
 
 const createSelenoidConfig = () => {
-  const configPath = path.join(global.codecept_dir, 'browsers.json');
+  const configPath = path.join(global.codecept_dir, 'browsers.json')
   return new Promise((res, rej) => {
     try {
       if (fs.existsSync(configPath)) {
-        res(true);
+        res(true)
       } else {
-        const data = new Uint8Array(Buffer.from(JSON.stringify(defaultBrowserConfig)));
-        fs.writeFileSync(configPath, data);
-        res(true);
+        const data = new Uint8Array(Buffer.from(JSON.stringify(defaultBrowserConfig)))
+        fs.writeFileSync(configPath, data)
+        res(true)
       }
     } catch (err) {
-      rej(err.stack);
+      rej(err.stack)
     }
-  });
-};
+  })
+}
 
-const createSelenoid = () => exec(dockerCreateScript);
+const createSelenoid = () => exec(dockerCreateScript)
 
-const startSelenoid = () => exec(dockerStartScript);
+const startSelenoid = () => exec(dockerStartScript)
 
-const stopSelenoid = () => exec(dockerStopScript);
+const stopSelenoid = () => exec(dockerStopScript)
 
-const checkDockerImage = () => exec(dockerImageCheckScript);
+const checkDockerImage = () => exec(dockerImageCheckScript)
 
 const pullImage = async () => {
-  const { stdout } = await checkDockerImage();
-  const pulls = [];
-  let resultPromise;
+  const { stdout } = await checkDockerImage()
+  const pulls = []
+  let resultPromise
 
-  output.print('Pulling in Selenoid containers. This may take a while when running the first time...');
+  output.print('Pulling in Selenoid containers. This may take a while when running the first time...')
 
-  console.time('Pulled containers');
+  console.time('Pulled containers')
   if (!stdout.includes('selenoid/video-recorder')) {
-    output.debug('Pulling selenoid/video-recorder...');
-    resultPromise = exec('docker pull selenoid/video-recorder:latest-release')
-      .then(() => output.debug('Pulled in selenoid/video-recorder'));
-    pulls.push(resultPromise);
+    output.debug('Pulling selenoid/video-recorder...')
+    resultPromise = exec('docker pull selenoid/video-recorder:latest-release').then(() =>
+      output.debug('Pulled in selenoid/video-recorder'),
+    )
+    pulls.push(resultPromise)
   }
   if (!stdout.includes('selenoid/chrome')) {
-    output.debug('Pulling selenoid/chrome...');
-    resultPromise = exec('docker pull selenoid/chrome:latest')
-      .then(() => output.debug('Pulled in selenoid/video-recorder'));
-    pulls.push(resultPromise);
+    output.debug('Pulling selenoid/chrome...')
+    resultPromise = exec('docker pull selenoid/chrome:latest').then(() =>
+      output.debug('Pulled in selenoid/video-recorder'),
+    )
+    pulls.push(resultPromise)
   }
   if (!stdout.includes('selenoid/firefox')) {
-    output.debug('Pulling selenoid/firefox...');
-    resultPromise = exec('docker pull selenoid/firefox:latest')
-      .then(() => output.debug('Pulled in selenoid/chrome'));
-    pulls.push(resultPromise);
+    output.debug('Pulling selenoid/firefox...')
+    resultPromise = exec('docker pull selenoid/firefox:latest').then(() => output.debug('Pulled in selenoid/chrome'))
+    pulls.push(resultPromise)
   }
 
   return Promise.all(pulls).then(() => {
-    console.timeEnd('Pulled containers');
-  });
-};
+    console.timeEnd('Pulled containers')
+  })
+}
 
 function createAndStart(autoCreate) {
-  const selenoidCreated = autoCreate ? createSelenoidConfig().then(createSelenoid).then(pullImage) : Promise.resolve();
-  return selenoidCreated.then(startSelenoid).then(() => wait(SELENOID_START_TIMEOUT));
+  const selenoidCreated = autoCreate ? createSelenoidConfig().then(createSelenoid).then(pullImage) : Promise.resolve()
+  return selenoidCreated.then(startSelenoid).then(() => wait(SELENOID_START_TIMEOUT))
 }
 
 function deletePassedTests(passedTests) {
-  const deleteVideoPromiseList = passedTests.map(clearString).map(test => axios.delete(`${seleniumUrl}/video/${test}.mp4`));
-  const deleteLogPromiseList = passedTests.map(clearString).map(test => axios.delete(`${seleniumUrl}/logs/${test}.log`));
+  const deleteVideoPromiseList = passedTests
+    .map(clearString)
+    .map((test) => axios.delete(`${seleniumUrl}/video/${test}.mp4`))
+  const deleteLogPromiseList = passedTests
+    .map(clearString)
+    .map((test) => axios.delete(`${seleniumUrl}/logs/${test}.log`))
 
   return Promise.all(deleteVideoPromiseList.concat(deleteLogPromiseList))
     .then(() => output.debug('Deleted videos and logs for all passed tests'))
-    .catch(err => output.error(`Error while deleting video and log files ${err.stack}`));
+    .catch((err) => output.error(`Error while deleting video and log files ${err.stack}`))
 }
 
 function setOptionsForWebdriver(config) {
-  const WebDriver = container.helpers('WebDriver');
-  WebDriver._setConfig(deepMerge(WebDriver.options, {
-    capabilities: { 'selenoid:options': config },
-  }));
+  const WebDriver = container.helpers('WebDriver')
+  WebDriver._setConfig(
+    deepMerge(WebDriver.options, {
+      capabilities: { 'selenoid:options': config },
+    }),
+  )
 }
 
 function setTestConfigForWebdriver(test) {
-  const WebDriver = container.helpers('WebDriver');
-  const fileName = clearString(test.title);
-  const { options } = WebDriver;
+  const WebDriver = container.helpers('WebDriver')
+  const fileName = clearString(test.title)
+  const { options } = WebDriver
   recorder.add('setting selenoid capabilities', () => {
-    options.capabilities['selenoid:options'].name = test.title;
-    options.capabilities['selenoid:options'].videoName = `${fileName}.mp4`;
-    options.capabilities['selenoid:options'].logName = `${fileName}.log`;
-    WebDriver._setConfig(options);
-  });
+    options.capabilities['selenoid:options'].name = test.title
+    options.capabilities['selenoid:options'].videoName = `${fileName}.mp4`
+    options.capabilities['selenoid:options'].logName = `${fileName}.log`
+    WebDriver._setConfig(options)
+  })
 }
 
 function replaceScriptConfig(config) {
   for (const key of Object.keys(config)) {
-    dockerCreateScript = dockerCreateScript.replace(new RegExp(`\\$${key}\\$`, 'g'), config[key]);
+    dockerCreateScript = dockerCreateScript.replace(new RegExp(`\\$${key}\\$`, 'g'), config[key])
   }
-  dockerStartScript = dockerStartScript.replace('$name$', config.name);
-  dockerStopScript = dockerStopScript.replace('$name$', config.name);
-  seleniumUrl = seleniumUrl.replace('$port$', config.port);
+  dockerStartScript = dockerStartScript.replace('$name$', config.name)
+  dockerStopScript = dockerStopScript.replace('$name$', config.name)
+  seleniumUrl = seleniumUrl.replace('$port$', config.port)
 }
diff --git a/lib/plugin/standardActingHelpers.js b/lib/plugin/standardActingHelpers.js
index 0deb983d3..536ac6a68 100644
--- a/lib/plugin/standardActingHelpers.js
+++ b/lib/plugin/standardActingHelpers.js
@@ -1,9 +1,3 @@
-const standardActingHelpers = [
-  'Playwright',
-  'WebDriver',
-  'Puppeteer',
-  'Appium',
-  'TestCafe',
-];
+const standardActingHelpers = ['Playwright', 'WebDriver', 'Puppeteer', 'Appium', 'TestCafe']
 
-module.exports = standardActingHelpers;
+module.exports = standardActingHelpers
diff --git a/lib/plugin/stepByStepReport.js b/lib/plugin/stepByStepReport.js
index 9f22dc576..21b96410a 100644
--- a/lib/plugin/stepByStepReport.js
+++ b/lib/plugin/stepByStepReport.js
@@ -1,17 +1,17 @@
-const colors = require('chalk');
-const crypto = require('crypto');
-const figures = require('figures');
-const fs = require('fs');
-const mkdirp = require('mkdirp');
-const path = require('path');
+const colors = require('chalk')
+const crypto = require('crypto')
+const figures = require('figures')
+const fs = require('fs')
+const mkdirp = require('mkdirp')
+const path = require('path')
 
-const Container = require('../container');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
-const { template, deleteDir } = require('../utils');
+const Container = require('../container')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
+const { template, deleteDir } = require('../utils')
 
-const supportedHelpers = require('./standardActingHelpers');
+const supportedHelpers = require('./standardActingHelpers')
 
 const defaultConfig = {
   deleteSuccessful: true,
@@ -21,9 +21,9 @@ const defaultConfig = {
   output: global.output_dir,
   screenshotsForAllureReport: false,
   disableScreenshotOnFail: true,
-};
+}
 
-const templates = {};
+const templates = {}
 
 /**
  * ![step-by-step-report](https://codecept.io/img/codeceptjs-slideshow.gif)
@@ -63,135 +63,151 @@ const templates = {};
  */
 
 module.exports = function (config) {
-  const helpers = Container.helpers();
-  let helper;
+  const helpers = Container.helpers()
+  let helper
 
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   for (const helperName of supportedHelpers) {
     if (Object.keys(helpers).indexOf(helperName) > -1) {
-      helper = helpers[helperName];
+      helper = helpers[helperName]
     }
   }
 
-  if (!helper) return; // no helpers for screenshot
+  if (!helper) return // no helpers for screenshot
 
-  let dir;
-  let stepNum;
-  let slides = {};
-  let error;
-  let savedStep = null;
-  let currentTest = null;
-  let scenarioFailed = false;
+  let dir
+  let stepNum
+  let slides = {}
+  let error
+  let savedStep = null
+  let currentTest = null
+  let scenarioFailed = false
 
-  const recordedTests = {};
-  const pad = '0000';
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output;
+  const recordedTests = {}
+  const pad = '0000'
+  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+
+  event.dispatcher.on(event.suite.before, (suite) => {
+    stepNum = -1
+  })
 
   event.dispatcher.on(event.test.before, (test) => {
-    const sha256hash = crypto.createHash('sha256').update(test.file + test.title).digest('hex');
-    dir = path.join(reportDir, `record_${sha256hash}`);
-    mkdirp.sync(dir);
-    stepNum = 0;
-    error = null;
-    slides = {};
-    savedStep = null;
-    currentTest = test;
-  });
+    const sha256hash = crypto
+      .createHash('sha256')
+      .update(test.file + test.title)
+      .digest('hex')
+    dir = path.join(reportDir, `record_${sha256hash}`)
+    mkdirp.sync(dir)
+    stepNum = 0
+    error = null
+    slides = {}
+    savedStep = null
+    currentTest = test
+  })
 
   event.dispatcher.on(event.step.failed, (step) => {
-    recorder.add('screenshot of failed test', async () => persistStep(step), true);
-  });
+    recorder.add('screenshot of failed test', async () => persistStep(step), true)
+  })
 
-  event.dispatcher.on(event.step.after, persistStep);
+  event.dispatcher.on(event.step.after, (step) => {
+    recorder.add('screenshot of step of test', async () => persistStep(step), true)
+  })
 
   event.dispatcher.on(event.test.passed, (test) => {
-    if (!config.deleteSuccessful) return persist(test);
+    if (!config.deleteSuccessful) return persist(test)
     // cleanup
-    deleteDir(dir);
-  });
+    deleteDir(dir)
+  })
 
   event.dispatcher.on(event.test.failed, (test, err) => {
     if (test.ctx._runnable.title.includes('hook: ')) {
-      output.plugin('stepByStepReport', 'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.');
-      return;
+      output.plugin(
+        'stepByStepReport',
+        'BeforeSuite/AfterSuite do not have any access to the browser, hence it could not take screenshot.',
+      )
+      return
     }
-    persist(test, err);
-  });
+    persist(test, err)
+  })
 
   event.dispatcher.on(event.all.result, () => {
-    if (Object.keys(recordedTests).length === 0 || !Object.keys(slides).length) return;
+    if (Object.keys(recordedTests).length === 0 || !Object.keys(slides).length) return
 
-    let links = '';
+    let links = ''
 
     for (const link in recordedTests) {
-      links += `<li><a href="${recordedTests[link]}">${link}</a></li>\n`;
+      links += `<li><a href="${recordedTests[link]}">${link}</a></li>\n`
     }
 
     const indexHTML = template(templates.index, {
       time: Date().toString(),
       records: links,
-    });
+    })
 
-    fs.writeFileSync(path.join(reportDir, 'records.html'), indexHTML);
+    fs.writeFileSync(path.join(reportDir, 'records.html'), indexHTML)
 
-    output.print(`${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`);
-  });
+    output.print(
+      `${figures.circleFilled} Step-by-step preview: ${colors.white.bold(`file://${reportDir}/records.html`)}`,
+    )
+  })
 
   async function persistStep(step) {
-    if (isStepIgnored(step)) return;
-    if (savedStep === step) return; // already saved
+    if (stepNum === -1) return // Ignore steps from BeforeSuite function
+    if (isStepIgnored(step)) return
+    if (savedStep === step) return // already saved
     // Ignore steps from BeforeSuite function
-    if (scenarioFailed && config.disableScreenshotOnFail) return;
-    if (step.metaStep && step.metaStep.name === 'BeforeSuite') return;
+    if (scenarioFailed && config.disableScreenshotOnFail) return
+    if (step.metaStep && step.metaStep.name === 'BeforeSuite') return
+    if (!step.test) return // Ignore steps from AfterSuite
 
-    const fileName = `${pad.substring(0, pad.length - stepNum.toString().length) + stepNum.toString()}.png`;
+    const fileName = `${pad.substring(0, pad.length - stepNum.toString().length) + stepNum.toString()}.png`
     if (step.status === 'failed') {
-      scenarioFailed = true;
+      scenarioFailed = true
     }
-    stepNum++;
-    slides[fileName] = step;
+    stepNum++
+    slides[fileName] = step
     try {
-      await helper.saveScreenshot(path.join(dir, fileName), config.fullPageScreenshots);
+      await helper.saveScreenshot(path.join(dir, fileName), config.fullPageScreenshots)
     } catch (err) {
-      output.plugin(`Can't save step screenshot: ${err}`);
-      error = err;
-      return;
+      output.plugin(`Can't save step screenshot: ${err}`)
+      error = err
+      return
     } finally {
-      savedStep = step;
+      savedStep = step
     }
 
-    if (!currentTest.artifacts.screenshots) currentTest.artifacts.screenshots = [];
+    if (!currentTest.artifacts.screenshots) currentTest.artifacts.screenshots = []
     // added attachments to test
-    currentTest.artifacts.screenshots.push(path.join(dir, fileName));
+    currentTest.artifacts.screenshots.push(path.join(dir, fileName))
 
-    const allureReporter = Container.plugins('allure');
+    const allureReporter = Container.plugins('allure')
     if (allureReporter && config.screenshotsForAllureReport) {
-      output.plugin('stepByStepReport', 'Adding screenshot to Allure');
-      allureReporter.addAttachment(`Screenshot of step ${step}`, fs.readFileSync(path.join(dir, fileName)), 'image/png');
+      output.plugin('stepByStepReport', 'Adding screenshot to Allure')
+      allureReporter.addAttachment(`Screenshot of step ${step}`, fs.readFileSync(path.join(dir, fileName)), 'image/png')
     }
   }
 
   function persist(test) {
-    if (error) return;
+    if (error) return
 
-    let indicatorHtml = '';
-    let slideHtml = '';
+    let indicatorHtml = ''
+    let slideHtml = ''
 
     for (const i in slides) {
-      const step = slides[i];
-      const stepNum = parseInt(i, 10);
+      const step = slides[i]
+      const stepNum = parseInt(i, 10)
       indicatorHtml += template(templates.indicator, {
         step: stepNum,
         isActive: stepNum ? '' : 'class="active"',
-      });
+      })
 
       slideHtml += template(templates.slides, {
         image: i,
         caption: step.toString().replace(/\[\d{2}m/g, ''), // remove ANSI escape sequence
         isActive: stepNum ? '' : 'active',
         isError: step.status === 'failed' ? 'error' : '',
-      });
+      })
     }
 
     const html = template(templates.global, {
@@ -200,21 +216,21 @@ module.exports = function (config) {
       feature: test.parent && test.parent.title,
       test: test.title,
       carousel_class: config.animateSlides ? ' slide' : '',
-    });
+    })
 
-    const index = path.join(dir, 'index.html');
-    fs.writeFileSync(index, html);
-    recordedTests[`${test.parent.title}: ${test.title}`] = path.relative(reportDir, index);
+    const index = path.join(dir, 'index.html')
+    fs.writeFileSync(index, html)
+    recordedTests[`${test.parent.title}: ${test.title}`] = path.relative(reportDir, index)
   }
 
   function isStepIgnored(step) {
-    if (!config.ignoreSteps) return;
+    if (!config.ignoreSteps) return
     for (const pattern of config.ignoreSteps || []) {
-      if (step.name.match(pattern)) return true;
+      if (step.name.match(pattern)) return true
     }
-    return false;
+    return false
   }
-};
+}
 
 templates.slides = `
 <div class="item {{isActive}}">
@@ -226,11 +242,11 @@ templates.slides = `
         <small>scroll up and down to see the full page</small>
     </div>
 </div>
-`;
+`
 
 templates.indicator = `
 <li data-target="#steps" data-slide-to="{{step}}" {{isActive}}></li>
-`;
+`
 
 templates.index = `
 <!DOCTYPE html>
@@ -259,7 +275,7 @@ templates.index = `
 
 </body>
 </html>
-`;
+`
 
 templates.global = `
 <!DOCTYPE html>
@@ -369,4 +385,4 @@ templates.global = `
 </body>
 
 </html>
-`;
+`
diff --git a/lib/plugin/stepTimeout.js b/lib/plugin/stepTimeout.js
index 1a586e691..f6c01416a 100644
--- a/lib/plugin/stepTimeout.js
+++ b/lib/plugin/stepTimeout.js
@@ -1,15 +1,12 @@
-const event = require('../event');
-const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER;
+const event = require('../event')
+const TIMEOUT_ORDER = require('../step').TIMEOUT_ORDER
 
 const defaultConfig = {
   timeout: 150,
   overrideStepLimits: false,
-  noTimeoutSteps: [
-    'amOnPage',
-    'wait*',
-  ],
+  noTimeoutSteps: ['amOnPage', 'wait*'],
   customTimeoutSteps: [],
-};
+}
 
 /**
  * Set timeout for test steps globally.
@@ -65,27 +62,31 @@ const defaultConfig = {
  *
  */
 module.exports = (config) => {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
   // below override rule makes sure customTimeoutSteps go first but then they override noTimeoutSteps in case of exact pattern match
-  config.customTimeoutSteps = config.customTimeoutSteps.concat(config.noTimeoutSteps).concat(config.customTimeoutSteps);
+  config.customTimeoutSteps = config.customTimeoutSteps.concat(config.noTimeoutSteps).concat(config.customTimeoutSteps)
 
   event.dispatcher.on(event.step.before, (step) => {
-    let stepTimeout;
+    let stepTimeout
     for (let stepRule of config.customTimeoutSteps) {
-      let customTimeout = 0;
+      let customTimeout = 0
       if (Array.isArray(stepRule)) {
-        if (stepRule.length > 1) customTimeout = stepRule[1];
-        stepRule = stepRule[0];
+        if (stepRule.length > 1) customTimeout = stepRule[1]
+        stepRule = stepRule[0]
       }
-      if (stepRule instanceof RegExp
-        ? step.name.match(stepRule)
-        : (step.name === stepRule || stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))
+      if (
+        stepRule instanceof RegExp
+          ? step.name.match(stepRule)
+          : step.name === stepRule || (stepRule.indexOf('*') && step.name.startsWith(stepRule.slice(0, -1)))
       ) {
-        stepTimeout = customTimeout;
-        break;
+        stepTimeout = customTimeout
+        break
       }
     }
-    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout;
-    step.setTimeout(stepTimeout * 1000, config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft);
-  });
-};
+    stepTimeout = stepTimeout === undefined ? config.timeout : stepTimeout
+    step.setTimeout(
+      stepTimeout * 1000,
+      config.overrideStepLimits ? TIMEOUT_ORDER.stepTimeoutHard : TIMEOUT_ORDER.stepTimeoutSoft,
+    )
+  })
+}
diff --git a/lib/plugin/subtitles.js b/lib/plugin/subtitles.js
index 261aeb416..b78dd3192 100644
--- a/lib/plugin/subtitles.js
+++ b/lib/plugin/subtitles.js
@@ -1,21 +1,21 @@
-const { v4: uuidv4 } = require('uuid');
-const fsPromise = require('fs').promises;
-const path = require('path');
-const event = require('../event');
+const { v4: uuidv4 } = require('uuid')
+const fsPromise = require('fs').promises
+const path = require('path')
+const event = require('../event')
 
 // This will convert a given timestamp in milliseconds to
 // an SRT recognized timestamp, ie HH:mm:ss,SSS
 function formatTimestamp(timestampInMs) {
-  const date = new Date(0, 0, 0, 0, 0, 0, timestampInMs);
-  const hours = date.getHours();
-  const minutes = date.getMinutes();
-  const seconds = date.getSeconds();
-  const ms = timestampInMs - (hours * 3600000 + minutes * 60000 + seconds * 1000);
-  return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
+  const date = new Date(0, 0, 0, 0, 0, 0, timestampInMs)
+  const hours = date.getHours()
+  const minutes = date.getMinutes()
+  const seconds = date.getSeconds()
+  const ms = timestampInMs - (hours * 3600000 + minutes * 60000 + seconds * 1000)
+  return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`
 }
 
-let steps = {};
-let testStartedAt;
+let steps = {}
+let testStartedAt
 /**
  * Automatically captures steps as subtitle, and saves it as an artifact when a video is found for a failed test
  *
@@ -30,40 +30,40 @@ let testStartedAt;
  */
 module.exports = function () {
   event.dispatcher.on(event.test.before, (_) => {
-    testStartedAt = Date.now();
-    steps = {};
-  });
+    testStartedAt = Date.now()
+    steps = {}
+  })
 
   event.dispatcher.on(event.step.started, (step) => {
-    const stepStartedAt = Date.now();
-    step.id = uuidv4();
+    const stepStartedAt = Date.now()
+    step.id = uuidv4()
 
-    let title = `${step.actor}.${step.name}(${step.args ? step.args.join(',') : ''})`;
+    let title = `${step.actor}.${step.name}(${step.args ? step.args.join(',') : ''})`
     if (title.length > 100) {
-      title = `${title.substring(0, 100)}...`;
+      title = `${title.substring(0, 100)}...`
     }
 
     steps[step.id] = {
       start: formatTimestamp(stepStartedAt - testStartedAt),
       startedAt: stepStartedAt,
       title,
-    };
-  });
+    }
+  })
 
   event.dispatcher.on(event.step.finished, (step) => {
     if (step && step.id && steps[step.id]) {
-      steps[step.id].end = formatTimestamp(Date.now() - testStartedAt);
+      steps[step.id].end = formatTimestamp(Date.now() - testStartedAt)
     }
-  });
+  })
 
   event.dispatcher.on(event.test.after, async (test) => {
     if (test && test.artifacts && test.artifacts.video) {
-      const stepsSortedByStartTime = Object.values(steps);
+      const stepsSortedByStartTime = Object.values(steps)
       stepsSortedByStartTime.sort((stepA, stepB) => {
-        return stepA.startedAt - stepB.startedAt;
-      });
+        return stepA.startedAt - stepB.startedAt
+      })
 
-      let subtitle = '';
+      let subtitle = ''
 
       // For an SRT file, every subtitle has to be in the format as mentioned below:
       //
@@ -76,13 +76,13 @@ module.exports = function () {
 ${step.start} --> ${step.end}
 ${step.title}
 
-`;
+`
         }
-      });
+      })
 
-      const { dir: artifactsDirectory, name: fileName } = path.parse(test.artifacts.video);
-      await fsPromise.writeFile(`${artifactsDirectory}/${fileName}.srt`, subtitle);
-      test.artifacts.subtitle = `${artifactsDirectory}/${fileName}.srt`;
+      const { dir: artifactsDirectory, name: fileName } = path.parse(test.artifacts.video)
+      await fsPromise.writeFile(`${artifactsDirectory}/${fileName}.srt`, subtitle)
+      test.artifacts.subtitle = `${artifactsDirectory}/${fileName}.srt`
     }
-  });
-};
+  })
+}
diff --git a/lib/plugin/tryTo.js b/lib/plugin/tryTo.js
index a793b7b6f..8114babbd 100644
--- a/lib/plugin/tryTo.js
+++ b/lib/plugin/tryTo.js
@@ -1,9 +1,9 @@
-const recorder = require('../recorder');
-const { debug } = require('../output');
+const recorder = require('../recorder')
+const { debug } = require('../output')
 
 const defaultConfig = {
   registerGlobal: true,
-};
+}
 
 /**
  *
@@ -71,35 +71,45 @@ const defaultConfig = {
  *
  */
 module.exports = function (config) {
-  config = Object.assign(defaultConfig, config);
+  config = Object.assign(defaultConfig, config)
 
   if (config.registerGlobal) {
-    global.tryTo = tryTo;
+    global.tryTo = tryTo
   }
-  return tryTo;
-};
+  return tryTo
+}
 
 function tryTo(callback) {
-  let result = false;
-  return recorder.add('tryTo', () => {
-    recorder.session.start('tryTo');
-    process.env.TRY_TO = 'true';
-    callback();
-    recorder.add(() => {
-      result = true;
-      recorder.session.restore('tryTo');
-      return result;
-    });
-    recorder.session.catch((err) => {
-      result = false;
-      const msg = err.inspect ? err.inspect() : err.toString();
-      debug(`Unsuccessful try > ${msg}`);
-      recorder.session.restore('tryTo');
-      return result;
-    });
-    return recorder.add('result', () => {
-      process.env.TRY_TO = undefined;
-      return result;
-    }, true, false);
-  }, false, false);
+  let result = false
+  return recorder.add(
+    'tryTo',
+    () => {
+      recorder.session.start('tryTo')
+      process.env.TRY_TO = 'true'
+      callback()
+      recorder.add(() => {
+        result = true
+        recorder.session.restore('tryTo')
+        return result
+      })
+      recorder.session.catch((err) => {
+        result = false
+        const msg = err.inspect ? err.inspect() : err.toString()
+        debug(`Unsuccessful try > ${msg}`)
+        recorder.session.restore('tryTo')
+        return result
+      })
+      return recorder.add(
+        'result',
+        () => {
+          process.env.TRY_TO = undefined
+          return result
+        },
+        true,
+        false,
+      )
+    },
+    false,
+    false,
+  )
 }
diff --git a/lib/plugin/wdio.js b/lib/plugin/wdio.js
index 4c37bb539..4ebf57fde 100644
--- a/lib/plugin/wdio.js
+++ b/lib/plugin/wdio.js
@@ -1,17 +1,17 @@
-const debug = require('debug')('codeceptjs:plugin:wdio');
+const debug = require('debug')('codeceptjs:plugin:wdio')
 
-const container = require('../container');
-const mainConfig = require('../config');
-const recorder = require('../recorder');
-const event = require('../event');
-const output = require('../output');
+const container = require('../container')
+const mainConfig = require('../config')
+const recorder = require('../recorder')
+const event = require('../event')
+const output = require('../output')
 
 const defaultConfig = {
   services: [],
   capabilities: {},
-};
+}
 
-let restartsSession;
+let restartsSession
 
 /**
  * Webdriverio services runner.
@@ -83,162 +83,167 @@ let restartsSession;
  */
 module.exports = (config) => {
   // Keep initial configs to pass as options to wdio services
-  const wdioOptions = { ...config };
-  const webDriver = container.helpers('WebDriver');
+  const wdioOptions = { ...config }
+  const webDriver = container.helpers('WebDriver')
   if (webDriver) {
-    config = Object.assign(webDriver.options, config);
-    restartsSession = !!config.restart;
+    config = Object.assign(webDriver.options, config)
+    restartsSession = !!config.restart
   }
-  config = Object.assign(defaultConfig, config);
-  const seleniumInstallArgs = { ...config.seleniumInstallArgs };
-  const seleniumArgs = { ...config.seleniumArgs };
+  config = Object.assign(defaultConfig, config)
+  const seleniumInstallArgs = { ...config.seleniumInstallArgs }
+  const seleniumArgs = { ...config.seleniumArgs }
 
-  const services = [];
-  const launchers = [];
+  const services = []
+  const launchers = []
 
   for (const name of config.services) {
-    const Service = safeRequire(`@wdio/${name.toLowerCase()}-service`);
+    const Service = safeRequire(`@wdio/${name.toLowerCase()}-service`)
     if (Service) {
       if (Service.launcher && typeof Service.launcher === 'function') {
-        const Launcher = Service.launcher;
+        const Launcher = Service.launcher
 
         const options = {
-          logPath: global.output_dir, installArgs: seleniumInstallArgs, args: seleniumArgs, ...wdioOptions,
-        };
-        launchers.push(new Launcher(options, [config.capabilities], config));
+          logPath: global.output_dir,
+          installArgs: seleniumInstallArgs,
+          args: seleniumArgs,
+          ...wdioOptions,
+        }
+        launchers.push(new Launcher(options, [config.capabilities], config))
       }
       if (typeof Service === 'function') {
-        services.push(new Service(config, config.capabilities));
+        services.push(new Service(config, config.capabilities))
       }
-      continue;
+      continue
     }
 
-    throw new Error(`Couldn't initialize service ${name} from wdio plugin config.\nIt should be available either in '@wdio/${name.toLowerCase()}-service' package`);
+    throw new Error(
+      `Couldn't initialize service ${name} from wdio plugin config.\nIt should be available either in '@wdio/${name.toLowerCase()}-service' package`,
+    )
   }
 
-  debug(`services ${services}, launchers ${launchers}`);
+  debug(`services ${services}, launchers ${launchers}`)
 
-  recorder.startUnlessRunning();
+  recorder.startUnlessRunning()
 
   for (const launcher of launchers) {
-    registerLauncher(launcher);
+    registerLauncher(launcher)
   }
 
   for (const service of services) {
-    registerService(service);
+    registerService(service)
   }
 
   function registerService(service) {
-    const name = service.constructor.name;
+    const name = service.constructor.name
     if (service.beforeSession) {
       event.dispatcher.on(event.all.before, () => {
         recorder.add(`service ${name} all.before`, async () => {
-          await service.beforeSession(config, config.capabilities);
-        });
-      });
+          await service.beforeSession(config, config.capabilities)
+        })
+      })
     }
 
     if (service.afterSession) {
       event.dispatcher.on(event.all.result, (result) => {
         recorder.add(`service ${name} all.after`, async () => {
-          await service.afterSession(result);
-        });
-      });
+          await service.afterSession(result)
+        })
+      })
     }
 
     if (service.beforeSuite) {
       event.dispatcher.on(event.suite.before, (suite) => {
-        debug(`suite started: ${suite.title}`);
-        recorder.add(`service ${name} suite.before`, () => service.beforeSuite(suite));
-      });
+        debug(`suite started: ${suite.title}`)
+        recorder.add(`service ${name} suite.before`, () => service.beforeSuite(suite))
+      })
     }
 
     if (service.afterSuite) {
       event.dispatcher.on(event.suite.after, (suite) => {
-        debug(`suite finished: ${suite.title}`);
-        recorder.add(`service ${name} suite.after`, () => service.afterSuite(suite));
-      });
+        debug(`suite finished: ${suite.title}`)
+        recorder.add(`service ${name} suite.after`, () => service.afterSuite(suite))
+      })
     }
 
     if (service.beforeTest) {
       event.dispatcher.on(event.test.started, async (test) => {
         if (test.parent) {
-          test.parent.toString = () => test.parent.title;
+          test.parent.toString = () => test.parent.title
         }
         // test.parent = test.parent ? test.parent.title : null;
-        debug(`test started: ${test.title}`);
+        debug(`test started: ${test.title}`)
         if (webDriver) {
-          global.browser = webDriver.browser;
-          global.browser.config = Object.assign(mainConfig.get('test', 1), global.browser.config);
+          global.browser = webDriver.browser
+          global.browser.config = Object.assign(mainConfig.get('test', 1), global.browser.config)
         }
-        await service.beforeTest(test);
-      });
+        await service.beforeTest(test)
+      })
     }
 
     if (service.afterTest) {
       event.dispatcher.on(event.test.finished, async (test) => {
-        debug(`test finished: ${test.title}`);
-        await service.afterTest(test);
-      });
+        debug(`test finished: ${test.title}`)
+        await service.afterTest(test)
+      })
     }
 
     if (restartsSession && service.before) {
-      event.dispatcher.on(event.test.started, () => service.before());
+      event.dispatcher.on(event.test.started, () => service.before())
     }
 
     if (restartsSession && service.after) {
-      event.dispatcher.on(event.test.finished, () => service.after());
+      event.dispatcher.on(event.test.finished, () => service.after())
     }
 
     if (!restartsSession && service.before) {
-      let initializedBrowser = false;
+      let initializedBrowser = false
       event.dispatcher.on(event.test.started, async () => {
         if (!initializedBrowser) {
-          await service.before();
-          initializedBrowser = true;
+          await service.before()
+          initializedBrowser = true
         }
-      });
+      })
     }
 
     if (!restartsSession && service.after) {
-      event.dispatcher.on(event.all.result, result => service.after(result));
+      event.dispatcher.on(event.all.result, (result) => service.after(result))
     }
   }
 
   function registerLauncher(launcher) {
-    const name = launcher.constructor.name;
+    const name = launcher.constructor.name
     if (launcher.onPrepare) {
       event.dispatcher.on(event.all.before, () => {
         recorder.add(`launcher ${name} start`, async () => {
           // browserstack-service expects capabilities as array
           if (launcher.constructor.name === 'BrowserstackLauncherService') {
-            await launcher.onPrepare(config, [config.capabilities]);
+            await launcher.onPrepare(config, [config.capabilities])
           } else {
-            await launcher.onPrepare(config, config.capabilities);
+            await launcher.onPrepare(config, config.capabilities)
           }
-          output.debug(`Started ${name}`);
-        });
-      });
+          output.debug(`Started ${name}`)
+        })
+      })
     }
 
     if (launcher.onComplete) {
       event.dispatcher.on(event.all.after, () => {
         recorder.add(`launcher ${name} start`, async () => {
-          await launcher.onComplete(process.exitCode, config, config.capabilities);
-          output.debug(`Stopped ${name}`);
-        });
-      });
+          await launcher.onComplete(process.exitCode, config, config.capabilities)
+          output.debug(`Stopped ${name}`)
+        })
+      })
     }
   }
-};
+}
 
 function safeRequire(name) {
   try {
-    return require(name);
+    return require(name)
   } catch (e) {
     if (!e.message.match(`Cannot find module '${name}'`)) {
-      throw new Error(`Couldn't initialise "${name}".\n${e.stack}`);
+      throw new Error(`Couldn't initialise "${name}".\n${e.stack}`)
     }
-    return null;
+    return null
   }
 }
diff --git a/lib/template/heal.js b/lib/template/heal.js
index 69edf12ff..a893de9ea 100644
--- a/lib/template/heal.js
+++ b/lib/template/heal.js
@@ -1,4 +1,4 @@
-const { heal, ai } = require('codeceptjs');
+const { heal, ai } = require('codeceptjs')
 
 heal.addRecipe('ai', {
   priority: 10,
@@ -16,24 +16,21 @@ heal.addRecipe('ai', {
     'doubleClick',
   ],
   fn: async (args) => {
-    return ai.healFailedStep(args);
+    return ai.healFailedStep(args)
   },
-});
+})
 
 heal.addRecipe('clickAndType', {
   priority: 1,
-  steps: [
-    'fillField',
-    'appendField',
-  ],
+  steps: ['fillField', 'appendField'],
   fn: async ({ step }) => {
-    const locator = step.args[0];
-    const text = step.args[1];
+    const locator = step.args[0]
+    const text = step.args[1]
 
     return ({ I }) => {
-      I.click(locator);
-      I.wait(1); // to open modal or something
-      I.type(text);
-    };
+      I.click(locator)
+      I.wait(1) // to open modal or something
+      I.type(text)
+    }
   },
-});
+})
diff --git a/package.json b/package.json
index fe9206117..f032bd87a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.6.4",
+  "version": "3.6.5",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -39,6 +39,7 @@
     "json-server:graphql": "node test/data/graphql/index.js",
     "lint": "eslint bin/ examples/ lib/ test/ translations/ runok.js",
     "lint-fix": "eslint bin/ examples/ lib/ test/ translations/ runok.js --fix",
+    "prettier": "prettier --config prettier.config.js --write bin/**/*.js lib/**/*.js test/**/*.js translations/**/*.js runok.js",
     "docs": "./runok.js docs",
     "test:unit": "mocha test/unit --recursive --timeout 10000",
     "test:runner": "mocha test/runner --recursive --timeout 10000",
@@ -74,7 +75,7 @@
     "@cucumber/gherkin": "26",
     "@cucumber/messages": "25.0.1",
     "@xmldom/xmldom": "0.8.10",
-    "acorn": "8.11.3",
+    "acorn": "8.12.1",
     "arrify": "2.0.1",
     "axios": "1.7.2",
     "chai": "5.1.1",
@@ -89,7 +90,7 @@
     "cross-spawn": "7.0.3",
     "css-to-xpath": "0.1.0",
     "csstoxpath": "1.6.0",
-    "devtools": "8.38.2",
+    "devtools": "8.39.1",
     "envinfo": "7.11.1",
     "escape-string-regexp": "4.0.0",
     "figures": "3.2.0",
@@ -98,13 +99,13 @@
     "glob": "6.0.1",
     "html-minifier-terser": "7.2.0",
     "inquirer": "6.5.2",
-    "joi": "17.13.1",
+    "joi": "17.13.3",
     "js-beautify": "1.15.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.merge": "4.6.2",
     "mkdirp": "1.0.4",
-    "mocha": "10.4.0",
-    "monocart-coverage-reports": "2.8.3",
+    "mocha": "10.6.0",
+    "monocart-coverage-reports": "2.10.0",
     "ms": "2.1.3",
     "ora-classic": "5.4.2",
     "pactum": "3.6.9",
@@ -116,17 +117,17 @@
     "uuid": "9.0"
   },
   "optionalDependencies": {
-    "@codeceptjs/detox-helper": "1.0.7"
+    "@codeceptjs/detox-helper": "1.0.8"
   },
   "devDependencies": {
     "@codeceptjs/mock-request": "0.3.1",
     "@faker-js/faker": "7.6.0",
     "@pollyjs/adapter-puppeteer": "6.0.6",
     "@pollyjs/core": "5.1.0",
-    "@types/chai": "4.3.12",
+    "@types/chai": "4.3.16",
     "@types/inquirer": "9.0.3",
     "@types/node": "20.11.30",
-    "@wdio/sauce-service": "8.35.1",
+    "@wdio/sauce-service": "8.39.1",
     "@wdio/selenium-standalone-service": "8.3.2",
     "@wdio/utils": "8.38.2",
     "@xmldom/xmldom": "0.8.10",
@@ -135,36 +136,37 @@
     "chai-subset": "1.6.0",
     "contributor-faces": "1.1.0",
     "documentation": "12.3.0",
-    "electron": "30.1.0",
+    "electron": "31.3.0",
     "eslint": "8.57.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-plugin-import": "2.29.1",
     "eslint-plugin-mocha": "10.4.3",
     "expect": "29.7.0",
     "express": "4.19.2",
-    "graphql": "14.6.0",
-    "husky": "8.0.3",
+    "graphql": "16.9.0",
+    "husky": "9.1.1",
     "inquirer-test": "2.0.1",
     "jsdoc": "4.0.3",
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.10.1",
-    "playwright": "1.44.1",
-    "puppeteer": "22.10.0",
+    "playwright": "1.45.3",
+    "prettier": "^3.3.2",
+    "puppeteer": "22.12.1",
     "qrcode-terminal": "0.12.0",
     "rosie": "2.1.1",
     "runok": "0.9.3",
     "sinon": "18.0.0",
     "sinon-chai": "3.7.0",
     "testcafe": "3.5.0",
-    "ts-morph": "21.0.1",
+    "ts-morph": "23.0.0",
     "ts-node": "10.9.2",
     "tsd": "^0.31.0",
     "tsd-jsdoc": "2.5.0",
-    "typedoc": "0.25.13",
-    "typedoc-plugin-markdown": "4.0.3",
-    "typescript": "5.4.5",
+    "typedoc": "0.26.5",
+    "typedoc-plugin-markdown": "4.2.1",
+    "typescript": "5.5.3",
     "wdio-docker-service": "1.5.0",
-    "webdriverio": "8.38.2",
+    "webdriverio": "8.39.1",
     "xml2js": "0.6.2",
     "xpath": "0.0.34"
   },
@@ -179,4 +181,4 @@
       "strict": false
     }
   }
-}
\ No newline at end of file
+}
diff --git a/prettier.config.js b/prettier.config.js
new file mode 100644
index 000000000..3b217498d
--- /dev/null
+++ b/prettier.config.js
@@ -0,0 +1,9 @@
+module.exports = {
+  printWidth: 120,
+  tabWidth: 2,
+  useTabs: false,
+  semi: false,
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSameLine: false,
+};
diff --git a/runok.js b/runok.js
index 582bb4987..2e09ef3e7 100755
--- a/runok.js
+++ b/runok.js
@@ -1,73 +1,66 @@
 #!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const axios = require('axios');
-const documentation = require('documentation');
+const fs = require('fs')
+const path = require('path')
+const axios = require('axios')
+const documentation = require('documentation')
 const {
-  stopOnFail, chdir, tasks: {
-    git, copy, exec, replaceInFile, npmRun, npx, writeToFile,
-  }, runok,
-} = require('runok');
-const contributors = require('contributor-faces');
+  stopOnFail,
+  chdir,
+  tasks: { git, copy, exec, replaceInFile, npmRun, npx, writeToFile },
+  runok,
+} = require('runok')
+const contributors = require('contributor-faces')
 
 const helperMarkDownFile = function (name) {
-  return `docs/helpers/${name}.md`;
-};
-const documentjsCliArgs = '-f md --shallow --markdown-toc=false --sort-order=alpha';
+  return `docs/helpers/${name}.md`
+}
+const documentjsCliArgs = '-f md --shallow --markdown-toc=false --sort-order=alpha'
 
-stopOnFail();
+stopOnFail()
 
 module.exports = {
   async docs() {
     // generate all docs (runs all docs:* commands in parallel)
-    await Promise.all([
-      this.docsHelpers(),
-      this.docsPlugins(),
-      this.docsExternalHelpers(),
-    ]);
+    await Promise.all([this.docsHelpers(), this.docsPlugins(), this.docsExternalHelpers()])
   },
 
   async def() {
-    await Promise.all([
-      this.buildLibWithDocs(true),
-      this.docsPlugins(),
-      this.docsExternalHelpers(),
-    ]);
-    await this.defTypings();
+    await Promise.all([this.buildLibWithDocs(true), this.docsPlugins(), this.docsExternalHelpers()])
+    await this.defTypings()
   },
 
   async defTypings() {
-    console.log('Generate TypeScript definition');
+    console.log('Generate TypeScript definition')
     // Generate definitions for promised-based helper methods
-    await npx('jsdoc -c typings/jsdocPromiseBased.conf.js');
-    fs.renameSync('typings/types.d.ts', 'typings/promiseBasedTypes.d.ts');
+    await npx('jsdoc -c typings/jsdocPromiseBased.conf.js')
+    fs.renameSync('typings/types.d.ts', 'typings/promiseBasedTypes.d.ts')
     // Generate all other regular definitions
-    await npx('jsdoc -c typings/jsdoc.conf.js');
+    await npx('jsdoc -c typings/jsdoc.conf.js')
   },
 
   async docsPlugins() {
     // generate documentation for plugins
-    await npx(`documentation build lib/plugin/*.js -o docs/plugins.md ${documentjsCliArgs}`);
+    await npx(`documentation build lib/plugin/*.js -o docs/plugins.md ${documentjsCliArgs}`)
     await replaceInFile('docs/plugins.md', (cfg) => {
-      cfg.replace(/^/, '---\npermalink: plugins\nsidebarDepth: \nsidebar: auto\ntitle: Plugins\n---\n\n');
-    });
+      cfg.replace(/^/, '---\npermalink: plugins\nsidebarDepth: \nsidebar: auto\ntitle: Plugins\n---\n\n')
+    })
   },
 
   async docsCi() {
     // generate docs for CI services
-    stopOnFail();
+    stopOnFail()
 
     writeToFile('docs/docker.md', (cfg) => {
-      cfg.line('---');
-      cfg.line('permalink: /docker');
-      cfg.line('layout: Section');
-      cfg.line('sidebar: false');
-      cfg.line('title: Docker');
-      cfg.line('editLink: false');
-      cfg.line('---');
-      cfg.line('');
-      cfg.textFromFile('docker/README.md');
-    });
+      cfg.line('---')
+      cfg.line('permalink: /docker')
+      cfg.line('layout: Section')
+      cfg.line('sidebar: false')
+      cfg.line('title: Docker')
+      cfg.line('editLink: false')
+      cfg.line('---')
+      cfg.line('')
+      cfg.textFromFile('docker/README.md')
+    })
 
     let body = `---
 permalink: /continuous-integration
@@ -86,154 +79,170 @@ Our community prepared some valuable recipes for setting up CI systems with Code
 
 ## Recipes
 
-`;
-    const res = await axios.get('https://codecept.discourse.group/search.json?q=category%3A9');
+`
+    const res = await axios.get('https://codecept.discourse.group/search.json?q=category%3A9')
     for (const topic of res.data.topics) {
-      if (topic.slug === 'about-the-continuous-integration-category') continue;
-      body += `* ### [${topic.title}](https://codecept.discourse.group/t/${topic.slug}/)\n`;
+      if (topic.slug === 'about-the-continuous-integration-category') continue
+      body += `* ### [${topic.title}](https://codecept.discourse.group/t/${topic.slug}/)\n`
     }
-    writeToFile('docs/continuous-integration.md', cfg => cfg.line(body));
+    writeToFile('docs/continuous-integration.md', (cfg) => cfg.line(body))
   },
 
   async docsExternalHelpers() {
     // generate documentation for helpers outside of main repo
-    console.log('Building @codecepjs/detox helper docs');
-    let helper = 'Detox';
+    console.log('Building @codecepjs/detox helper docs')
+    let helper = 'Detox'
     replaceInFile(`node_modules/@codeceptjs/detox-helper/${helper}.js`, (cfg) => {
-      cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object');
-      cfg.replace(/LocatorOrString/g, 'string | object');
-    });
-    await npx(`documentation build node_modules/@codeceptjs/detox-helper/${helper}.js -o ${helperMarkDownFile(helper)} ${documentjsCliArgs}`);
+      cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object')
+      cfg.replace(/LocatorOrString/g, 'string | object')
+    })
+    await npx(
+      `documentation build node_modules/@codeceptjs/detox-helper/${helper}.js -o ${helperMarkDownFile(helper)} ${documentjsCliArgs}`,
+    )
 
     await writeToFile(helperMarkDownFile(helper), (cfg) => {
-      cfg.line(`---\npermalink: /helpers/${helper}\nsidebar: auto\ntitle: ${helper}\n---\n\n# ${helper}\n\n`);
-      cfg.textFromFile(helperMarkDownFile(helper));
-    });
+      cfg.line(`---\npermalink: /helpers/${helper}\nsidebar: auto\ntitle: ${helper}\n---\n\n# ${helper}\n\n`)
+      cfg.textFromFile(helperMarkDownFile(helper))
+    })
 
     replaceInFile(`node_modules/@codeceptjs/detox-helper/${helper}.js`, (cfg) => {
-      cfg.replace(/string \| object/g, 'CodeceptJS.LocatorOrString');
-      cfg.replace(/string \| object/g, 'LocatorOrString');
-    });
+      cfg.replace(/string \| object/g, 'CodeceptJS.LocatorOrString')
+      cfg.replace(/string \| object/g, 'LocatorOrString')
+    })
 
-    console.log('Building @codeceptjs/mock-request');
-    helper = 'MockRequest';
+    console.log('Building @codeceptjs/mock-request')
+    helper = 'MockRequest'
     replaceInFile('node_modules/@codeceptjs/mock-request/index.js', (cfg) => {
-      cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object');
-      cfg.replace(/LocatorOrString/g, 'string | object');
-    });
-    await npx(`documentation build node_modules/@codeceptjs/mock-request/index.js -o ${helperMarkDownFile(helper)} ${documentjsCliArgs}`);
+      cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object')
+      cfg.replace(/LocatorOrString/g, 'string | object')
+    })
+    await npx(
+      `documentation build node_modules/@codeceptjs/mock-request/index.js -o ${helperMarkDownFile(helper)} ${documentjsCliArgs}`,
+    )
 
     await writeToFile(helperMarkDownFile(helper), (cfg) => {
-      cfg.line(`---\npermalink: /helpers/${helper}\nsidebar: auto\ntitle: ${helper}\n---\n\n# ${helper}\n\n`);
-      cfg.textFromFile(helperMarkDownFile(helper));
-    });
+      cfg.line(`---\npermalink: /helpers/${helper}\nsidebar: auto\ntitle: ${helper}\n---\n\n# ${helper}\n\n`)
+      cfg.textFromFile(helperMarkDownFile(helper))
+    })
 
     replaceInFile('node_modules/@codeceptjs/mock-request/index.js', (cfg) => {
-      cfg.replace(/string \| object/g, 'CodeceptJS.LocatorOrString');
-      cfg.replace(/string \| object/g, 'LocatorOrString');
-    });
+      cfg.replace(/string \| object/g, 'CodeceptJS.LocatorOrString')
+      cfg.replace(/string \| object/g, 'LocatorOrString')
+    })
   },
 
   async docsExternalPlugins() {
     // generate documentation for helpers outside of main repo
-    console.log('Building Vue plugin docs');
-    const resp = await axios.get('https://raw.githubusercontent.com/codecept-js/vue-cli-plugin-codeceptjs-puppeteer/master/README.md');
+    console.log('Building Vue plugin docs')
+    const resp = await axios.get(
+      'https://raw.githubusercontent.com/codecept-js/vue-cli-plugin-codeceptjs-puppeteer/master/README.md',
+    )
 
     writeToFile('docs/vue.md', (cfg) => {
-      cfg.line('---\npermalink: /vue\nlayout: Section\nsidebar: false\ntitle: Testing Vue Apps\n---\n\n');
-      cfg.line(resp.data);
-    });
+      cfg.line('---\npermalink: /vue\nlayout: Section\nsidebar: false\ntitle: Testing Vue Apps\n---\n\n')
+      cfg.line(resp.data)
+    })
 
-    this.docsCi();
+    this.docsCi()
   },
 
   async buildLibWithDocs(forTypings = false) {
     // generate documentation for helpers
-    const files = fs.readdirSync('lib/helper').filter(f => path.extname(f) === '.js');
+    const files = fs.readdirSync('lib/helper').filter((f) => path.extname(f) === '.js')
 
-    const partials = fs.readdirSync('docs/webapi').filter(f => path.extname(f) === '.mustache');
-    const placeholders = partials.map(file => `{{> ${path.basename(file, '.mustache')} }}`);
+    const partials = fs.readdirSync('docs/webapi').filter((f) => path.extname(f) === '.mustache')
+    const placeholders = partials.map((file) => `{{> ${path.basename(file, '.mustache')} }}`)
     const templates = partials
-      .map(file => fs.readFileSync(`docs/webapi/${file}`).toString())
-      .map(template => template.replace(/^/gm, '   * ').replace(/^/, '\n').replace(/\s*\* /, ''));
+      .map((file) => fs.readFileSync(`docs/webapi/${file}`).toString())
+      .map((template) =>
+        template
+          .replace(/^/gm, '   * ')
+          .replace(/^/, '\n')
+          .replace(/\s*\* /, ''),
+      )
 
     for (const file of files) {
-      const name = path.basename(file, '.js');
-      console.log(`Building helpers with docs for ${name}`);
-      copy(`lib/helper/${file}`, `docs/build/${file}`);
+      const name = path.basename(file, '.js')
+      console.log(`Building helpers with docs for ${name}`)
+      copy(`lib/helper/${file}`, `docs/build/${file}`)
       replaceInFile(`docs/build/${file}`, (cfg) => {
         for (const i in placeholders) {
-          cfg.replace(placeholders[i], templates[i]);
+          cfg.replace(placeholders[i], templates[i])
         }
         if (!forTypings) {
-          cfg.replace(/CodeceptJS.LocatorOrString\?/g, '(string | object)?');
-          cfg.replace(/LocatorOrString\?/g, '(string | object)?');
-          cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object');
-          cfg.replace(/LocatorOrString/g, 'string | object');
-          cfg.replace(/CodeceptJS.StringOrSecret/g, 'string | object');
+          cfg.replace(/CodeceptJS.LocatorOrString\?/g, '(string | object)?')
+          cfg.replace(/LocatorOrString\?/g, '(string | object)?')
+          cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object')
+          cfg.replace(/LocatorOrString/g, 'string | object')
+          cfg.replace(/CodeceptJS.StringOrSecret/g, 'string | object')
         }
-      });
+      })
     }
   },
 
   async docsHelpers() {
     // generate documentation for helpers
-    const files = fs.readdirSync('lib/helper').filter(f => path.extname(f) === '.js');
+    const files = fs.readdirSync('lib/helper').filter((f) => path.extname(f) === '.js')
 
-    const ignoreList = ['Polly', 'MockRequest']; // WebDriverIO won't be documented and should be removed
+    const ignoreList = ['Polly', 'MockRequest'] // WebDriverIO won't be documented and should be removed
 
-    const partials = fs.readdirSync('docs/webapi').filter(f => path.extname(f) === '.mustache');
-    const placeholders = partials.map(file => `{{> ${path.basename(file, '.mustache')} }}`);
+    const partials = fs.readdirSync('docs/webapi').filter((f) => path.extname(f) === '.mustache')
+    const placeholders = partials.map((file) => `{{> ${path.basename(file, '.mustache')} }}`)
     const templates = partials
-      .map(file => fs.readFileSync(`docs/webapi/${file}`).toString())
-      .map(template => template.replace(/^/gm, '   * ').replace(/^/, '\n').replace(/\s*\* /, ''));
-
-    const sharedPartials = fs.readdirSync('docs/shared').filter(f => path.extname(f) === '.mustache');
-    const sharedPlaceholders = sharedPartials.map(file => `{{ ${path.basename(file, '.mustache')} }}`);
+      .map((file) => fs.readFileSync(`docs/webapi/${file}`).toString())
+      .map((template) =>
+        template
+          .replace(/^/gm, '   * ')
+          .replace(/^/, '\n')
+          .replace(/\s*\* /, ''),
+      )
+
+    const sharedPartials = fs.readdirSync('docs/shared').filter((f) => path.extname(f) === '.mustache')
+    const sharedPlaceholders = sharedPartials.map((file) => `{{ ${path.basename(file, '.mustache')} }}`)
     const sharedTemplates = sharedPartials
-      .map(file => fs.readFileSync(`docs/shared/${file}`).toString())
-      .map(template => `\n\n\n${template}`);
+      .map((file) => fs.readFileSync(`docs/shared/${file}`).toString())
+      .map((template) => `\n\n\n${template}`)
 
     for (const file of files) {
-      const name = path.basename(file, '.js');
-      if (ignoreList.indexOf(name) >= 0) continue;
-      console.log(`Writing documentation for ${name}`);
-      copy(`lib/helper/${file}`, `docs/build/${file}`);
+      const name = path.basename(file, '.js')
+      if (ignoreList.indexOf(name) >= 0) continue
+      console.log(`Writing documentation for ${name}`)
+      copy(`lib/helper/${file}`, `docs/build/${file}`)
       replaceInFile(`docs/build/${file}`, (cfg) => {
         for (const i in placeholders) {
-          cfg.replace(placeholders[i], templates[i]);
+          cfg.replace(placeholders[i], templates[i])
         }
-        cfg.replace(/CodeceptJS.LocatorOrString\?/g, '(string | object)?');
-        cfg.replace(/LocatorOrString\?/g, '(string | object)?');
-        cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object');
-        cfg.replace(/LocatorOrString/g, 'string | object');
-        cfg.replace(/CodeceptJS.StringOrSecret/g, 'string | object');
-      });
-
-      await npx(`documentation build docs/build/${file} -o docs/helpers/${name}.md ${documentjsCliArgs}`);
+        cfg.replace(/CodeceptJS.LocatorOrString\?/g, '(string | object)?')
+        cfg.replace(/LocatorOrString\?/g, '(string | object)?')
+        cfg.replace(/CodeceptJS.LocatorOrString/g, 'string | object')
+        cfg.replace(/LocatorOrString/g, 'string | object')
+        cfg.replace(/CodeceptJS.StringOrSecret/g, 'string | object')
+      })
+
+      await npx(`documentation build docs/build/${file} -o docs/helpers/${name}.md ${documentjsCliArgs}`)
       replaceInFile(helperMarkDownFile(name), (cfg) => {
-        cfg.replace(/\(optional, default.*?\)/gm, '');
-        cfg.replace(/\\*/gm, '');
-      });
+        cfg.replace(/\(optional, default.*?\)/gm, '')
+        cfg.replace(/\\*/gm, '')
+      })
 
       replaceInFile(helperMarkDownFile(name), (cfg) => {
         for (const i in sharedPlaceholders) {
-          cfg.replace(sharedPlaceholders[i], sharedTemplates[i]);
+          cfg.replace(sharedPlaceholders[i], sharedTemplates[i])
         }
-      });
+      })
 
       replaceInFile(helperMarkDownFile(name), (cfg) => {
-        const regex = /## config((.|\n)*)\[1\]/m;
-        const fullText = fs.readFileSync(helperMarkDownFile(name)).toString();
-        const text = fullText.match(regex);
-        if (!text) return;
+        const regex = /## config((.|\n)*)\[1\]/m
+        const fullText = fs.readFileSync(helperMarkDownFile(name)).toString()
+        const text = fullText.match(regex)
+        if (!text) return
 
-        cfg.replace('<!-- configuration -->', text[1]);
-        cfg.replace(regex, '[1]');
-      });
+        cfg.replace('<!-- configuration -->', text[1])
+        cfg.replace(regex, '[1]')
+      })
 
       if (name === 'Appium') {
-        await this.docsAppium();
+        await this.docsAppium()
       }
 
       await writeToFile(helperMarkDownFile(name), (cfg) => {
@@ -244,9 +253,9 @@ sidebar: auto
 title: ${name}
 ---
 
-`);
-        cfg.textFromFile(helperMarkDownFile(name));
-      });
+`)
+        cfg.textFromFile(helperMarkDownFile(name))
+      })
     }
   },
 
@@ -254,64 +263,68 @@ title: ${name}
     // publish wiki pages to website
     if (!fs.existsSync('docs/wiki/Home.md')) {
       await git((fn) => {
-        fn.clone('git@github.com:codeceptjs/CodeceptJS.wiki.git', 'docs/wiki');
-      });
+        fn.clone('git@github.com:codeceptjs/CodeceptJS.wiki.git', 'docs/wiki')
+      })
     }
-    await chdir('docs/wiki', () => git(cfg => cfg.pull('origin master')));
+    await chdir('docs/wiki', () => git((cfg) => cfg.pull('origin master')))
 
     await writeToFile('docs/community-helpers.md', (cfg) => {
-      cfg.line('---');
-      cfg.line('permalink: /community-helpers');
-      cfg.line('title: Community Helpers');
-      cfg.line('editLink: false');
-      cfg.line('---');
-      cfg.line('');
-      cfg.line('# Community Helpers');
-      cfg.line('> Share your helpers at our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Community-Helpers)');
-      cfg.line('');
-      cfg.textFromFile('docs/wiki/Community-Helpers-&-Plugins.md');
-    });
+      cfg.line('---')
+      cfg.line('permalink: /community-helpers')
+      cfg.line('title: Community Helpers')
+      cfg.line('editLink: false')
+      cfg.line('---')
+      cfg.line('')
+      cfg.line('# Community Helpers')
+      cfg.line(
+        '> Share your helpers at our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Community-Helpers)',
+      )
+      cfg.line('')
+      cfg.textFromFile('docs/wiki/Community-Helpers-&-Plugins.md')
+    })
 
     writeToFile('docs/examples.md', (cfg) => {
-      cfg.line('---');
-      cfg.line('permalink: /examples');
-      cfg.line('layout: Section');
-      cfg.line('sidebar: false');
-      cfg.line('title: Examples');
-      cfg.line('editLink: false');
-      cfg.line('---');
-      cfg.line('');
-      cfg.line('# Examples');
-      cfg.line('> Add your own examples to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Examples)');
-      cfg.textFromFile('docs/wiki/Examples.md');
-    });
+      cfg.line('---')
+      cfg.line('permalink: /examples')
+      cfg.line('layout: Section')
+      cfg.line('sidebar: false')
+      cfg.line('title: Examples')
+      cfg.line('editLink: false')
+      cfg.line('---')
+      cfg.line('')
+      cfg.line('# Examples')
+      cfg.line('> Add your own examples to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Examples)')
+      cfg.textFromFile('docs/wiki/Examples.md')
+    })
 
     writeToFile('docs/books.md', (cfg) => {
-      cfg.line('---');
-      cfg.line('permalink: /books');
-      cfg.line('layout: Section');
-      cfg.line('sidebar: false');
-      cfg.line('title: Books & Posts');
-      cfg.line('editLink: false');
-      cfg.line('---');
-      cfg.line('');
-      cfg.line('# Books & Posts');
-      cfg.line('> Add your own books or posts to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Books-&-Posts)');
-      cfg.textFromFile('docs/wiki/Books-&-Posts.md');
-    });
+      cfg.line('---')
+      cfg.line('permalink: /books')
+      cfg.line('layout: Section')
+      cfg.line('sidebar: false')
+      cfg.line('title: Books & Posts')
+      cfg.line('editLink: false')
+      cfg.line('---')
+      cfg.line('')
+      cfg.line('# Books & Posts')
+      cfg.line(
+        '> Add your own books or posts to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Books-&-Posts)',
+      )
+      cfg.textFromFile('docs/wiki/Books-&-Posts.md')
+    })
 
     writeToFile('docs/videos.md', (cfg) => {
-      cfg.line('---');
-      cfg.line('permalink: /videos');
-      cfg.line('layout: Section');
-      cfg.line('sidebar: false');
-      cfg.line('title: Videos');
-      cfg.line('editLink: false');
-      cfg.line('---');
-      cfg.line('');
-      cfg.line('> Add your own videos to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Videos)');
-      cfg.textFromFile('docs/wiki/Videos.md');
-    });
+      cfg.line('---')
+      cfg.line('permalink: /videos')
+      cfg.line('layout: Section')
+      cfg.line('sidebar: false')
+      cfg.line('title: Videos')
+      cfg.line('editLink: false')
+      cfg.line('---')
+      cfg.line('')
+      cfg.line('> Add your own videos to our [Wiki Page](https://github.com/codeceptjs/CodeceptJS/wiki/Videos)')
+      cfg.textFromFile('docs/wiki/Videos.md')
+    })
   },
 
   async docsAppium() {
@@ -329,106 +342,103 @@ title: ${name}
       /Css/,
       /Tab$/,
       /^wait/,
-    ];
+    ]
     const webdriverDoc = await documentation.build(['docs/build/WebDriver.js'], {
       shallow: true,
       order: 'asc',
-    });
+    })
     const doc = await documentation.build(['docs/build/Appium.js'], {
       shallow: true,
       order: 'asc',
-    });
+    })
 
     // copy all public methods from webdriver
     for (const method of webdriverDoc[0].members.instance) {
-      if (onlyWeb.filter(f => method.name.match(f)).length) continue;
-      if (doc[0].members.instance.filter(m => m.name === method.name).length) continue;
-      doc[0].members.instance.push(method);
+      if (onlyWeb.filter((f) => method.name.match(f)).length) continue
+      if (doc[0].members.instance.filter((m) => m.name === method.name).length) continue
+      doc[0].members.instance.push(method)
     }
-    const output = await documentation.formats.md(doc);
+    const output = await documentation.formats.md(doc)
     // output is a string of Markdown data
-    fs.writeFileSync('docs/helpers/Appium.md', output);
+    fs.writeFileSync('docs/helpers/Appium.md', output)
   },
 
   async publishSite() {
     // updates codecept.io website
-    await processChangelog();
-    await this.wiki();
+    await processChangelog()
+    await this.wiki()
 
-    const dir = 'website';
+    const dir = 'website'
     if (fs.existsSync(dir)) {
-      await exec(`rm -rf ${dir}`);
+      await exec(`rm -rf ${dir}`)
     }
 
-    await git((fn) => fn.clone('git@github.com:codeceptjs/website.git', dir));
-    await copy('docs', 'website/docs');
+    await git((fn) => fn.clone('git@github.com:codeceptjs/website.git', dir))
+    await copy('docs', 'website/docs')
 
     await chdir(dir, async () => {
-      stopOnFail(false);
+      stopOnFail(false)
       await git((fn) => {
-        fn.add('-A');
-        fn.commit('-m "synchronized with docs"');
-        fn.pull();
-        fn.push();
-      });
-      stopOnFail(true);
-
-      await exec('./runok.js publish');
-    });
+        fn.add('-A')
+        fn.commit('-m "synchronized with docs"')
+        fn.pull()
+        fn.push()
+      })
+      stopOnFail(true)
+
+      await exec('./runok.js publish')
+    })
   },
 
   async server() {
     // run test server. Warning! PHP required!
-    await Promise.all([
-      exec('php -S 127.0.0.1:8000 -t test/data/app'),
-      npmRun('json-server'),
-    ]);
+    await Promise.all([exec('php -S 127.0.0.1:8000 -t test/data/app'), npmRun('json-server')])
   },
 
   async release(releaseType = null) {
-    const packageInfo = JSON.parse(fs.readFileSync('package.json'));
+    const packageInfo = JSON.parse(fs.readFileSync('package.json'))
     // Releases CodeceptJS. You can pass in argument "patch", "minor", "major" to update package.json
     if (releaseType) {
-      packageInfo.version = semver.inc(packageInfo.version, releaseType);
-      fs.writeFileSync('package.json', JSON.stringify(packageInfo));
+      packageInfo.version = semver.inc(packageInfo.version, releaseType)
+      fs.writeFileSync('package.json', JSON.stringify(packageInfo))
       await git((cmd) => {
-        cmd.add('package.json');
-        cmd.commit('-m "version bump"');
-      });
+        cmd.add('package.json')
+        cmd.commit('-m "version bump"')
+      })
     }
     // publish a new release on npm. Update version in package.json!
-    const version = packageInfo.version;
-    await this.docs();
-    await this.def();
-    await this.publishSite();
+    const version = packageInfo.version
+    await this.docs()
+    await this.def()
+    await this.publishSite()
     await git((cmd) => {
-      cmd.pull();
-      cmd.tag(version);
-      cmd.push('origin 3.x --tags');
-    });
-    await exec('rm -rf docs/wiki/.git');
-    await exec('npm publish');
-    console.log('-- RELEASED --');
+      cmd.pull()
+      cmd.tag(version)
+      cmd.push('origin 3.x --tags')
+    })
+    await exec('rm -rf docs/wiki/.git')
+    await exec('npm publish')
+    console.log('-- RELEASED --')
   },
 
   async versioning() {
-    const semver = require('semver');
+    const semver = require('semver')
 
     if (fs.existsSync('./package.json')) {
-      const packageFile = require('./package.json');
-      const currentVersion = packageFile.version;
-      let type = process.argv[3];
+      const packageFile = require('./package.json')
+      const currentVersion = packageFile.version
+      let type = process.argv[3]
       if (!['major', 'minor', 'patch'].includes(type)) {
-        type = 'patch';
+        type = 'patch'
       }
 
-      const newVersion = semver.inc(packageFile.version, type);
-      packageFile.version = newVersion;
-      fs.writeFileSync('./package.json', (JSON.stringify(packageFile, null, 2)).replace(/(^[ \t]*\n)/gm, ''));
-      console.log('Version updated', currentVersion, '=>', newVersion);
+      const newVersion = semver.inc(packageFile.version, type)
+      packageFile.version = newVersion
+      fs.writeFileSync('./package.json', JSON.stringify(packageFile, null, 2).replace(/(^[ \t]*\n)/gm, ''))
+      console.log('Version updated', currentVersion, '=>', newVersion)
 
-      const file = 'CHANGELOG.md';
-      const changelog = fs.readFileSync(file).toString();
+      const file = 'CHANGELOG.md'
+      const changelog = fs.readFileSync(file).toString()
 
       const _changelog = `## ${newVersion}\n
 ❤️ Thanks all to those who contributed to make this release! ❤️
@@ -439,56 +449,62 @@ title: ${name}
 
 📖 *Documentation*
 
-${changelog}`;
+${changelog}`
 
-      fs.writeFileSync(`./${file}`, _changelog);
+      fs.writeFileSync(`./${file}`, _changelog)
 
-      console.log('Creating and switching to release branch...');
-      await exec(`git checkout -b release-${newVersion}`);
+      console.log('Creating and switching to release branch...')
+      await exec(`git checkout -b release-${newVersion}`)
     }
   },
 
   async getCommitLog() {
-    console.log('Gathering commits...');
-    const logs = await exec('git log --grep "chore(deps" --invert-grep --pretty=\'format:* %s - by @%aN\' $(git describe --abbrev=0 --tags)..HEAD | grep "DOC: " -v');
-    console.log(logs.data.stdout);
+    console.log('Gathering commits...')
+    const logs = await exec(
+      'git log --grep "chore(deps" --invert-grep --pretty=\'format:* %s - by @%aN\' $(git describe --abbrev=0 --tags)..HEAD | grep "DOC: " -v',
+    )
+    console.log(logs.data.stdout)
   },
 
   async contributorFaces() {
     // update contributors list in readme
-    await contributors.update(null, { exclude: 'actions-user' });
-    let readmeContent = fs.readFileSync('README.md');
-    readmeContent = readmeContent.toString()
-      .replace('<a href="https://github.com/apps/dependabot"><img src="https://avatars.githubusercontent.com/in/29110?v=4" title="dependabot[bot]" width="80" height="80"></a>\n', '');
-    fs.writeFileSync('./README.md', readmeContent);
+    await contributors.update(null, { exclude: 'actions-user' })
+    let readmeContent = fs.readFileSync('README.md')
+    readmeContent = readmeContent
+      .toString()
+      .replace(
+        '<a href="https://github.com/apps/dependabot"><img src="https://avatars.githubusercontent.com/in/29110?v=4" title="dependabot[bot]" width="80" height="80"></a>\n',
+        '',
+      )
+    fs.writeFileSync('./README.md', readmeContent)
   },
-};
+}
 
 async function processChangelog() {
-  const file = 'CHANGELOG.md';
-  let changelog = fs.readFileSync(file).toString();
+  const file = 'CHANGELOG.md'
+  let changelog = fs.readFileSync(file).toString()
 
   // user
-  changelog = changelog.replace(/\s@([\w-]+)/mg, ' **[$1](https://github.com/$1)**');
+  changelog = changelog.replace(/\s@([\w-]+)/gm, ' **[$1](https://github.com/$1)**')
 
   // issue
-  changelog = changelog.replace(/#(\d+)/mg, '[#$1](https://github.com/codeceptjs/CodeceptJS/issues/$1)');
+  changelog = changelog.replace(/#(\d+)/gm, '[#$1](https://github.com/codeceptjs/CodeceptJS/issues/$1)')
 
   // helper
-  changelog = changelog.replace(/\s\[(\w+)\]\s/mg, ' **[$1]** ');
+  changelog = changelog.replace(/\s\[(\w+)\]\s/gm, ' **[$1]** ')
 
   writeToFile('docs/changelog.md', (cfg) => {
-    cfg.line('---');
-    cfg.line('permalink: /changelog');
-    cfg.line('title: Releases');
-    cfg.line('sidebar: false');
-    cfg.line('layout: Section');
-    cfg.line('---');
-    cfg.line('');
-    cfg.line('# Releases');
-    cfg.line('');
-    cfg.line(changelog);
-  });
+    cfg.line('---')
+    cfg.line('permalink: /changelog')
+    cfg.line('title: Releases')
+    cfg.line('sidebar: false')
+    cfg.line('layout: Section')
+    cfg.line('---')
+    cfg.line('')
+    cfg.line('# Releases')
+    cfg.line('')
+    cfg.line(changelog)
+  })
 }
 
-if (require.main === module) runok(module.exports);
+if (require.main === module) runok(module.exports)
diff --git a/test/acceptance/codecept.Playwright.coverage.js b/test/acceptance/codecept.Playwright.coverage.js
index 11017f986..e2925d364 100644
--- a/test/acceptance/codecept.Playwright.coverage.js
+++ b/test/acceptance/codecept.Playwright.coverage.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -49,4 +49,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.Playwright.js b/test/acceptance/codecept.Playwright.js
index e4dca9ded..586a7ace6 100644
--- a/test/acceptance/codecept.Playwright.js
+++ b/test/acceptance/codecept.Playwright.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -41,4 +41,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.Playwright.retryTo.js b/test/acceptance/codecept.Playwright.retryTo.js
index e4dca9ded..586a7ace6 100644
--- a/test/acceptance/codecept.Playwright.retryTo.js
+++ b/test/acceptance/codecept.Playwright.retryTo.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -41,4 +41,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.Puppeteer.js b/test/acceptance/codecept.Puppeteer.js
index 8c2a8e987..d7e31d71c 100644
--- a/test/acceptance/codecept.Puppeteer.js
+++ b/test/acceptance/codecept.Puppeteer.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -9,10 +9,7 @@ module.exports.config = {
       url: TestHelper.siteUrl(),
       show: false,
       chrome: {
-        args: [
-          '--no-sandbox',
-          '--disable-setuid-sandbox',
-        ],
+        args: ['--no-sandbox', '--disable-setuid-sandbox'],
       },
     },
     ScreenshotSessionHelper: {
@@ -34,4 +31,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.Testcafe.js b/test/acceptance/codecept.Testcafe.js
index 13b529103..bf924656f 100644
--- a/test/acceptance/codecept.Testcafe.js
+++ b/test/acceptance/codecept.Testcafe.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -19,4 +19,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.WebDriver.devtools.coverage.js b/test/acceptance/codecept.WebDriver.devtools.coverage.js
index 6fb8f5aaa..3d771815d 100644
--- a/test/acceptance/codecept.WebDriver.devtools.coverage.js
+++ b/test/acceptance/codecept.WebDriver.devtools.coverage.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -46,4 +46,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.WebDriver.devtools.js b/test/acceptance/codecept.WebDriver.devtools.js
index f86312789..755e950d5 100644
--- a/test/acceptance/codecept.WebDriver.devtools.js
+++ b/test/acceptance/codecept.WebDriver.devtools.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -24,9 +24,10 @@ module.exports.config = {
     ExpectHelper: {},
   },
   include: {},
-  bootstrap: async () => new Promise(done => {
-    setTimeout(done, 5000);
-  }), // let's wait for selenium
+  bootstrap: async () =>
+    new Promise((done) => {
+      setTimeout(done, 5000)
+    }), // let's wait for selenium
   mocha: {},
   name: 'acceptance',
   plugins: {
@@ -38,4 +39,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/codecept.WebDriver.js b/test/acceptance/codecept.WebDriver.js
index 54dd4e3e4..006e69d67 100644
--- a/test/acceptance/codecept.WebDriver.js
+++ b/test/acceptance/codecept.WebDriver.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   tests: './*_test.js',
@@ -24,9 +24,10 @@ module.exports.config = {
     ExpectHelper: {},
   },
   include: {},
-  bootstrap: async () => new Promise(done => {
-    setTimeout(done, 5000);
-  }), // let's wait for selenium
+  bootstrap: async () =>
+    new Promise((done) => {
+      setTimeout(done, 5000)
+    }), // let's wait for selenium
   mocha: {},
   name: 'acceptance',
   plugins: {
@@ -38,4 +39,4 @@ module.exports.config = {
     features: './gherkin/*.feature',
     steps: ['./gherkin/steps.js'],
   },
-};
+}
diff --git a/test/acceptance/config_test.js b/test/acceptance/config_test.js
index fe3de0790..140d2a4c3 100644
--- a/test/acceptance/config_test.js
+++ b/test/acceptance/config_test.js
@@ -1,47 +1,47 @@
-Feature('Dynamic Config').config({ url: 'https://google.com' });
+Feature('Dynamic Config').config({ url: 'https://google.com' })
 
 Scenario('change config 1 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.dontSeeInCurrentUrl('github.com');
-  I.seeInCurrentUrl('google.com');
-});
+  I.amOnPage('/')
+  I.dontSeeInCurrentUrl('github.com')
+  I.seeInCurrentUrl('google.com')
+})
 
 Scenario('change config 2 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.seeInCurrentUrl('github.com');
-}).config({ url: 'https://github.com' });
+  I.amOnPage('/')
+  I.seeInCurrentUrl('github.com')
+}).config({ url: 'https://github.com' })
 
 Scenario('change config 3 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.dontSeeInCurrentUrl('github.com');
-  I.seeInCurrentUrl('google.com');
-});
+  I.amOnPage('/')
+  I.dontSeeInCurrentUrl('github.com')
+  I.seeInCurrentUrl('google.com')
+})
 
 Scenario('change config 4 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.seeInCurrentUrl('codecept.io');
+  I.amOnPage('/')
+  I.seeInCurrentUrl('codecept.io')
 }).config((test) => {
-  return { url: 'https://codecept.io/', capabilities: { 'moz:title': test.title } };
-});
+  return { url: 'https://codecept.io/', capabilities: { 'moz:title': test.title } }
+})
 
 Scenario('change config 5 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.dontSeeInCurrentUrl('github.com');
-  I.seeInCurrentUrl('google.com');
-});
+  I.amOnPage('/')
+  I.dontSeeInCurrentUrl('github.com')
+  I.seeInCurrentUrl('google.com')
+})
 
 Scenario('make API call and check response @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.makeApiRequest('get', 'https://reqres.in/api/users?page=2');
-  I.seeResponseCodeIsSuccessful();
-});
+  I.amOnPage('/')
+  I.makeApiRequest('get', 'https://reqres.in/api/users?page=2')
+  I.seeResponseCodeIsSuccessful()
+})
 
 Scenario('change config 6 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/');
-  I.seeInCurrentUrl('github.com');
+  I.amOnPage('/')
+  I.seeInCurrentUrl('github.com')
 }).config(async () => {
-  await new Promise(r => {
-    setTimeout(r, 50);
-  });
-  return { url: 'https://github.com' };
-});
+  await new Promise((r) => {
+    setTimeout(r, 50)
+  })
+  return { url: 'https://github.com' }
+})
diff --git a/test/acceptance/coverage_test.js b/test/acceptance/coverage_test.js
index 2a4c37706..2e5f88d1f 100644
--- a/test/acceptance/coverage_test.js
+++ b/test/acceptance/coverage_test.js
@@ -1,62 +1,79 @@
-const { I } = inject();
+const { I } = inject()
 
-Feature('Plugins');
+Feature('Plugins')
 
 Before(() => {
-  I.amOnPage('https://todomvc.com/examples/react/dist/');
+  I.amOnPage('https://todomvc.com/examples/react/dist/')
 
-  I.say('Given I already have some todos');
+  I.say('Given I already have some todos')
 
-  I.executeScript(({ todoItems }) => {
-    localStorage.setItem('todos-angularjs', JSON.stringify(todoItems));
-  }, [{
-    title: 'Create a cypress like runner for CodeceptJS', completed: false,
-  }, {
-    title: 'Make it even better than cypress', completed: false,
-  }]);
+  I.executeScript(
+    ({ todoItems }) => {
+      localStorage.setItem('todos-angularjs', JSON.stringify(todoItems))
+    },
+    [
+      {
+        title: 'Create a cypress like runner for CodeceptJS',
+        completed: false,
+      },
+      {
+        title: 'Make it even better than cypress',
+        completed: false,
+      },
+    ],
+  )
 
-  I.refreshPage();
+  I.refreshPage()
 
-  I.executeScript(() => console.log('Some info'));
-  I.executeScript(() => console.error('Some error'));
-});
+  I.executeScript(() => console.log('Some info'))
+  I.executeScript(() => console.error('Some error'))
+})
 
 Scenario('Create some todo items @coverage', () => {
-  I.say('When I focus the todo field');
-  I.click('.new-todo');
-
-  I.say('Then I can add additional todos');
-  I.fillField({
-    css: '.new-todo',
-  }, 'Optimize Puppeteer support');
-  I.pressKey('Enter');
-
-  I.fillField({
-    css: '.new-todo',
-  }, 'Add a web REPL');
-  I.pressKey('Enter');
-
-  I.fillField(locate('.new-todo').as('TODO Input'), 'Support Appium');
-  I.pressKey('Enter');
-
-  I.fillField({
-    css: '.new-todo',
-  }, 'Become REALLY productive writing E2E Tests with codepress and CodeceptJS');
-  I.pressKey('Enter');
-
-  I.say('And I see them in the list');
-  I.seeNumberOfVisibleElements('.todo-list li', 4);
+  I.say('When I focus the todo field')
+  I.click('.new-todo')
+
+  I.say('Then I can add additional todos')
+  I.fillField(
+    {
+      css: '.new-todo',
+    },
+    'Optimize Puppeteer support',
+  )
+  I.pressKey('Enter')
+
+  I.fillField(
+    {
+      css: '.new-todo',
+    },
+    'Add a web REPL',
+  )
+  I.pressKey('Enter')
+
+  I.fillField(locate('.new-todo').as('TODO Input'), 'Support Appium')
+  I.pressKey('Enter')
+
+  I.fillField(
+    {
+      css: '.new-todo',
+    },
+    'Become REALLY productive writing E2E Tests with codepress and CodeceptJS',
+  )
+  I.pressKey('Enter')
+
+  I.say('And I see them in the list')
+  I.seeNumberOfVisibleElements('.todo-list li', 4)
   I.see('Optimize Puppeteer support', {
     css: 'li:nth-child(1) label',
-  });
-  I.dontSee('Nightmare', '.main');
+  })
+  I.dontSee('Nightmare', '.main')
 
-  I.say('I complete a todo');
+  I.say('I complete a todo')
   I.click({
     css: 'li:nth-child(1) .toggle',
-  });
-  I.seeElement('li:nth-child(1).completed');
+  })
+  I.seeElement('li:nth-child(1).completed')
 
-  I.say('I mark all as completed');
-  I.saveScreenshot('create-multiple-todo-items.png');
-});
+  I.say('I mark all as completed')
+  I.saveScreenshot('create-multiple-todo-items.png')
+})
diff --git a/test/acceptance/react_test.js b/test/acceptance/react_test.js
index 5f5e16b38..5b4ffda0c 100644
--- a/test/acceptance/react_test.js
+++ b/test/acceptance/react_test.js
@@ -1,33 +1,33 @@
-const { I } = inject();
+const { I } = inject()
 
-Feature('React Selectors');
+Feature('React Selectors')
 
 Scenario('props @Puppeteer @Playwright', () => {
-  I.amOnPage('https://codecept.io/test-react-calculator/');
-  I.click('7');
-  I.click({ react: 't', props: { name: '=' } });
-  I.seeElement({ react: 't', props: { value: '7' } });
-  I.click({ react: 't', props: { name: '+' } });
-  I.click({ react: 't', props: { name: '3' } });
-  I.click({ react: 't', props: { name: '=' } });
-  I.seeElement({ react: 't', props: { value: '10' } });
-});
+  I.amOnPage('https://codecept.io/test-react-calculator/')
+  I.click('7')
+  I.click({ react: 't', props: { name: '=' } })
+  I.seeElement({ react: 't', props: { value: '7' } })
+  I.click({ react: 't', props: { name: '+' } })
+  I.click({ react: 't', props: { name: '3' } })
+  I.click({ react: 't', props: { name: '=' } })
+  I.seeElement({ react: 't', props: { value: '10' } })
+})
 
 Scenario('component name @Puppeteer @Playwright', () => {
-  I.amOnPage('http://negomi.github.io/react-burger-menu/');
-  I.click({ react: 'BurgerIcon' });
-  I.waitForVisible('#slide', 10);
-  I.click('Alerts');
-  I.seeElement({ react: 'Demo' });
-});
+  I.amOnPage('http://negomi.github.io/react-burger-menu/')
+  I.click({ react: 'BurgerIcon' })
+  I.waitForVisible('#slide', 10)
+  I.click('Alerts')
+  I.seeElement({ react: 'Demo' })
+})
 
 Scenario('using playwright locator @Playwright', () => {
-  I.amOnPage('https://codecept.io/test-react-calculator/');
-  I.click('7');
-  I.click({ pw: '_react=t[name = "="]' });
-  I.seeElement({ pw: '_react=t[value = "7"]' });
-  I.click({ pw: '_react=t[name = "+"]' });
-  I.click({ pw: '_react=t[name = "3"]' });
-  I.click({ pw: '_react=t[name = "="]' });
-  I.seeElement({ pw: '_react=t[value = "10"]' });
-});
+  I.amOnPage('https://codecept.io/test-react-calculator/')
+  I.click('7')
+  I.click({ pw: '_react=t[name = "="]' })
+  I.seeElement({ pw: '_react=t[value = "7"]' })
+  I.click({ pw: '_react=t[name = "+"]' })
+  I.click({ pw: '_react=t[name = "3"]' })
+  I.click({ pw: '_react=t[name = "="]' })
+  I.seeElement({ pw: '_react=t[value = "10"]' })
+})
diff --git a/test/acceptance/retryTo_test.js b/test/acceptance/retryTo_test.js
index 6253fdb80..67d253143 100644
--- a/test/acceptance/retryTo_test.js
+++ b/test/acceptance/retryTo_test.js
@@ -1,36 +1,36 @@
-const { I } = inject();
+const { I } = inject()
 
-Feature('Plugins');
+Feature('Plugins')
 
 Scenario('retryTo works with await steps @plugin', async () => {
   await retryTo(async (tryNum) => {
-    const foo = await I.grabCurrentUrl();
-    if (tryNum < 3) I.waitForVisible('.nothing', 1);
-  }, 4);
-});
+    const foo = await I.grabCurrentUrl()
+    if (tryNum < 3) I.waitForVisible('.nothing', 1)
+  }, 4)
+})
 
 Scenario('retryTo works with non await steps @plugin', async () => {
   await retryTo(async (tryNum) => {
-    if (tryNum < 3) I.waitForVisible('.nothing', 1);
-  }, 4);
-});
+    if (tryNum < 3) I.waitForVisible('.nothing', 1)
+  }, 4)
+})
 
 Scenario('Should be succeed', async ({ I }) => {
-  I.amOnPage('http://example.org');
-  I.waitForVisible('.nothing', 1); // should fail here but it won't terminate
+  I.amOnPage('http://example.org')
+  I.waitForVisible('.nothing', 1) // should fail here but it won't terminate
   await retryTo((tryNum) => {
-    I.see('.doesNotMatter');
-  }, 10);
-});
+    I.see('.doesNotMatter')
+  }, 10)
+})
 
 Scenario('Should fail after reached max retries', async () => {
   await retryTo(() => {
-    throw new Error('Custom pluginRetryTo Error');
-  }, 3);
-});
+    throw new Error('Custom pluginRetryTo Error')
+  }, 3)
+})
 
 Scenario('Should succeed at the third attempt @plugin', async () => {
   await retryTo(async (tryNum) => {
-    if (tryNum < 2) throw new Error('Custom pluginRetryTo Error');
-  }, 3);
-});
+    if (tryNum < 2) throw new Error('Custom pluginRetryTo Error')
+  }, 3)
+})
diff --git a/test/acceptance/session_test.js b/test/acceptance/session_test.js
index d8ea18627..4a87e372e 100644
--- a/test/acceptance/session_test.js
+++ b/test/acceptance/session_test.js
@@ -1,240 +1,245 @@
-const assert = require('assert');
+const assert = require('assert')
 
-const { event } = codeceptjs;
+const { event } = codeceptjs
 
-Feature('Session');
+Feature('Session')
 
 Scenario('simple session @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/info');
+  I.amOnPage('/info')
   session('john', () => {
-    I.amOnPage('https://codecept.io/');
-    I.dontSeeInCurrentUrl('/info');
-    I.see('CodeceptJS');
-  });
-  I.dontSee('GitHub');
-  I.seeInCurrentUrl('/info');
-});
+    I.amOnPage('https://codecept.io/')
+    I.dontSeeInCurrentUrl('/info')
+    I.see('CodeceptJS')
+  })
+  I.dontSee('GitHub')
+  I.seeInCurrentUrl('/info')
+})
 
 Scenario('screenshots reflect the current page of current session @Puppeteer @Playwright @WebDriver', async ({ I }) => {
-  I.amOnPage('/');
-  I.saveScreenshot('session_default_1.png');
+  I.amOnPage('/')
+  I.saveScreenshot('session_default_1.png')
 
   session('john', () => {
-    I.amOnPage('/info');
-    I.saveScreenshot('session_john_1.png');
-  });
+    I.amOnPage('/info')
+    I.saveScreenshot('session_john_1.png')
+  })
 
-  I.saveScreenshot('session_default_2.png');
+  I.saveScreenshot('session_default_2.png')
 
   session('john', () => {
-    I.saveScreenshot('session_john_2.png');
-  });
+    I.saveScreenshot('session_john_2.png')
+  })
 
   const [default1Digest, default2Digest, john1Digest, john2Digest] = await I.getSHA256Digests([
     `${output_dir}/session_default_1.png`,
     `${output_dir}/session_default_2.png`,
     `${output_dir}/john_session_john_1.png`,
     `${output_dir}/session_john_2.png`,
-  ]);
+  ])
 
   // Assert that screenshots of same page in same session are equal
-  I.expectEqual(default1Digest, default2Digest);
-  I.expectEqual(john1Digest, john2Digest);
+  I.expectEqual(default1Digest, default2Digest)
+  I.expectEqual(john1Digest, john2Digest)
 
   // Assert that screenshots of different pages in different sessions are not equal
-  I.expectNotEqual(default1Digest, john1Digest);
-});
+  I.expectNotEqual(default1Digest, john1Digest)
+})
 
 Scenario('Different cookies for different sessions @Playwright @Puppeteer', async ({ I }) => {
-  const cookiePage = 'https://www.microsoft.com/en-au/';
-  const cookieName = 'MUID';
-  const cookies = {};
+  const cookiePage = 'https://www.microsoft.com/en-au/'
+  const cookieName = 'MUID'
+  const cookies = {}
 
-  I.amOnPage(cookiePage);
+  I.amOnPage(cookiePage)
   session('john', () => {
-    I.amOnPage(cookiePage);
-  });
+    I.amOnPage(cookiePage)
+  })
   session('mary', () => {
-    I.amOnPage(cookiePage);
-  });
+    I.amOnPage(cookiePage)
+  })
 
-  cookies.default = (await I.grabCookie(cookieName)).value;
-  I.say(`${cookieName}: ${cookies.default}`);
+  cookies.default = (await I.grabCookie(cookieName)).value
+  I.say(`${cookieName}: ${cookies.default}`)
   session('john', async () => {
-    cookies.john = (await I.grabCookie(cookieName)).value;
-    I.say(`${cookieName}: ${cookies.john}`);
-  });
+    cookies.john = (await I.grabCookie(cookieName)).value
+    I.say(`${cookieName}: ${cookies.john}`)
+  })
   session('mary', async () => {
-    cookies.mary = (await I.grabCookie(cookieName)).value;
-    I.say(`${cookieName}: ${cookies.mary}`);
-  });
-  await I.seeInCurrentUrl('en-au');
-  assert(cookies.default);
-  assert(cookies.john);
-  assert(cookies.mary);
-  I.expectNotEqual(cookies.default, cookies.john);
-  I.expectNotEqual(cookies.default, cookies.mary);
-  I.expectNotEqual(cookies.john, cookies.mary);
-});
+    cookies.mary = (await I.grabCookie(cookieName)).value
+    I.say(`${cookieName}: ${cookies.mary}`)
+  })
+  await I.seeInCurrentUrl('en-au')
+  assert(cookies.default)
+  assert(cookies.john)
+  assert(cookies.mary)
+  I.expectNotEqual(cookies.default, cookies.john)
+  I.expectNotEqual(cookies.default, cookies.mary)
+  I.expectNotEqual(cookies.john, cookies.mary)
+})
 
 Scenario('should save screenshot for sessions @WebDriverIO @Puppeteer @Playwright', async function ({ I }) {
-  await I.amOnPage('/form/bug1467');
-  await I.saveScreenshot('original.png');
-  await I.amOnPage('/');
-  await I.saveScreenshot('main_session.png');
+  await I.amOnPage('/form/bug1467')
+  await I.saveScreenshot('original.png')
+  await I.amOnPage('/')
+  await I.saveScreenshot('main_session.png')
   session('john', async () => {
-    await I.amOnPage('/form/bug1467');
-    event.dispatcher.emit(event.test.failed, this);
-  });
+    await I.amOnPage('/form/bug1467')
+    event.dispatcher.emit(event.test.failed, this)
+  })
 
-  const fileName = clearString(this.title);
+  const fileName = clearString(this.title)
   const [original, failed] = await I.getSHA256Digests([
     `${output_dir}/original.png`,
     `${output_dir}/john_${fileName}.failed.png`,
-  ]);
+  ])
 
   // Assert that screenshots of same page in same session are equal
-  await I.expectEqual(original, failed);
+  await I.expectEqual(original, failed)
 
   // Assert that screenshots of sessions are created
   const [main_original, session_failed] = await I.getSHA256Digests([
     `${output_dir}/main_session.png`,
     `${output_dir}/john_${fileName}.failed.png`,
-  ]);
-  await I.expectNotEqual(main_original, session_failed);
-});
+  ])
+  await I.expectNotEqual(main_original, session_failed)
+})
 
 Scenario('should throw exception and close correctly @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/form/bug1467#session1');
-  I.checkOption('Yes');
+  I.amOnPage('/form/bug1467#session1')
+  I.checkOption('Yes')
   session('john', () => {
-    I.amOnPage('/form/bug1467#session2');
-    I.checkOption('No1');
-    I.seeCheckboxIsChecked({ css: 'input[value=No]' });
-  });
-  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' });
-  I.amOnPage('/info');
-}).fails();
+    I.amOnPage('/form/bug1467#session2')
+    I.checkOption('No1')
+    I.seeCheckboxIsChecked({ css: 'input[value=No]' })
+  })
+  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' })
+  I.amOnPage('/info')
+}).fails()
 
 Scenario('async/await @WebDriverIO', ({ I }) => {
-  I.amOnPage('/form/bug1467#session1');
-  I.checkOption('Yes');
+  I.amOnPage('/form/bug1467#session1')
+  I.checkOption('Yes')
   session('john', async () => {
-    I.amOnPage('/form/bug1467#session2');
-    I.checkOption('No');
-    I.seeCheckboxIsChecked({ css: 'input[value=No]' });
-  });
-  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' });
-});
+    I.amOnPage('/form/bug1467#session2')
+    I.checkOption('No')
+    I.seeCheckboxIsChecked({ css: 'input[value=No]' })
+  })
+  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' })
+})
 
 Scenario('exception on async/await @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/form/bug1467#session1');
-  I.checkOption('Yes');
+  I.amOnPage('/form/bug1467#session1')
+  I.checkOption('Yes')
   session('john', async () => {
-    I.amOnPage('/form/bug1467#session2');
-    I.checkOption('No');
-    I.seeCheckboxIsChecked({ css: 'input[value=Yes]' });
-  });
-  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' });
-}).throws(/to be checked/);
+    I.amOnPage('/form/bug1467#session2')
+    I.checkOption('No')
+    I.seeCheckboxIsChecked({ css: 'input[value=Yes]' })
+  })
+  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' })
+}).throws(/to be checked/)
 
 Scenario('should work with within @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/form/bug1467');
+  I.amOnPage('/form/bug1467')
   session('john', () => {
-    I.amOnPage('/form/bug1467');
+    I.amOnPage('/form/bug1467')
     within({ css: '[name=form1]' }, () => {
-      I.checkOption('Yes');
-      I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' });
-    });
-  });
+      I.checkOption('Yes')
+      I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' })
+    })
+  })
   within({ css: '[name=form2]' }, () => {
-    I.checkOption('Yes');
-    I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' });
-  });
-  I.seeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' });
-  I.dontSeeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' });
+    I.checkOption('Yes')
+    I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' })
+  })
+  I.seeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' })
+  I.dontSeeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' })
   session('john', () => {
-    I.seeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' });
-    I.dontSeeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' });
-  });
-});
+    I.seeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' })
+    I.dontSeeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' })
+  })
+})
 
 Scenario('change page emulation @Playwright', async ({ I }) => {
-  const assert = require('assert');
-  I.amOnPage('/');
-  session('mobile user', {
-    viewport: { width: 300, height: 500 },
-  }, async () => {
-    I.amOnPage('/');
-    const width = await I.executeScript('window.innerWidth');
-    I.expectEqual(width, 300);
-  });
-});
+  const assert = require('assert')
+  I.amOnPage('/')
+  session(
+    'mobile user',
+    {
+      viewport: { width: 300, height: 500 },
+    },
+    async () => {
+      I.amOnPage('/')
+      const width = await I.executeScript('window.innerWidth')
+      I.expectEqual(width, 300)
+    },
+  )
+})
 
 Scenario('emulate iPhone @Playwright', async ({ I }) => {
-  const { devices } = require('playwright');
-  if (process.env.BROWSER === 'firefox') return;
-  const assert = require('assert');
-  I.amOnPage('/');
+  const { devices } = require('playwright')
+  if (process.env.BROWSER === 'firefox') return
+  const assert = require('assert')
+  I.amOnPage('/')
   session('mobile user', devices['iPhone 6'], async () => {
-    I.amOnPage('/');
-    const width = await I.executeScript('window.innerWidth');
-    assert.ok(width > 950 && width < 1000);
-  });
-});
-
-xScenario('should use different base URL @Puppeteer @Playwright', ({ I }) => { // nah, that's broken
-  I.amOnPage('/');
-  I.see('Welcome to test app');
+    I.amOnPage('/')
+    const width = await I.executeScript('window.innerWidth')
+    assert.ok(width > 950 && width < 1000)
+  })
+})
+
+xScenario('should use different base URL @Puppeteer @Playwright', ({ I }) => {
+  // nah, that's broken
+  I.amOnPage('/')
+  I.see('Welcome to test app')
   session('john', { url: 'https://github.com' }, () => {
-    I.amOnPage('/');
-    I.dontSee('Welcome to test app');
-    I.see('GitHub');
-  });
-  I.see('Welcome to test app');
-});
-
-xScenario('should start firefox', async ({ I }) => { // requires firefox :)
-  I.amOnPage('/form/bug1467#session1');
-  I.checkOption('Yes');
+    I.amOnPage('/')
+    I.dontSee('Welcome to test app')
+    I.see('GitHub')
+  })
+  I.see('Welcome to test app')
+})
+
+xScenario('should start firefox', async ({ I }) => {
+  // requires firefox :)
+  I.amOnPage('/form/bug1467#session1')
+  I.checkOption('Yes')
   session('john', { browser: 'firefox' }, async () => {
-    I.amOnPage('/form/bug1467#session2');
-    I.checkOption('No');
-    I.seeCheckboxIsChecked({ css: 'input[value=No]' });
-    const isChrome = await I.executeScript(() => !!window.chrome);
-    assert(!isChrome);
-  });
-  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' });
-  const isChrome = await I.executeScript(() => !!window.chrome);
-  assert(isChrome);
-});
+    I.amOnPage('/form/bug1467#session2')
+    I.checkOption('No')
+    I.seeCheckboxIsChecked({ css: 'input[value=No]' })
+    const isChrome = await I.executeScript(() => !!window.chrome)
+    assert(!isChrome)
+  })
+  I.seeCheckboxIsChecked({ css: 'input[value=Yes]' })
+  const isChrome = await I.executeScript(() => !!window.chrome)
+  assert(isChrome)
+})
 
 Scenario('should return a value in @WebDriverIO @Puppeteer @Playwright', async ({ I }) => {
-  I.amOnPage('/form/textarea');
+  I.amOnPage('/form/textarea')
   const val = await session('john', () => {
-    I.amOnPage('/info');
-    return I.grabTextFrom({ css: 'h1' });
-  });
-  I.fillField('Description', val);
-  I.click('Submit');
-  I.see('[description] => Information');
-});
+    I.amOnPage('/info')
+    return I.grabTextFrom({ css: 'h1' })
+  })
+  I.fillField('Description', val)
+  I.click('Submit')
+  I.see('[description] => Information')
+})
 
 Scenario('should return a value @WebDriverIO @Puppeteer @Playwright in async', async ({ I }) => {
-  I.amOnPage('/form/textarea');
+  I.amOnPage('/form/textarea')
   const val = await session('john', async () => {
-    I.amOnPage('/info');
-    return I.grabTextFrom({ css: 'h1' });
-  });
-  I.fillField('Description', val);
-  I.click('Submit');
-  I.see('[description] => Information');
-});
+    I.amOnPage('/info')
+    return I.grabTextFrom({ css: 'h1' })
+  })
+  I.fillField('Description', val)
+  I.click('Submit')
+  I.see('[description] => Information')
+})
 
 function clearString(str) {
-  if (!str) return '';
+  if (!str) return ''
   /* Replace forbidden symbols in string
-     */
-  return str
-    .replace(/ /g, '_');
+   */
+  return str.replace(/ /g, '_')
 }
diff --git a/test/acceptance/within_test.js b/test/acceptance/within_test.js
index 726c75253..8a5fd2b2b 100644
--- a/test/acceptance/within_test.js
+++ b/test/acceptance/within_test.js
@@ -1,117 +1,123 @@
-Feature('within', { retries: 3 });
+Feature('within', { retries: 3 })
 
 Scenario('within on form @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/form/bug1467');
-  I.see('TEST TEST');
+  I.amOnPage('/form/bug1467')
+  I.see('TEST TEST')
   within({ css: '[name=form2]' }, async () => {
-    await I.checkOption('Yes');
-    await I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' });
-  });
-  I.seeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' });
-  I.dontSeeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' });
-});
+    await I.checkOption('Yes')
+    await I.seeCheckboxIsChecked({ css: 'input[name=first_test_radio]' })
+  })
+  I.seeCheckboxIsChecked({ css: 'form[name=form2] input[name=first_test_radio]' })
+  I.dontSeeCheckboxIsChecked({ css: 'form[name=form1] input[name=first_test_radio]' })
+})
 
 Scenario('switch iframe manually @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe');
+  I.amOnPage('/iframe')
 
-  I.switchTo('iframe');
-  I.fillField('rus', 'Updated');
-  I.click('Sign in!');
-  I.waitForText('Email Address');
+  I.switchTo('iframe')
+  I.fillField('rus', 'Updated')
+  I.click('Sign in!')
+  I.waitForText('Email Address')
 
-  I.switchTo();
-  I.see('Iframe test');
-  I.dontSee('Email Address');
-});
+  I.switchTo()
+  I.see('Iframe test')
+  I.dontSee('Email Address')
+})
 
 Scenario('within on iframe @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe');
+  I.amOnPage('/iframe')
   within({ frame: 'iframe' }, async () => {
-    await I.fillField('rus', 'Updated');
-    await I.click('Sign in!');
-    await I.waitForText('Email Address');
-  });
-  I.see('Iframe test');
-  I.dontSee('Email Address');
-});
+    await I.fillField('rus', 'Updated')
+    await I.click('Sign in!')
+    await I.waitForText('Email Address')
+  })
+  I.see('Iframe test')
+  I.dontSee('Email Address')
+})
 
 Scenario('within on iframe without iframe navigation @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe');
+  I.amOnPage('/iframe')
   within({ frame: 'iframe' }, async () => {
-    await I.fillField('rus', 'Updated');
-    await I.see('Sign in!');
-  });
-  I.see('Iframe test');
-  I.dontSee('Sign in!');
-});
+    await I.fillField('rus', 'Updated')
+    await I.see('Sign in!')
+  })
+  I.see('Iframe test')
+  I.dontSee('Sign in!')
+})
 
 Scenario('within on nested iframe without iframe navigation depth 2 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe_nested');
+  I.amOnPage('/iframe_nested')
   within({ frame: ['[name=wrapper]', '[name=content]'] }, () => {
-    I.fillField('rus', 'Updated');
-    I.see('Sign in!');
-  });
-  I.see('Nested Iframe test');
-  I.dontSee('Sign in!');
-});
+    I.fillField('rus', 'Updated')
+    I.see('Sign in!')
+  })
+  I.see('Nested Iframe test')
+  I.dontSee('Sign in!')
+})
 
 Scenario('within on nested iframe depth 1 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe');
+  I.amOnPage('/iframe')
   within({ frame: ['[name=content]'] }, () => {
-    I.fillField('rus', 'Updated');
-    I.click('Sign in!');
-    I.waitForText('Email Address');
-  });
-  I.see('Iframe test');
-  I.dontSee('Email Address');
-});
+    I.fillField('rus', 'Updated')
+    I.click('Sign in!')
+    I.waitForText('Email Address')
+  })
+  I.see('Iframe test')
+  I.dontSee('Email Address')
+})
 
 Scenario('within on nested iframe depth 2 @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe_nested');
+  I.amOnPage('/iframe_nested')
   within({ frame: ['[name=wrapper]', '[name=content]'] }, () => {
-    I.fillField('rus', 'Updated');
-    I.click('Sign in!');
-    I.see('Email Address');
-  });
-  I.see('Nested Iframe test');
-  I.dontSee('Email Address');
-});
+    I.fillField('rus', 'Updated')
+    I.click('Sign in!')
+    I.see('Email Address')
+  })
+  I.see('Nested Iframe test')
+  I.dontSee('Email Address')
+})
 
-Scenario('within on nested iframe depth 2 and mixed id and xpath selector @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe_nested');
-  within({ frame: ['#wrapperId', '[name=content]'] }, () => {
-    I.fillField('rus', 'Updated');
-    I.click('Sign in!');
-    I.see('Email Address');
-  });
-  I.see('Nested Iframe test');
-  I.dontSee('Email Address');
-});
+Scenario(
+  'within on nested iframe depth 2 and mixed id and xpath selector @WebDriverIO @Puppeteer @Playwright',
+  ({ I }) => {
+    I.amOnPage('/iframe_nested')
+    within({ frame: ['#wrapperId', '[name=content]'] }, () => {
+      I.fillField('rus', 'Updated')
+      I.click('Sign in!')
+      I.see('Email Address')
+    })
+    I.see('Nested Iframe test')
+    I.dontSee('Email Address')
+  },
+)
 
-Scenario('within on nested iframe depth 2 and mixed class and xpath selector @WebDriverIO @Puppeteer @Playwright', ({ I }) => {
-  I.amOnPage('/iframe_nested');
-  within({ frame: ['.wrapperClass', '[name=content]'] }, () => {
-    I.fillField('rus', 'Updated');
-    I.click('Sign in!');
-    I.see('Email Address');
-  });
-  I.see('Nested Iframe test');
-  I.dontSee('Email Address');
-});
+Scenario(
+  'within on nested iframe depth 2 and mixed class and xpath selector @WebDriverIO @Puppeteer @Playwright',
+  ({ I }) => {
+    I.amOnPage('/iframe_nested')
+    within({ frame: ['.wrapperClass', '[name=content]'] }, () => {
+      I.fillField('rus', 'Updated')
+      I.click('Sign in!')
+      I.see('Email Address')
+    })
+    I.see('Nested Iframe test')
+    I.dontSee('Email Address')
+  },
+)
 
 Scenario('should throw exception if element not found @WebDriverIO @Puppeteer @Playwright', async ({ I }) => {
-  I.amOnPage('/form/textarea');
+  I.amOnPage('/form/textarea')
   within('#grab-multiple', async () => {
-    return I.grabTextFrom('#first-link');
-  });
-}).throws(/found/);
+    return I.grabTextFrom('#first-link')
+  })
+}).throws(/found/)
 
 Scenario('should return a value @WebDriverIO @Puppeteer @Playwright', async ({ I }) => {
-  I.amOnPage('/info');
+  I.amOnPage('/info')
   const val = await within('#grab-multiple', () => {
-    return I.grabTextFrom('#first-link');
-  });
-  I.fillField('rus', val);
-  I.pressKey('Enter');
-  I.see('[rus] => First');
-}).retry(0);
+    return I.grabTextFrom('#first-link')
+  })
+  I.fillField('rus', val)
+  I.pressKey('Enter')
+  I.see('[rus] => First')
+}).retry(0)
diff --git a/test/bdd/codecept.faker.js b/test/bdd/codecept.faker.js
index 2fd547ecb..a7cb273cc 100644
--- a/test/bdd/codecept.faker.js
+++ b/test/bdd/codecept.faker.js
@@ -1,4 +1,4 @@
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
 module.exports.config = {
   timeout: 10000,
@@ -8,10 +8,7 @@ module.exports.config = {
       url: TestHelper.siteUrl(),
       show: false,
       chrome: {
-        args: [
-          '--no-sandbox',
-          '--disable-setuid-sandbox',
-        ],
+        args: ['--no-sandbox', '--disable-setuid-sandbox'],
       },
     },
     ScreenshotSessionHelper: {
@@ -35,4 +32,4 @@ module.exports.config = {
     features: './features/faker.feature',
     steps: ['./defs/faker.js'],
   },
-};
+}
diff --git a/test/data/I.js b/test/data/I.js
index 76a70cada..1f0dd65fa 100644
--- a/test/data/I.js
+++ b/test/data/I.js
@@ -1,7 +1,7 @@
 module.exports = {
   _init: () => {
-    global.I_initialized = true;
+    global.I_initialized = true
   },
 
   doSomething: () => 'done',
-};
+}
diff --git a/test/data/app/view/form/wait_disabled.php b/test/data/app/view/form/wait_disabled.php
new file mode 100644
index 000000000..4e765b47f
--- /dev/null
+++ b/test/data/app/view/form/wait_disabled.php
@@ -0,0 +1,21 @@
+<html>
+<body>
+
+<input id="text" type="text" name="test" disabled="true" value="some text">
+
+<button id="button" type="button" name="button1" disabled="true" value="first" onclick="updateMessage('button was clicked')">A Button</button>
+
+<div id="message"></div>
+
+<script>
+  setTimeout(function () {
+    document.querySelector('#text').disabled = false;
+    document.querySelector('#button').disabled = false;
+  }, 2000);
+
+  function updateMessage(msg) {
+    document.querySelector('#message').textContent = msg;
+  }
+</script>
+</body>
+</html>
diff --git a/test/data/dummy_page.js b/test/data/dummy_page.js
index 49c79338f..b65706a56 100644
--- a/test/data/dummy_page.js
+++ b/test/data/dummy_page.js
@@ -1,6 +1,6 @@
-const { I } = inject();
+const { I } = inject()
 
 module.exports = {
   openDummyPage: () => 'dummy page opened',
   getI: () => I,
-};
+}
diff --git a/test/data/fake_driver.js b/test/data/fake_driver.js
index d28d9c59c..9f34d45cd 100644
--- a/test/data/fake_driver.js
+++ b/test/data/fake_driver.js
@@ -1,13 +1,13 @@
-const Helper = require('../../lib/helper');
+const Helper = require('../../lib/helper')
 
 class FakeDriver extends Helper {
   printBrowser() {
-    this.debug(this.config.browser);
+    this.debug(this.config.browser)
   }
 
   printWindowSize() {
-    this.debug(this.config.windowSize);
+    this.debug(this.config.windowSize)
   }
 }
 
-module.exports = FakeDriver;
+module.exports = FakeDriver
diff --git a/test/data/helper.js b/test/data/helper.js
index a0b953162..b02c7906d 100644
--- a/test/data/helper.js
+++ b/test/data/helper.js
@@ -1,61 +1,61 @@
-const Helper = require('../../lib/helper');
+const Helper = require('../../lib/helper')
 
 class MyHelper extends Helper {
   method() {
-    return 'hello world';
+    return 'hello world'
   }
 
   _init() {
-    console.log('Helper: I\'m initialized');
+    console.log("Helper: I'm initialized")
   }
 
   _beforeSuite() {
-    console.log('Helper: I\'m simple BeforeSuite hook');
+    console.log("Helper: I'm simple BeforeSuite hook")
   }
 
   _before() {
-    console.log('Helper: I\'m simple Before hook');
+    console.log("Helper: I'm simple Before hook")
   }
 
   _after() {
-    console.log('Helper: I\'m simple After hook');
+    console.log("Helper: I'm simple After hook")
   }
 
   _afterSuite() {
-    console.log('Helper: I\'m simple AfterSuite hook');
+    console.log("Helper: I'm simple AfterSuite hook")
   }
 
   _passed() {
-    console.log('Event:test.passed (helper)');
+    console.log('Event:test.passed (helper)')
   }
 
   _failed() {
-    console.log('Event:test.failed (helper)');
+    console.log('Event:test.failed (helper)')
   }
 
   method2() {
-    return 'hello another world';
+    return 'hello another world'
   }
 
   _hiddenMethod() {
-    return 'hello dark side';
+    return 'hello dark side'
   }
 
   stringWithHook(hookName) {
-    return `Test: I'm generator ${hookName} hook`;
+    return `Test: I'm generator ${hookName} hook`
   }
 
   asyncStringWithHook(hookName) {
-    return `Test: I'm async/await ${hookName} hook`;
+    return `Test: I'm async/await ${hookName} hook`
   }
 
   stringWithScenarioType(type) {
-    return `Test: I'm ${type} test`;
+    return `Test: I'm ${type} test`
   }
 
   _locate() {
-    return [{ name: 'el1' }, { name: 'el2' }];
+    return [{ name: 'el1' }, { name: 'el2' }]
   }
 }
 
-module.exports = MyHelper;
+module.exports = MyHelper
diff --git a/test/graphql/GraphQLDataFactory_test.js b/test/graphql/GraphQLDataFactory_test.js
index e4e82d8d2..aa6b68d3c 100644
--- a/test/graphql/GraphQLDataFactory_test.js
+++ b/test/graphql/GraphQLDataFactory_test.js
@@ -1,16 +1,16 @@
-require('../support/setup');
-const path = require('path');
-const fs = require('fs');
+require('../support/setup')
+const path = require('path')
+const fs = require('fs')
 
-const TestHelper = require('../support/TestHelper');
+const TestHelper = require('../support/TestHelper')
 
-const GraphQLDataFactory = require('../../lib/helper/GraphQLDataFactory');
-global.codeceptjs = require('../../lib');
+const GraphQLDataFactory = require('../../lib/helper/GraphQLDataFactory')
+global.codeceptjs = require('../../lib')
 
-const graphql_url = TestHelper.graphQLServerUrl();
+const graphql_url = TestHelper.graphQLServerUrl()
 
-let I;
-const dbFile = path.join(__dirname, '/../data/graphql/db.json');
+let I
+const dbFile = path.join(__dirname, '/../data/graphql/db.json')
 
 const data = {
   users: [
@@ -21,7 +21,7 @@ const data = {
       email: 'johnd@mutex.com',
     },
   ],
-};
+}
 
 const creatUserQuery = `
       mutation createUser($input: UserInput!) {
@@ -31,16 +31,16 @@ const creatUserQuery = `
           email
         }
       }
-    `;
+    `
 
 const deleteOperationQuery = `
   mutation deleteUser($id: ID!) {
     deleteUser(id: $id)
   }
-`;
+`
 
 describe('GraphQLDataFactory', function () {
-  this.timeout(20000);
+  this.timeout(20000)
 
   before(() => {
     I = new GraphQLDataFactory({
@@ -53,59 +53,59 @@ describe('GraphQLDataFactory', function () {
             return {
               query: deleteOperationQuery,
               variables: { id: data.id },
-            };
+            }
           },
         },
       },
-    });
-  });
+    })
+  })
 
   after((done) => {
     // Prepare db.json for the next test run
     try {
-      fs.writeFileSync(dbFile, JSON.stringify(data));
+      fs.writeFileSync(dbFile, JSON.stringify(data))
     } catch (err) {
-      console.error(err);
+      console.error(err)
     }
-    setTimeout(done, 1000);
-  });
+    setTimeout(done, 1000)
+  })
 
   beforeEach((done) => {
     try {
-      fs.writeFileSync(dbFile, JSON.stringify(data));
+      fs.writeFileSync(dbFile, JSON.stringify(data))
     } catch (err) {
-      console.error(err);
+      console.error(err)
     }
-    setTimeout(done, 1000);
-  });
+    setTimeout(done, 1000)
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('create and cleanup records', function () {
-    this.retries(2);
+    this.retries(2)
 
     it('should create a new user', async () => {
-      await I.mutateData('createUser');
-      const resp = await I.graphqlHelper.sendQuery('query { users { id name } }');
-      const { users } = resp.data.data;
-      users.length.should.eql(2);
-    });
+      await I.mutateData('createUser')
+      const resp = await I.graphqlHelper.sendQuery('query { users { id name } }')
+      const { users } = resp.data.data
+      users.length.should.eql(2)
+    })
 
     it('should create a new user with predefined field', async () => {
-      const user = await I.mutateData('createUser', { name: 'radhey' });
+      const user = await I.mutateData('createUser', { name: 'radhey' })
 
-      user.name.should.eql('radhey');
-      user.id.should.eql('1');
-    });
+      user.name.should.eql('radhey')
+      user.id.should.eql('1')
+    })
 
     it('should update request with onRequest', async () => {
       I = new GraphQLDataFactory({
         endpoint: graphql_url,
         onRequest: (request) => {
           if (request.data.variables && request.data.variables.input) {
-            request.data.variables.input.name = 'Dante';
+            request.data.variables.input.name = 'Dante'
           }
         },
         factories: {
@@ -116,36 +116,36 @@ describe('GraphQLDataFactory', function () {
               return {
                 query: deleteOperationQuery,
                 variables: { id: data.id },
-              };
+              }
             },
           },
         },
-      });
-      const user = await I.mutateData('createUser');
-      user.name.should.eql('Dante');
-    });
+      })
+      const user = await I.mutateData('createUser')
+      user.name.should.eql('Dante')
+    })
 
     it('should cleanup created data', async () => {
-      const user = await I.mutateData('createUser', { name: 'Dante' });
-      user.name.should.eql('Dante');
-      user.id.should.eql('1');
-      await I._after();
-      const resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(1);
-    });
+      const user = await I.mutateData('createUser', { name: 'Dante' })
+      user.name.should.eql('Dante')
+      user.id.should.eql('1')
+      await I._after()
+      const resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(1)
+    })
 
     it('should create multiple users and cleanup after', async () => {
-      let resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(1);
+      let resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(1)
 
-      await I.mutateMultiple('createUser', 3);
-      resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(4);
+      await I.mutateMultiple('createUser', 3)
+      resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(4)
 
-      await I._after();
-      resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(1);
-    });
+      await I._after()
+      resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(1)
+    })
 
     it('should not remove records if cleanup:false', async () => {
       I = new GraphQLDataFactory({
@@ -159,17 +159,17 @@ describe('GraphQLDataFactory', function () {
               return {
                 query: deleteOperationQuery,
                 variables: { id: data.id },
-              };
+              }
             },
           },
         },
-      });
-      await I.mutateData('createUser');
-      let resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(2);
-      await I._after();
-      resp = await I.graphqlHelper.sendQuery('query { users { id } }');
-      resp.data.data.users.length.should.eql(2);
-    });
-  });
-});
+      })
+      await I.mutateData('createUser')
+      let resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(2)
+      await I._after()
+      resp = await I.graphqlHelper.sendQuery('query { users { id } }')
+      resp.data.data.users.length.should.eql(2)
+    })
+  })
+})
diff --git a/test/graphql/GraphQL_test.js b/test/graphql/GraphQL_test.js
index 371b951c9..81ecdd84d 100644
--- a/test/graphql/GraphQL_test.js
+++ b/test/graphql/GraphQL_test.js
@@ -1,15 +1,15 @@
-const path = require('path');
-const fs = require('fs');
+const path = require('path')
+const fs = require('fs')
 
-const TestHelper = require('../support/TestHelper');
-const GraphQL = require('../../lib/helper/GraphQL');
-const Container = require('../../lib/container');
-global.codeceptjs = require('../../lib');
+const TestHelper = require('../support/TestHelper')
+const GraphQL = require('../../lib/helper/GraphQL')
+const Container = require('../../lib/container')
+global.codeceptjs = require('../../lib')
 
-const graphql_url = TestHelper.graphQLServerUrl();
+const graphql_url = TestHelper.graphQLServerUrl()
 
-let I;
-const dbFile = path.join(__dirname, '/../data/graphql/db.json');
+let I
+const dbFile = path.join(__dirname, '/../data/graphql/db.json')
 
 const data = {
   users: [
@@ -20,17 +20,17 @@ const data = {
       email: 'johnd@mutex.com',
     },
   ],
-};
+}
 
 describe('GraphQL', () => {
   before((done) => {
     try {
-      fs.writeFileSync(dbFile, JSON.stringify(data));
+      fs.writeFileSync(dbFile, JSON.stringify(data))
     } catch (err) {
-      console.error(err);
+      console.error(err)
     }
-    setTimeout(done, 1500);
-  });
+    setTimeout(done, 1500)
+  })
 
   beforeEach((done) => {
     I = new GraphQL({
@@ -38,21 +38,21 @@ describe('GraphQL', () => {
       defaultHeaders: {
         'X-Test': 'test',
       },
-    });
-    done();
-  });
+    })
+    done()
+  })
 
   describe('basic queries', () => {
     it('should send a query: read', async () => {
-      const resp = await I.sendQuery('{ user(id: 0) { id name email }}');
-      const { user } = resp.data.data;
+      const resp = await I.sendQuery('{ user(id: 0) { id name email }}')
+      const { user } = resp.data.data
       user.should.eql({
         id: '0',
         name: 'john doe',
         email: 'johnd@mutex.com',
-      });
-    });
-  });
+      })
+    })
+  })
 
   describe('basic mutations', () => {
     it('should send a mutation: create', async () => {
@@ -65,7 +65,7 @@ describe('GraphQL', () => {
             age
           }
         }
-      `;
+      `
       const variables = {
         input: {
           id: 111,
@@ -73,34 +73,34 @@ describe('GraphQL', () => {
           email: 'sourab@mail.com',
           age: 23,
         },
-      };
-      const resp = await I.sendMutation(mutation, variables);
-      const { createUser } = resp.data.data;
+      }
+      const resp = await I.sendMutation(mutation, variables)
+      const { createUser } = resp.data.data
       createUser.should.eql({
         id: '111',
         name: 'Sourab',
         email: 'sourab@mail.com',
         age: 23,
-      });
-    });
+      })
+    })
 
     it('should send a mutation: delete', async () => {
       const mutation = `
         mutation deleteUser($id: ID) {
           deleteUser(id: $id)
         }
-      `;
+      `
       const variables = {
         id: 111,
-      };
-      const resp = await I.sendMutation(mutation, variables);
-      const { deleteUser } = resp.data.data;
-      deleteUser.should.eql('111');
-    });
-  });
+      }
+      const resp = await I.sendMutation(mutation, variables)
+      const { deleteUser } = resp.data.data
+      deleteUser.should.eql('111')
+    })
+  })
 
   describe('JSONResponse integration', () => {
-    let jsonResponse;
+    let jsonResponse
 
     beforeEach(() => {
       Container.create({
@@ -112,20 +112,20 @@ describe('GraphQL', () => {
             requestHelper: 'GraphQL',
           },
         },
-      });
-      I = Container.helpers('GraphQL');
-      jsonResponse = Container.helpers('JSONResponse');
-      jsonResponse._beforeSuite();
-    });
+      })
+      I = Container.helpers('GraphQL')
+      jsonResponse = Container.helpers('JSONResponse')
+      jsonResponse._beforeSuite()
+    })
 
     afterEach(() => {
-      Container.clear();
-    });
+      Container.clear()
+    })
 
     it('should be able to parse JSON responses', async () => {
-      await I.sendQuery('{ user(id: 0) { id name email }}');
-      await jsonResponse.seeResponseCodeIsSuccessful();
-      await jsonResponse.seeResponseContainsKeys(['data']);
+      await I.sendQuery('{ user(id: 0) { id name email }}')
+      await jsonResponse.seeResponseCodeIsSuccessful()
+      await jsonResponse.seeResponseContainsKeys(['data'])
       await jsonResponse.seeResponseContainsJson({
         data: {
           user: {
@@ -133,61 +133,61 @@ describe('GraphQL', () => {
             email: 'johnd@mutex.com',
           },
         },
-      });
-    });
-  });
+      })
+    })
+  })
 
   describe('headers', () => {
     it('should set headers for all requests multiple times', async () => {
-      I.haveRequestHeaders({ 'XY1-Test': 'xy1-first' });
-      I.haveRequestHeaders({ 'XY1-Test': 'xy1-second' });
-      I.haveRequestHeaders({ 'XY2-Test': 'xy2' });
+      I.haveRequestHeaders({ 'XY1-Test': 'xy1-first' })
+      I.haveRequestHeaders({ 'XY1-Test': 'xy1-second' })
+      I.haveRequestHeaders({ 'XY2-Test': 'xy2' })
 
-      const response = await I.sendQuery('{ user(id: 0) { id name email }}');
+      const response = await I.sendQuery('{ user(id: 0) { id name email }}')
 
-      response.config.headers.should.have.property('XY1-Test');
-      response.config.headers['XY1-Test'].should.eql('xy1-second');
+      response.config.headers.should.have.property('XY1-Test')
+      response.config.headers['XY1-Test'].should.eql('xy1-second')
 
-      response.config.headers.should.have.property('XY2-Test');
-      response.config.headers['XY2-Test'].should.eql('xy2');
+      response.config.headers.should.have.property('XY2-Test')
+      response.config.headers['XY2-Test'].should.eql('xy2')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should override the header set for all requests', async () => {
-      I.haveRequestHeaders({ 'XY-Test': 'first' });
+      I.haveRequestHeaders({ 'XY-Test': 'first' })
 
-      const response = await I.sendQuery('{ user(id: 0) { id name email }}');
+      const response = await I.sendQuery('{ user(id: 0) { id name email }}')
 
-      response.config.headers.should.have.property('XY-Test');
-      response.config.headers['XY-Test'].should.eql('first');
+      response.config.headers.should.have.property('XY-Test')
+      response.config.headers['XY-Test'].should.eql('first')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should set Bearer authorization', async () => {
-      I.amBearerAuthenticated('token');
-      const response = await I.sendQuery('{ user(id: 0) { id name email }}');
+      I.amBearerAuthenticated('token')
+      const response = await I.sendQuery('{ user(id: 0) { id name email }}')
 
-      response.config.headers.should.have.property('Authorization');
-      response.config.headers.Authorization.should.eql('Bearer token');
+      response.config.headers.should.have.property('Authorization')
+      response.config.headers.Authorization.should.eql('Bearer token')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should set Bearer authorization multiple times', async () => {
-      I.amBearerAuthenticated('token1');
-      I.amBearerAuthenticated('token2');
-      const response = await I.sendQuery('{ user(id: 0) { id name email }}');
-
-      response.config.headers.should.have.property('Authorization');
-      response.config.headers.Authorization.should.eql('Bearer token2');
-
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
-  });
-});
+      I.amBearerAuthenticated('token1')
+      I.amBearerAuthenticated('token2')
+      const response = await I.sendQuery('{ user(id: 0) { id name email }}')
+
+      response.config.headers.should.have.property('Authorization')
+      response.config.headers.Authorization.should.eql('Bearer token2')
+
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
+  })
+})
diff --git a/test/helper/AppiumV2Web_test.js b/test/helper/AppiumV2Web_test.js
index 67e0e050e..66ad70f4b 100644
--- a/test/helper/AppiumV2Web_test.js
+++ b/test/helper/AppiumV2Web_test.js
@@ -1,12 +1,12 @@
-const Appium = require('../../lib/helper/Appium');
-global.codeceptjs = require('../../lib');
+const Appium = require('../../lib/helper/Appium')
+global.codeceptjs = require('../../lib')
 
-let I;
-const site_url = 'http://davertmik.github.io';
+let I
+const site_url = 'http://davertmik.github.io'
 
 describe('Appium Web', function () {
-  this.retries(4);
-  this.timeout(70000);
+  this.retries(4)
+  this.timeout(70000)
 
   before(() => {
     I = new Appium({
@@ -30,136 +30,136 @@ describe('Appium Web', function () {
       // host: 'localhost',
       user: process.env.SAUCE_USERNAME,
       key: process.env.SAUCE_ACCESS_KEY,
-    });
+    })
     // I.isWeb = true;
-    I._init();
-    I._beforeSuite();
-  });
+    I._init()
+    I._beforeSuite()
+  })
 
-  after(() => I._finishTest());
+  after(() => I._finishTest())
 
   beforeEach(() => {
-    I.isWeb = true;
-    return I._before();
-  });
+    I.isWeb = true
+    return I._before()
+  })
 
-  afterEach(() => I._after());
+  afterEach(() => I._after())
 
   describe('current url : #seeInCurrentUrl, #seeCurrentUrlEquals, ...', () => {
     it('should check for url fragment', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.seeInCurrentUrl('/info');
-      await I.dontSeeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.seeInCurrentUrl('/info')
+      await I.dontSeeInCurrentUrl('/result')
+    })
 
     it('should check for equality', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.seeCurrentUrlEquals('/angular-demo-app/#/info');
-      await I.dontSeeCurrentUrlEquals('/angular-demo-app/#/result');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.seeCurrentUrlEquals('/angular-demo-app/#/info')
+      await I.dontSeeCurrentUrlEquals('/angular-demo-app/#/result')
+    })
+  })
 
   describe('see text : #see', () => {
     it('should check text on site', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.see('Description');
-      await I.dontSee('Create Event Today');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.see('Description')
+      await I.dontSee('Create Event Today')
+    })
 
     it('should check text inside element', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.see('About', 'h1');
-      await I.see('Welcome to event app', { css: 'p.jumbotron' });
-      await I.see('Back to form', '//div/a');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.see('About', 'h1')
+      await I.see('Welcome to event app', { css: 'p.jumbotron' })
+      await I.see('Back to form', '//div/a')
+    })
+  })
 
   describe('see element : #seeElement, #dontSeeElement', () => {
     it('should check visible elements on page', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.seeElement('.btn.btn-primary');
-      await I.seeElement({ css: '.btn.btn-primary' });
-      await I.dontSeeElement({ css: '.btn.btn-secondary' });
-    });
-  });
+      await I.amOnPage('/angular-demo-app/')
+      await I.seeElement('.btn.btn-primary')
+      await I.seeElement({ css: '.btn.btn-primary' })
+      await I.dontSeeElement({ css: '.btn.btn-secondary' })
+    })
+  })
 
   describe('#click', () => {
     it('should click by text', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.dontSeeInCurrentUrl('/info');
-      await I.click('Get more info!');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.dontSeeInCurrentUrl('/info')
+      await I.click('Get more info!')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click by css', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('.btn-primary');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('.btn-primary')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click by non-optimal css', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('form a.btn');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('form a.btn')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click by xpath', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('//a[contains(., "more info")]');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('//a[contains(., "more info")]')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click on context', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('.btn-primary', 'form');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('.btn-primary', 'form')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click link with inner span', async () => {
-      await I.amOnPage('/angular-demo-app/#/result');
-      await I.click('Go to info');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/#/result')
+      await I.click('Go to info')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click buttons as links', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('Options');
-      await I.seeInCurrentUrl('/options');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('Options')
+      await I.seeInCurrentUrl('/options')
+    })
+  })
 
   describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom', () => {
     it('should grab text from page', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      const val = await I.grabTextFrom('p.jumbotron');
-      val.should.be.equal('Welcome to event app');
-    });
+      await I.amOnPage('/angular-demo-app/#/info')
+      const val = await I.grabTextFrom('p.jumbotron')
+      val.should.be.equal('Welcome to event app')
+    })
 
     it('should grab value from field', async () => {
-      await I.amOnPage('/angular-demo-app/#/options');
-      const val = await I.grabValueFrom('#ssh');
-      val.should.be.equal('PUBLIC-SSH-KEY');
-    });
+      await I.amOnPage('/angular-demo-app/#/options')
+      const val = await I.grabValueFrom('#ssh')
+      val.should.be.equal('PUBLIC-SSH-KEY')
+    })
 
     it('should grab attribute from element', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      const val = await I.grabAttributeFrom('a.btn', 'ng-href');
-      val.should.be.equal('#/');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      const val = await I.grabAttributeFrom('a.btn', 'ng-href')
+      val.should.be.equal('#/')
+    })
+  })
 
   describe('#within', () => {
-    afterEach(() => I._withinEnd());
+    afterEach(() => I._withinEnd())
 
     it('should work using within operator', async () => {
-      await I.amOnPage('/angular-demo-app/#/options');
-      await I.see('Choose if you ok with terms');
-      await I._withinBegin({ css: 'div.results' });
-      await I.see('SSH Public Key: PUBLIC-SSH-KEY');
-      await I.dontSee('Options');
-    });
-  });
-});
+      await I.amOnPage('/angular-demo-app/#/options')
+      await I.see('Choose if you ok with terms')
+      await I._withinBegin({ css: 'div.results' })
+      await I.see('SSH Public Key: PUBLIC-SSH-KEY')
+      await I.dontSee('Options')
+    })
+  })
+})
diff --git a/test/helper/AppiumV2_ios_test.js b/test/helper/AppiumV2_ios_test.js
index 5595cc8e6..c23b3e423 100644
--- a/test/helper/AppiumV2_ios_test.js
+++ b/test/helper/AppiumV2_ios_test.js
@@ -1,21 +1,21 @@
-const assert = require('assert');
-const path = require('path');
+const assert = require('assert')
+const path = require('path')
 
-const Appium = require('../../lib/helper/Appium');
-const AssertionFailedError = require('../../lib/assert/error');
-const fileExists = require('../../lib/utils').fileExists;
-global.codeceptjs = require('../../lib');
+const Appium = require('../../lib/helper/Appium')
+const AssertionFailedError = require('../../lib/assert/error')
+const fileExists = require('../../lib/utils').fileExists
+global.codeceptjs = require('../../lib')
 
-let app;
+let app
 // iOS test app is built from https://github.com/appium/ios-test-app and uploaded to Saucelabs
-const apk_path = 'storage:filename=TestApp-iphonesimulator.zip';
-const smallWait = 3;
+const apk_path = 'storage:filename=TestApp-iphonesimulator.zip'
+const smallWait = 3
 
 describe('Appium iOS Tests', function () {
-  this.timeout(0);
+  this.timeout(0)
 
   before(async () => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     app = new Appium({
       app: apk_path,
       appiumV2: true,
@@ -38,165 +38,166 @@ describe('Appium iOS Tests', function () {
       port: 80,
       user: process.env.SAUCE_USERNAME,
       key: process.env.SAUCE_ACCESS_KEY,
-    });
-    await app._beforeSuite();
-    app.isWeb = false;
-    await app._before();
-  });
+    })
+    await app._beforeSuite()
+    app.isWeb = false
+    await app._before()
+  })
 
   after(async () => {
-    await app._after();
-  });
+    await app._after()
+  })
 
   describe('app installation : #removeApp', () => {
-    describe(
-      '#grabAllContexts, #grabContext, #grabOrientation, #grabSettings',
-      () => {
-        it('should grab all available contexts for screen', async () => {
-          await app.resetApp();
-          const val = await app.grabAllContexts();
-          assert.deepEqual(val, ['NATIVE_APP']);
-        });
-
-        it('should grab current context', async () => {
-          const val = await app.grabContext();
-          assert.equal(val, 'NATIVE_APP');
-        });
-
-        it('should grab custom settings', async () => {
-          const val = await app.grabSettings();
-          assert.deepEqual(val, { imageElementTapStrategy: 'w3cActions' });
-        });
-      },
-    );
-  });
+    describe('#grabAllContexts, #grabContext, #grabOrientation, #grabSettings', () => {
+      it('should grab all available contexts for screen', async () => {
+        await app.resetApp()
+        const val = await app.grabAllContexts()
+        assert.deepEqual(val, ['NATIVE_APP'])
+      })
+
+      it('should grab current context', async () => {
+        const val = await app.grabContext()
+        assert.equal(val, 'NATIVE_APP')
+      })
+
+      it('should grab custom settings', async () => {
+        const val = await app.grabSettings()
+        assert.deepEqual(val, { imageElementTapStrategy: 'w3cActions' })
+      })
+    })
+  })
 
   describe('device orientation : #seeOrientationIs #setOrientation', () => {
     it('should return correct status about device orientation', async () => {
-      await app.seeOrientationIs('PORTRAIT');
+      await app.seeOrientationIs('PORTRAIT')
       try {
-        await app.seeOrientationIs('LANDSCAPE');
+        await app.seeOrientationIs('LANDSCAPE')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected orientation to be LANDSCAPE');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected orientation to be LANDSCAPE')
       }
-    });
-  });
+    })
+  })
 
   describe('#hideDeviceKeyboard', () => {
     it('should hide device Keyboard @quick', async () => {
-      await app.resetApp();
-      await app.click('~IntegerA');
+      await app.resetApp()
+      await app.click('~IntegerA')
       try {
-        await app.click('~locationStatus');
+        await app.click('~locationStatus')
       } catch (e) {
-        e.message.should.include('element');
+        e.message.should.include('element')
       }
-      await app.hideDeviceKeyboard('pressKey', 'Done');
-      await app.click('~locationStatus');
-    });
+      await app.hideDeviceKeyboard('pressKey', 'Done')
+      await app.click('~locationStatus')
+    })
 
     it('should assert if no keyboard', async () => {
       try {
-        await app.hideDeviceKeyboard('pressKey', 'Done');
+        await app.hideDeviceKeyboard('pressKey', 'Done')
       } catch (e) {
-        e.message.should.include('An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard');
+        e.message.should.include(
+          'An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard',
+        )
       }
-    });
-  });
+    })
+  })
 
   describe('see text : #see', () => {
     it('should work inside elements @second', async () => {
-      await app.resetApp();
-      await app.see('Compute Sum', '~ComputeSumButton');
-    });
-  });
+      await app.resetApp()
+      await app.see('Compute Sum', '~ComputeSumButton')
+    })
+  })
 
   describe('#appendField', () => {
     it('should be able to send special keys to element @second', async () => {
-      await app.resetApp();
-      await app.waitForElement('~IntegerA', smallWait);
-      await app.click('~IntegerA');
-      await app.appendField('~IntegerA', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
-      await app.see('1', '~IntegerA');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~IntegerA', smallWait)
+      await app.click('~IntegerA')
+      await app.appendField('~IntegerA', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
+      await app.see('1', '~IntegerA')
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', async () => {
       try {
-        await app.waitForText('Nothing here', 1, '~IntegerA');
+        await app.waitForText('Nothing here', 1, '~IntegerA')
       } catch (e) {
-        e.message.should.contain('element (~IntegerA) is not in DOM or there is no element(~IntegerA) with text "Nothing here" after 1 sec');
+        e.message.should.contain(
+          'element (~IntegerA) is not in DOM or there is no element(~IntegerA) with text "Nothing here" after 1 sec',
+        )
       }
-    });
-  });
+    })
+  })
 
   describe('#seeNumberOfElements @second', () => {
     it('should return 1 as count', async () => {
-      await app.resetApp();
-      await app.seeNumberOfElements('~IntegerA', 1);
-    });
-  });
+      await app.resetApp()
+      await app.seeNumberOfElements('~IntegerA', 1)
+    })
+  })
 
   describe('see element : #seeElement, #dontSeeElement', () => {
     it('should check visible elements on page @quick', async () => {
-      await app.resetApp();
-      await app.seeElement('~IntegerA');
-      await app.dontSeeElement('#something-beyond');
-      await app.dontSeeElement('//input[@id="something-beyond"]');
-    });
-  });
+      await app.resetApp()
+      await app.seeElement('~IntegerA')
+      await app.dontSeeElement('#something-beyond')
+      await app.dontSeeElement('//input[@id="something-beyond"]')
+    })
+  })
 
   describe('#click @quick', () => {
     it('should click by accessibility id', async () => {
-      await app.resetApp();
-      await app.tap('~ComputeSumButton');
-      await app.see('0');
-    });
-  });
+      await app.resetApp()
+      await app.tap('~ComputeSumButton')
+      await app.see('0')
+    })
+  })
 
   describe('#fillField @second', () => {
     it('should fill field by accessibility id', async () => {
-      await app.resetApp();
-      await app.waitForElement('~IntegerA', smallWait);
-      await app.click('~IntegerA');
-      await app.fillField('~IntegerA', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
-      await app.see('1', '~IntegerA');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~IntegerA', smallWait)
+      await app.click('~IntegerA')
+      await app.fillField('~IntegerA', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
+      await app.see('1', '~IntegerA')
+    })
+  })
 
   describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom @quick', () => {
     it('should grab text from page', async () => {
-      await app.resetApp();
-      const val = await app.grabTextFrom('~ComputeSumButton');
-      assert.equal(val, 'Compute Sum');
-    });
+      await app.resetApp()
+      const val = await app.grabTextFrom('~ComputeSumButton')
+      assert.equal(val, 'Compute Sum')
+    })
 
     it('should grab attribute from element', async () => {
-      await app.resetApp();
-      const val = await app.grabAttributeFrom('~ComputeSumButton', 'label');
-      assert.equal(val, 'Compute Sum');
-    });
+      await app.resetApp()
+      const val = await app.grabAttributeFrom('~ComputeSumButton', 'label')
+      assert.equal(val, 'Compute Sum')
+    })
 
     it('should be able to grab elements', async () => {
-      await app.resetApp();
-      const id = await app.grabNumberOfVisibleElements('~ComputeSumButton');
-      assert.strictEqual(1, id);
-    });
-  });
+      await app.resetApp()
+      const id = await app.grabNumberOfVisibleElements('~ComputeSumButton')
+      assert.strictEqual(1, id)
+    })
+  })
 
   describe('#saveScreenshot', () => {
     beforeEach(() => {
-      global.output_dir = path.join(global.codecept_dir, 'output');
-    });
+      global.output_dir = path.join(global.codecept_dir, 'output')
+    })
 
     it('should create a screenshot file in output dir', async () => {
-      const sec = (new Date()).getUTCMilliseconds();
-      await app.saveScreenshot(`screenshot_${sec}.png`);
-      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists');
-    });
-  });
-});
+      const sec = new Date().getUTCMilliseconds()
+      await app.saveScreenshot(`screenshot_${sec}.png`)
+      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists')
+    })
+  })
+})
diff --git a/test/helper/AppiumV2_test.js b/test/helper/AppiumV2_test.js
index 2d671ef93..16272b84d 100644
--- a/test/helper/AppiumV2_test.js
+++ b/test/helper/AppiumV2_test.js
@@ -1,26 +1,26 @@
-const assert = require('assert');
+const assert = require('assert')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
 
-const Appium = require('../../lib/helper/Appium');
-const AssertionFailedError = require('../../lib/assert/error');
-const fileExists = require('../../lib/utils').fileExists;
-global.codeceptjs = require('../../lib');
+const Appium = require('../../lib/helper/Appium')
+const AssertionFailedError = require('../../lib/assert/error')
+const fileExists = require('../../lib/utils').fileExists
+global.codeceptjs = require('../../lib')
 
-let app;
-const apk_path = 'storage:filename=selendroid-test-app-0.17.0.apk';
-const smallWait = 3;
+let app
+const apk_path = 'storage:filename=selendroid-test-app-0.17.0.apk'
+const smallWait = 3
 
 describe('Appium', function () {
   // this.retries(1);
-  this.timeout(0);
+  this.timeout(0)
 
   before(async () => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     app = new Appium({
       app: apk_path,
       appiumV2: true,
@@ -45,359 +45,392 @@ describe('Appium', function () {
       // host: 'localhost',
       user: process.env.SAUCE_USERNAME,
       key: process.env.SAUCE_ACCESS_KEY,
-    });
-    await app._beforeSuite();
-    app.isWeb = false;
-    await app._before();
-  });
+    })
+    await app._beforeSuite()
+    app.isWeb = false
+    await app._before()
+  })
 
   after(async () => {
-    await app._after();
-  });
+    await app._after()
+  })
 
   describe('app installation : #seeAppIsInstalled, #installApp, #removeApp, #seeAppIsNotInstalled', () => {
-    describe(
-      '#grabAllContexts, #grabContext, #grabCurrentActivity, #grabNetworkConnection, #grabOrientation, #grabSettings',
-      () => {
-        it('should grab all available contexts for screen', async () => {
-          await app.resetApp();
-          await app.waitForElement('~buttonStartWebviewCD', smallWait);
-          await app.click('~buttonStartWebviewCD');
-          const val = await app.grabAllContexts();
-          assert.deepEqual(val, ['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp']);
-        });
-
-        it('should grab current context', async () => {
-          const val = await app.grabContext();
-          assert.equal(val, 'NATIVE_APP');
-        });
-
-        it('should grab current activity of app', async () => {
-          const val = await app.grabCurrentActivity();
-          assert.equal(val, '.HomeScreenActivity');
-        });
-
-        it('should grab network connection settings', async () => {
-          await app.setNetworkConnection(4);
-          const val = await app.grabNetworkConnection();
-          assert.equal(val.value, 4);
-          assert.equal(val.inAirplaneMode, false);
-          assert.equal(val.hasWifi, false);
-          assert.equal(val.hasData, true);
-        });
-
-        it('should grab orientation', async () => {
-          const val = await app.grabOrientation();
-          assert.equal(val, 'PORTRAIT');
-        });
-
-        it('should grab custom settings', async () => {
-          const val = await app.grabSettings();
-          assert.deepEqual(val, { ignoreUnimportantViews: false });
-        });
-      },
-    );
+    describe('#grabAllContexts, #grabContext, #grabCurrentActivity, #grabNetworkConnection, #grabOrientation, #grabSettings', () => {
+      it('should grab all available contexts for screen', async () => {
+        await app.resetApp()
+        await app.waitForElement('~buttonStartWebviewCD', smallWait)
+        await app.click('~buttonStartWebviewCD')
+        const val = await app.grabAllContexts()
+        assert.deepEqual(val, ['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp'])
+      })
+
+      it('should grab current context', async () => {
+        const val = await app.grabContext()
+        assert.equal(val, 'NATIVE_APP')
+      })
+
+      it('should grab current activity of app', async () => {
+        const val = await app.grabCurrentActivity()
+        assert.equal(val, '.HomeScreenActivity')
+      })
+
+      it('should grab network connection settings', async () => {
+        await app.setNetworkConnection(4)
+        const val = await app.grabNetworkConnection()
+        assert.equal(val.value, 4)
+        assert.equal(val.inAirplaneMode, false)
+        assert.equal(val.hasWifi, false)
+        assert.equal(val.hasData, true)
+      })
+
+      it('should grab orientation', async () => {
+        const val = await app.grabOrientation()
+        assert.equal(val, 'PORTRAIT')
+      })
+
+      it('should grab custom settings', async () => {
+        const val = await app.grabSettings()
+        assert.deepEqual(val, { ignoreUnimportantViews: false })
+      })
+    })
 
     it('should remove App and install it again', async () => {
-      await app.seeAppIsInstalled('io.selendroid.testapp');
-      await app.removeApp('io.selendroid.testapp');
-      await app.seeAppIsNotInstalled('io.selendroid.testapp');
-      await app.installApp(apk_path);
-      await app.seeAppIsInstalled('io.selendroid.testapp');
-    });
+      await app.seeAppIsInstalled('io.selendroid.testapp')
+      await app.removeApp('io.selendroid.testapp')
+      await app.seeAppIsNotInstalled('io.selendroid.testapp')
+      await app.installApp(apk_path)
+      await app.seeAppIsInstalled('io.selendroid.testapp')
+    })
 
     it('should return true if app is installed @quick', async () => {
-      const status = await app.checkIfAppIsInstalled('io.selendroid.testapp');
-      expect(status).to.be.true;
-    });
+      const status = await app.checkIfAppIsInstalled('io.selendroid.testapp')
+      expect(status).to.be.true
+    })
 
     it('should assert when app is/is not installed', async () => {
       try {
-        await app.seeAppIsInstalled('io.super.app');
+        await app.seeAppIsInstalled('io.super.app')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected app io.super.app to be installed');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected app io.super.app to be installed')
       }
 
       try {
-        await app.seeAppIsNotInstalled('io.selendroid.testapp');
+        await app.seeAppIsNotInstalled('io.selendroid.testapp')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected app io.selendroid.testapp not to be installed');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected app io.selendroid.testapp not to be installed')
       }
-    });
-  });
+    })
+  })
 
   describe('see seeCurrentActivity: #seeCurrentActivityIs', () => {
     it('should return .HomeScreenActivity for default screen', async () => {
-      await app.seeCurrentActivityIs('.HomeScreenActivity');
-    });
+      await app.seeCurrentActivityIs('.HomeScreenActivity')
+    })
 
     it('should assert for wrong screen', async () => {
       try {
-        await app.seeCurrentActivityIs('.SuperScreen');
+        await app.seeCurrentActivityIs('.SuperScreen')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected current activity to be .SuperScreen');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected current activity to be .SuperScreen')
       }
-    });
-  });
+    })
+  })
 
   describe('device lock : #seeDeviceIsLocked, #seeDeviceIsUnlocked', () => {
     it('should return correct status about lock @second', async () => {
-      await app.seeDeviceIsUnlocked();
+      await app.seeDeviceIsUnlocked()
       try {
-        await app.seeDeviceIsLocked();
+        await app.seeDeviceIsLocked()
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected device to be locked');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected device to be locked')
       }
-    });
-  });
+    })
+  })
 
   describe('device orientation : #seeOrientationIs #setOrientation', () => {
     it('should return correct status about lock', async () => {
-      await app.seeOrientationIs('PORTRAIT');
+      await app.seeOrientationIs('PORTRAIT')
       try {
-        await app.seeOrientationIs('LANDSCAPE');
+        await app.seeOrientationIs('LANDSCAPE')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected orientation to be LANDSCAPE');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected orientation to be LANDSCAPE')
       }
-    });
+    })
 
     it('should set device orientation', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.click('~buttonStartWebviewCD');
-      await app.setOrientation('LANDSCAPE');
-      await app.seeOrientationIs('LANDSCAPE');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.click('~buttonStartWebviewCD')
+      await app.setOrientation('LANDSCAPE')
+      await app.seeOrientationIs('LANDSCAPE')
+    })
+  })
 
   describe('app context and activity: #switchToContext, #switchToWeb, #switchToNative', () => {
     it('should switch context', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.click('~buttonStartWebviewCD');
-      await app.switchToContext('WEBVIEW_io.selendroid.testapp');
-      const val = await app.grabContext();
-      return assert.equal(val, 'WEBVIEW_io.selendroid.testapp');
-    });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.click('~buttonStartWebviewCD')
+      await app.switchToContext('WEBVIEW_io.selendroid.testapp')
+      const val = await app.grabContext()
+      return assert.equal(val, 'WEBVIEW_io.selendroid.testapp')
+    })
 
     it('should switch to native and web contexts @quick', async () => {
-      await app.resetApp();
-      await app.click('~buttonStartWebviewCD');
-      await app.see('WebView location');
-      await app.switchToWeb();
-      let val = await app.grabContext();
-      assert.equal(val, 'WEBVIEW_io.selendroid.testapp');
-      await app.see('Prefered Car');
-      assert.ok(app.isWeb);
-      await app.switchToNative();
-      val = await app.grabContext();
-      assert.equal(val, 'NATIVE_APP');
-      return assert.ok(!app.isWeb);
-    });
+      await app.resetApp()
+      await app.click('~buttonStartWebviewCD')
+      await app.see('WebView location')
+      await app.switchToWeb()
+      let val = await app.grabContext()
+      assert.equal(val, 'WEBVIEW_io.selendroid.testapp')
+      await app.see('Prefered Car')
+      assert.ok(app.isWeb)
+      await app.switchToNative()
+      val = await app.grabContext()
+      assert.equal(val, 'NATIVE_APP')
+      return assert.ok(!app.isWeb)
+    })
 
     it('should switch activity', async () => {
-      await app.startActivity('io.selendroid.testapp', '.RegisterUserActivity');
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.RegisterUserActivity');
-    });
-  });
+      await app.startActivity('io.selendroid.testapp', '.RegisterUserActivity')
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.RegisterUserActivity')
+    })
+  })
 
   describe('#setNetworkConnection, #setSettings', () => {
     it('should set Network Connection (airplane mode on)', async () => {
-      await app.setNetworkConnection(1);
-      const val = await app.grabNetworkConnection();
-      return assert.equal(val.value, 1);
-    });
+      await app.setNetworkConnection(1)
+      const val = await app.grabNetworkConnection()
+      return assert.equal(val.value, 1)
+    })
 
     it('should set custom settings', async () => {
-      await app.setSettings({ cyberdelia: 'open' });
-      const val = await app.grabSettings();
-      assert.deepEqual(val, { ignoreUnimportantViews: false, cyberdelia: 'open' });
-    });
-  });
+      await app.setSettings({ cyberdelia: 'open' })
+      const val = await app.grabSettings()
+      assert.deepEqual(val, { ignoreUnimportantViews: false, cyberdelia: 'open' })
+    })
+  })
 
   describe('#hideDeviceKeyboard', () => {
     it('should hide device Keyboard @quick', async () => {
-      await app.resetApp();
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.click('~startUserRegistrationCD')
       try {
-        await app.click('//android.widget.CheckBox');
+        await app.click('//android.widget.CheckBox')
       } catch (e) {
-        e.message.should.include('element');
+        e.message.should.include('element')
       }
-      await app.hideDeviceKeyboard('pressKey', 'Done');
-      await app.click('//android.widget.CheckBox');
-    });
+      await app.hideDeviceKeyboard('pressKey', 'Done')
+      await app.click('//android.widget.CheckBox')
+    })
 
     it('should assert if no keyboard', async () => {
       try {
-        await app.hideDeviceKeyboard('pressKey', 'Done');
+        await app.hideDeviceKeyboard('pressKey', 'Done')
       } catch (e) {
-        e.message.should.include('An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard');
+        e.message.should.include(
+          'An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard',
+        )
       }
-    });
-  });
+    })
+  })
 
   describe('#sendDeviceKeyEvent', () => {
     it('should react on pressing keycode', async () => {
-      await app.sendDeviceKeyEvent(3);
-      await app.waitForVisible('~Apps');
-    });
-  });
+      await app.sendDeviceKeyEvent(3)
+      await app.waitForVisible('~Apps')
+    })
+  })
 
   describe('#openNotifications', () => {
     it('should react on notification opening', async () => {
       try {
-        await app.seeElement('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]');
+        await app.seeElement(
+          '//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]',
+        )
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected elements of //android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"] to be seen');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include(
+          'expected elements of //android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"] to be seen',
+        )
       }
-      await app.openNotifications();
-      await app.waitForVisible('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]', 10);
-    });
-  });
+      await app.openNotifications()
+      await app.waitForVisible(
+        '//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]',
+        10,
+      )
+    })
+  })
 
   describe('#makeTouchAction', () => {
     it('should react on touch actions', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.tap('~buttonStartWebviewCD');
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.WebViewActivity');
-    });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.tap('~buttonStartWebviewCD')
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.WebViewActivity')
+    })
 
     it('should react on swipe action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipe(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vx = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vx.match(/vx: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vx = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vx.match(/vx: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeDown action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeDown(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('run simplified swipeDown @quick', async () => {
-      await app.resetApp();
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.resetApp()
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeDown(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         120,
         100,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      assert.equal(type, 'FLICK');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      assert.equal(type, 'FLICK')
+    })
 
     it('should react on swipeUp action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeUp(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vy: -\d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vy: -\d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeRight action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeRight(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vx: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vx: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeLeft action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeLeft(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vx: -\d\d000\.0 pps/), 'to be like 21000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vx: -\d\d000\.0 pps/), 'to be like 21000.0 pps')
+    })
 
     it('should react on touchPerform action', async () => {
-      await app.touchPerform([{
-        action: 'press',
-        options: {
-          x: 100,
-          y: 200,
+      await app.touchPerform([
+        {
+          action: 'press',
+          options: {
+            x: 100,
+            y: 200,
+          },
         },
-      }, { action: 'release' }]);
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.HomeScreenActivity');
-    });
+        { action: 'release' },
+      ])
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.HomeScreenActivity')
+    })
 
     it('should assert when you dont scroll the document anymore', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
       try {
         await app.swipeTo(
           '//android.widget.CheckBox',
@@ -406,16 +439,16 @@ describe('Appium', function () {
           30,
           100,
           500,
-        );
+        )
       } catch (e) {
-        e.message.should.include('Scroll to the end and element android.widget.CheckBox was not found');
+        e.message.should.include('Scroll to the end and element android.widget.CheckBox was not found')
       }
-    });
+    })
 
     it('should react on swipeTo action', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
       await app.swipeTo(
         '//android.widget.CheckBox',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -423,101 +456,121 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-    });
+      )
+    })
 
     describe('#performTouchAction', () => {
       it('should react on swipeUp action @second', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(parseInt(vy.split(' ')[1], 10)).to.be.below(1006);
-      });
+        )
+        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(parseInt(vy.split(' ')[1], 10)).to.be.below(1006)
+      })
 
       it('should react on swipeDown action @second', async () => {
-        await app.resetApp();
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.resetApp()
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(parseInt(vy.split(' ')[1], 10)).to.be.above(-300);
-      });
+        )
+        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(parseInt(vy.split(' ')[1], 10)).to.be.above(-300)
+      })
 
       it('should react on swipeLeft action', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeLeft("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(vy.split(' ')[1]).to.be.below(730);
-      });
+        )
+        await app.swipeLeft(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(vy.split(' ')[1]).to.be.below(730)
+      })
 
       it('should react on swipeRight action', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeRight("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(vy.split(' ')[1]).to.be.above(278);
-      });
-    });
-  });
+        )
+        await app.swipeRight(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(vy.split(' ')[1]).to.be.above(278)
+      })
+    })
+  })
 
   describe('#pullFile', () => {
     it('should pull file to local machine', async () => {
-      const savepath = path.join(__dirname, `/../data/output/testpullfile${new Date().getTime()}.png`);
-      await app.pullFile('/storage/emulated/0/DCIM/sauce_logo.png', savepath);
-      assert.ok(fileExists(savepath), null, 'file does not exists');
-    });
-  });
+      const savepath = path.join(__dirname, `/../data/output/testpullfile${new Date().getTime()}.png`)
+      await app.pullFile('/storage/emulated/0/DCIM/sauce_logo.png', savepath)
+      assert.ok(fileExists(savepath), null, 'file does not exists')
+    })
+  })
 
   describe('see text : #see', () => {
     it('should work inside elements @second', async () => {
-      await app.resetApp();
-      await app.see('EN Button', '~buttonTestCD');
-      await app.see('Hello');
-      await app.dontSee('Welcome', '~buttonTestCD');
-    });
+      await app.resetApp()
+      await app.see('EN Button', '~buttonTestCD')
+      await app.see('Hello')
+      await app.dontSee('Welcome', '~buttonTestCD')
+    })
 
     it('should work inside web view as normally @quick', async () => {
-      await app.resetApp();
-      await app.click('~buttonStartWebviewCD');
-      await app.switchToWeb();
-      await app.see('Prefered Car:');
-    });
-  });
+      await app.resetApp()
+      await app.click('~buttonStartWebviewCD')
+      await app.switchToWeb()
+      await app.see('Prefered Car:')
+    })
+  })
 
   describe('#appendField', () => {
     it('should be able to send special keys to element @second', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.click('~email of the customer');
-      await app.appendField('~email of the customer', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.click('~email of the customer')
+      await app.appendField('~email of the customer', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -525,70 +578,67 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
-      await app.see(
-        '1',
-        '#io.selendroid.testapp:id/label_email_data',
-      );
-    });
-  });
+      )
+      await app.click('//android.widget.Button')
+      await app.see('1', '#io.selendroid.testapp:id/label_email_data')
+    })
+  })
 
   describe('#seeInSource', () => {
     it('should check for text to be in HTML source', async () => {
-      await app.seeInSource('class="android.widget.Button" package="io.selendroid.testapp" content-desc="buttonTestCD"');
-      await app.dontSeeInSource('<meta');
-    });
-  });
+      await app.seeInSource('class="android.widget.Button" package="io.selendroid.testapp" content-desc="buttonTestCD"')
+      await app.dontSeeInSource('<meta')
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', async () => {
       try {
-        await app.waitForText('Nothing here', 1, '~buttonTestCD');
+        await app.waitForText('Nothing here', 1, '~buttonTestCD')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected element ~buttonTestCD to include "Nothing here"');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.be.equal('expected element ~buttonTestCD to include "Nothing here"')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeNumberOfElements @second', () => {
     it('should return 1 as count', async () => {
-      await app.resetApp();
-      await app.seeNumberOfElements('~buttonTestCD', 1);
-    });
-  });
+      await app.resetApp()
+      await app.seeNumberOfElements('~buttonTestCD', 1)
+    })
+  })
 
   describe('see element : #seeElement, #dontSeeElement', () => {
     it('should check visible elements on page @quick', async () => {
-      await app.resetApp();
-      await app.seeElement('//android.widget.Button[@content-desc = "buttonTestCD"]');
-      await app.dontSeeElement('#something-beyond');
-      await app.dontSeeElement('//input[@id="something-beyond"]');
-    });
-  });
+      await app.resetApp()
+      await app.seeElement('//android.widget.Button[@content-desc = "buttonTestCD"]')
+      await app.dontSeeElement('#something-beyond')
+      await app.dontSeeElement('//input[@id="something-beyond"]')
+    })
+  })
 
   describe('#click @quick', () => {
     it('should click by accessibility id', async () => {
-      await app.resetApp();
-      await app.tap('~startUserRegistrationCD');
-      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]');
-    });
+      await app.resetApp()
+      await app.tap('~startUserRegistrationCD')
+      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]')
+    })
 
     it('should click by xpath', async () => {
-      await app.resetApp();
-      await app.click('//android.widget.ImageButton[@content-desc = "startUserRegistrationCD"]');
-      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]');
-    });
-  });
+      await app.resetApp()
+      await app.click('//android.widget.ImageButton[@content-desc = "startUserRegistrationCD"]')
+      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]')
+    })
+  })
 
   describe('#fillField, #appendField @second', () => {
     it('should fill field by accessibility id', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -596,20 +646,20 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing special',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
+      )
+    })
 
     it('should fill field by xpath', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('//android.widget.EditText[@content-desc="email of the customer"]', 'Nothing special');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('//android.widget.EditText[@content-desc="email of the customer"]', 'Nothing special')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -617,21 +667,21 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing special',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
+      )
+    })
 
     it('should append field value @second', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.appendField('~email of the customer', 'blabla');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.appendField('~email of the customer', 'blabla')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -639,46 +689,46 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing specialblabla',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('#clearField', () => {
     it('should clear a given element', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.see('Nothing special', '~email of the customer');
-      await app.clearField('~email of the customer');
-      await app.dontSee('Nothing special', '~email of the customer');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.see('Nothing special', '~email of the customer')
+      await app.clearField('~email of the customer')
+      await app.dontSee('Nothing special', '~email of the customer')
+    })
+  })
 
   describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom @quick', () => {
     it('should grab text from page', async () => {
-      await app.resetApp();
-      const val = await app.grabTextFrom('//android.widget.Button[@content-desc="buttonTestCD"]');
-      assert.equal(val, 'EN Button');
-    });
+      await app.resetApp()
+      const val = await app.grabTextFrom('//android.widget.Button[@content-desc="buttonTestCD"]')
+      assert.equal(val, 'EN Button')
+    })
 
     it('should grab attribute from element', async () => {
-      await app.resetApp();
-      const val = await app.grabAttributeFrom('//android.widget.Button[@content-desc="buttonTestCD"]', 'resourceId');
-      assert.equal(val, 'io.selendroid.testapp:id/buttonTest');
-    });
+      await app.resetApp()
+      const val = await app.grabAttributeFrom('//android.widget.Button[@content-desc="buttonTestCD"]', 'resourceId')
+      assert.equal(val, 'io.selendroid.testapp:id/buttonTest')
+    })
 
     it('should be able to grab elements', async () => {
-      await app.resetApp();
-      await app.tap('~startUserRegistrationCD');
-      await app.tap('~email of the customer');
-      await app.appendField('//android.widget.EditText[@content-desc="email of the customer"]', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.tap('~startUserRegistrationCD')
+      await app.tap('~email of the customer')
+      await app.appendField('//android.widget.EditText[@content-desc="email of the customer"]', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -686,66 +736,66 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
-      await app.see(
-        '1',
-        '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
+      )
+      await app.click('//android.widget.Button')
+      await app.see('1', '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]')
       const id = await app.grabNumberOfVisibleElements(
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
         'contentDescription',
-      );
-      assert.strictEqual(1, id);
-    });
-  });
+      )
+      assert.strictEqual(1, id)
+    })
+  })
 
   describe('#saveScreenshot @quick', () => {
     beforeEach(() => {
-      global.output_dir = path.join(global.codecept_dir, 'output');
-    });
+      global.output_dir = path.join(global.codecept_dir, 'output')
+    })
 
     it('should create a screenshot file in output dir', async () => {
-      const sec = (new Date()).getUTCMilliseconds();
-      await app.saveScreenshot(`screenshot_${sec}.png`);
-      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists');
-    });
-  });
+      const sec = new Date().getUTCMilliseconds()
+      await app.saveScreenshot(`screenshot_${sec}.png`)
+      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists')
+    })
+  })
 
   describe('#runOnIOS, #runOnAndroid, #runInWeb', () => {
     it('should use Android locators', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click({ android: '~startUserRegistrationCD', ios: 'fake-element' });
-      await app.see('Welcome to register a new User');
-    });
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click({ android: '~startUserRegistrationCD', ios: 'fake-element' })
+      await app.see('Welcome to register a new User')
+    })
 
     it('should execute only on Android @quick', async () => {
-      let platform = null;
+      let platform = null
       await app.runOnIOS(() => {
-        platform = 'ios';
-      });
+        platform = 'ios'
+      })
       await app.runOnAndroid(() => {
-        platform = 'android';
-      });
+        platform = 'android'
+      })
       await app.runOnAndroid({ platformVersion: '7.0' }, () => {
-        platform = 'android7';
-      });
+        platform = 'android7'
+      })
 
-      assert.equal('android', platform);
-    });
+      assert.equal('android', platform)
+    })
 
     it('should execute only on Android >= 5.0 @quick', async () => {
-      await app.runOnAndroid(caps => caps.platformVersion >= 5, () => {});
-    });
+      await app.runOnAndroid(
+        (caps) => caps.platformVersion >= 5,
+        () => {},
+      )
+    })
 
     it('should execute only in Web', () => {
-      app.isWeb = true;
-      let executed = false;
+      app.isWeb = true
+      let executed = false
       app.runOnIOS(() => {
-        executed = true;
-      });
-      assert.ok(!executed);
-    });
-  });
-});
+        executed = true
+      })
+      assert.ok(!executed)
+    })
+  })
+})
diff --git a/test/helper/AppiumWeb_test.js b/test/helper/AppiumWeb_test.js
index 39d7510b0..27fc51a9b 100644
--- a/test/helper/AppiumWeb_test.js
+++ b/test/helper/AppiumWeb_test.js
@@ -1,12 +1,12 @@
-const Appium = require('../../lib/helper/Appium');
-global.codeceptjs = require('../../lib');
+const Appium = require('../../lib/helper/Appium')
+global.codeceptjs = require('../../lib')
 
-let I;
-const site_url = 'http://davertmik.github.io';
+let I
+const site_url = 'http://davertmik.github.io'
 
 describe('Appium Web', function () {
-  this.retries(4);
-  this.timeout(70000);
+  this.retries(4)
+  this.timeout(70000)
 
   before(() => {
     I = new Appium({
@@ -27,136 +27,136 @@ describe('Appium Web', function () {
       // host: 'localhost',
       user: process.env.SAUCE_USERNAME,
       key: process.env.SAUCE_ACCESS_KEY,
-    });
+    })
     // I.isWeb = true;
-    I._init();
-    I._beforeSuite();
-  });
+    I._init()
+    I._beforeSuite()
+  })
 
-  after(() => I._finishTest());
+  after(() => I._finishTest())
 
   beforeEach(() => {
-    I.isWeb = true;
-    return I._before();
-  });
+    I.isWeb = true
+    return I._before()
+  })
 
-  afterEach(() => I._after());
+  afterEach(() => I._after())
 
   describe('current url : #seeInCurrentUrl, #seeCurrentUrlEquals, ...', () => {
     it('should check for url fragment', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.seeInCurrentUrl('/info');
-      await I.dontSeeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.seeInCurrentUrl('/info')
+      await I.dontSeeInCurrentUrl('/result')
+    })
 
     it('should check for equality', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.seeCurrentUrlEquals('/angular-demo-app/#/info');
-      await I.dontSeeCurrentUrlEquals('/angular-demo-app/#/result');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.seeCurrentUrlEquals('/angular-demo-app/#/info')
+      await I.dontSeeCurrentUrlEquals('/angular-demo-app/#/result')
+    })
+  })
 
   describe('see text : #see', () => {
     it('should check text on site', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.see('Description');
-      await I.dontSee('Create Event Today');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.see('Description')
+      await I.dontSee('Create Event Today')
+    })
 
     it('should check text inside element', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      await I.see('About', 'h1');
-      await I.see('Welcome to event app', { css: 'p.jumbotron' });
-      await I.see('Back to form', '//div/a');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      await I.see('About', 'h1')
+      await I.see('Welcome to event app', { css: 'p.jumbotron' })
+      await I.see('Back to form', '//div/a')
+    })
+  })
 
   describe('see element : #seeElement, #dontSeeElement', () => {
     it('should check visible elements on page', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.seeElement('.btn.btn-primary');
-      await I.seeElement({ css: '.btn.btn-primary' });
-      await I.dontSeeElement({ css: '.btn.btn-secondary' });
-    });
-  });
+      await I.amOnPage('/angular-demo-app/')
+      await I.seeElement('.btn.btn-primary')
+      await I.seeElement({ css: '.btn.btn-primary' })
+      await I.dontSeeElement({ css: '.btn.btn-secondary' })
+    })
+  })
 
   describe('#click', () => {
     it('should click by text', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.dontSeeInCurrentUrl('/info');
-      await I.click('Get more info!');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.dontSeeInCurrentUrl('/info')
+      await I.click('Get more info!')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click by css', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('.btn-primary');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('.btn-primary')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click by non-optimal css', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('form a.btn');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('form a.btn')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click by xpath', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('//a[contains(., "more info")]');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('//a[contains(., "more info")]')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click on context', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('.btn-primary', 'form');
-      await I.wait(2);
-      await I.seeInCurrentUrl('/result');
-    });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('.btn-primary', 'form')
+      await I.wait(2)
+      await I.seeInCurrentUrl('/result')
+    })
 
     it('should click link with inner span', async () => {
-      await I.amOnPage('/angular-demo-app/#/result');
-      await I.click('Go to info');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/angular-demo-app/#/result')
+      await I.click('Go to info')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click buttons as links', async () => {
-      await I.amOnPage('/angular-demo-app/');
-      await I.click('Options');
-      await I.seeInCurrentUrl('/options');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/')
+      await I.click('Options')
+      await I.seeInCurrentUrl('/options')
+    })
+  })
 
   describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom', () => {
     it('should grab text from page', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      const val = await I.grabTextFrom('p.jumbotron');
-      val.should.be.equal('Welcome to event app');
-    });
+      await I.amOnPage('/angular-demo-app/#/info')
+      const val = await I.grabTextFrom('p.jumbotron')
+      val.should.be.equal('Welcome to event app')
+    })
 
     it('should grab value from field', async () => {
-      await I.amOnPage('/angular-demo-app/#/options');
-      const val = await I.grabValueFrom('#ssh');
-      val.should.be.equal('PUBLIC-SSH-KEY');
-    });
+      await I.amOnPage('/angular-demo-app/#/options')
+      const val = await I.grabValueFrom('#ssh')
+      val.should.be.equal('PUBLIC-SSH-KEY')
+    })
 
     it('should grab attribute from element', async () => {
-      await I.amOnPage('/angular-demo-app/#/info');
-      const val = await I.grabAttributeFrom('a.btn', 'ng-href');
-      val.should.be.equal('#/');
-    });
-  });
+      await I.amOnPage('/angular-demo-app/#/info')
+      const val = await I.grabAttributeFrom('a.btn', 'ng-href')
+      val.should.be.equal('#/')
+    })
+  })
 
   describe('#within', () => {
-    afterEach(() => I._withinEnd());
+    afterEach(() => I._withinEnd())
 
     it('should work using within operator', async () => {
-      await I.amOnPage('/angular-demo-app/#/options');
-      await I.see('Choose if you ok with terms');
-      await I._withinBegin({ css: 'div.results' });
-      await I.see('SSH Public Key: PUBLIC-SSH-KEY');
-      await I.dontSee('Options');
-    });
-  });
-});
+      await I.amOnPage('/angular-demo-app/#/options')
+      await I.see('Choose if you ok with terms')
+      await I._withinBegin({ css: 'div.results' })
+      await I.see('SSH Public Key: PUBLIC-SSH-KEY')
+      await I.dontSee('Options')
+    })
+  })
+})
diff --git a/test/helper/Appium_test.js b/test/helper/Appium_test.js
index a1d5d560b..58ec776ec 100644
--- a/test/helper/Appium_test.js
+++ b/test/helper/Appium_test.js
@@ -1,26 +1,26 @@
-const assert = require('assert');
+const assert = require('assert')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
 
-const Appium = require('../../lib/helper/Appium');
-const AssertionFailedError = require('../../lib/assert/error');
-const fileExists = require('../../lib/utils').fileExists;
-global.codeceptjs = require('../../lib');
+const Appium = require('../../lib/helper/Appium')
+const AssertionFailedError = require('../../lib/assert/error')
+const fileExists = require('../../lib/utils').fileExists
+global.codeceptjs = require('../../lib')
 
-let app;
-const apk_path = 'storage:filename=selendroid-test-app-0.17.0.apk';
-const smallWait = 3;
+let app
+const apk_path = 'storage:filename=selendroid-test-app-0.17.0.apk'
+const smallWait = 3
 
 describe('Appium', function () {
   // this.retries(1);
-  this.timeout(0);
+  this.timeout(0)
 
   before(async () => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     app = new Appium({
       app: apk_path,
       desiredCapabilities: {
@@ -42,359 +42,392 @@ describe('Appium', function () {
       // host: 'localhost',
       user: process.env.SAUCE_USERNAME,
       key: process.env.SAUCE_ACCESS_KEY,
-    });
-    await app._beforeSuite();
-    app.isWeb = false;
-    await app._before();
-  });
+    })
+    await app._beforeSuite()
+    app.isWeb = false
+    await app._before()
+  })
 
   after(async () => {
-    await app._after();
-  });
+    await app._after()
+  })
 
   describe('app installation : #seeAppIsInstalled, #installApp, #removeApp, #seeAppIsNotInstalled', () => {
-    describe(
-      '#grabAllContexts, #grabContext, #grabCurrentActivity, #grabNetworkConnection, #grabOrientation, #grabSettings',
-      () => {
-        it('should grab all available contexts for screen', async () => {
-          await app.resetApp();
-          await app.waitForElement('~buttonStartWebviewCD', smallWait);
-          await app.click('~buttonStartWebviewCD');
-          const val = await app.grabAllContexts();
-          assert.deepEqual(val, ['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp']);
-        });
-
-        it('should grab current context', async () => {
-          const val = await app.grabContext();
-          assert.equal(val, 'NATIVE_APP');
-        });
-
-        it('should grab current activity of app', async () => {
-          const val = await app.grabCurrentActivity();
-          assert.equal(val, '.HomeScreenActivity');
-        });
-
-        it('should grab network connection settings', async () => {
-          await app.setNetworkConnection(4);
-          const val = await app.grabNetworkConnection();
-          assert.equal(val.value, 4);
-          assert.equal(val.inAirplaneMode, false);
-          assert.equal(val.hasWifi, false);
-          assert.equal(val.hasData, true);
-        });
-
-        it('should grab orientation', async () => {
-          const val = await app.grabOrientation();
-          assert.equal(val, 'PORTRAIT');
-        });
-
-        it('should grab custom settings', async () => {
-          const val = await app.grabSettings();
-          assert.deepEqual(val, { ignoreUnimportantViews: false });
-        });
-      },
-    );
+    describe('#grabAllContexts, #grabContext, #grabCurrentActivity, #grabNetworkConnection, #grabOrientation, #grabSettings', () => {
+      it('should grab all available contexts for screen', async () => {
+        await app.resetApp()
+        await app.waitForElement('~buttonStartWebviewCD', smallWait)
+        await app.click('~buttonStartWebviewCD')
+        const val = await app.grabAllContexts()
+        assert.deepEqual(val, ['NATIVE_APP', 'WEBVIEW_io.selendroid.testapp'])
+      })
+
+      it('should grab current context', async () => {
+        const val = await app.grabContext()
+        assert.equal(val, 'NATIVE_APP')
+      })
+
+      it('should grab current activity of app', async () => {
+        const val = await app.grabCurrentActivity()
+        assert.equal(val, '.HomeScreenActivity')
+      })
+
+      it('should grab network connection settings', async () => {
+        await app.setNetworkConnection(4)
+        const val = await app.grabNetworkConnection()
+        assert.equal(val.value, 4)
+        assert.equal(val.inAirplaneMode, false)
+        assert.equal(val.hasWifi, false)
+        assert.equal(val.hasData, true)
+      })
+
+      it('should grab orientation', async () => {
+        const val = await app.grabOrientation()
+        assert.equal(val, 'PORTRAIT')
+      })
+
+      it('should grab custom settings', async () => {
+        const val = await app.grabSettings()
+        assert.deepEqual(val, { ignoreUnimportantViews: false })
+      })
+    })
 
     it('should remove App and install it again', async () => {
-      await app.seeAppIsInstalled('io.selendroid.testapp');
-      await app.removeApp('io.selendroid.testapp');
-      await app.seeAppIsNotInstalled('io.selendroid.testapp');
-      await app.installApp(apk_path);
-      await app.seeAppIsInstalled('io.selendroid.testapp');
-    });
+      await app.seeAppIsInstalled('io.selendroid.testapp')
+      await app.removeApp('io.selendroid.testapp')
+      await app.seeAppIsNotInstalled('io.selendroid.testapp')
+      await app.installApp(apk_path)
+      await app.seeAppIsInstalled('io.selendroid.testapp')
+    })
 
     it('should return true if app is installed @quick', async () => {
-      const status = await app.checkIfAppIsInstalled('io.selendroid.testapp');
-      expect(status).to.be.true;
-    });
+      const status = await app.checkIfAppIsInstalled('io.selendroid.testapp')
+      expect(status).to.be.true
+    })
 
     it('should assert when app is/is not installed', async () => {
       try {
-        await app.seeAppIsInstalled('io.super.app');
+        await app.seeAppIsInstalled('io.super.app')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected app io.super.app to be installed');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected app io.super.app to be installed')
       }
 
       try {
-        await app.seeAppIsNotInstalled('io.selendroid.testapp');
+        await app.seeAppIsNotInstalled('io.selendroid.testapp')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected app io.selendroid.testapp not to be installed');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected app io.selendroid.testapp not to be installed')
       }
-    });
-  });
+    })
+  })
 
   describe('see seeCurrentActivity: #seeCurrentActivityIs', () => {
     it('should return .HomeScreenActivity for default screen', async () => {
-      await app.seeCurrentActivityIs('.HomeScreenActivity');
-    });
+      await app.seeCurrentActivityIs('.HomeScreenActivity')
+    })
 
     it('should assert for wrong screen', async () => {
       try {
-        await app.seeCurrentActivityIs('.SuperScreen');
+        await app.seeCurrentActivityIs('.SuperScreen')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected current activity to be .SuperScreen');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected current activity to be .SuperScreen')
       }
-    });
-  });
+    })
+  })
 
   describe('device lock : #seeDeviceIsLocked, #seeDeviceIsUnlocked', () => {
     it('should return correct status about lock @second', async () => {
-      await app.seeDeviceIsUnlocked();
+      await app.seeDeviceIsUnlocked()
       try {
-        await app.seeDeviceIsLocked();
+        await app.seeDeviceIsLocked()
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected device to be locked');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected device to be locked')
       }
-    });
-  });
+    })
+  })
 
   describe('device orientation : #seeOrientationIs #setOrientation', () => {
     it('should return correct status about lock', async () => {
-      await app.seeOrientationIs('PORTRAIT');
+      await app.seeOrientationIs('PORTRAIT')
       try {
-        await app.seeOrientationIs('LANDSCAPE');
+        await app.seeOrientationIs('LANDSCAPE')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected orientation to be LANDSCAPE');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('expected orientation to be LANDSCAPE')
       }
-    });
+    })
 
     it('should set device orientation', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.click('~buttonStartWebviewCD');
-      await app.setOrientation('LANDSCAPE');
-      await app.seeOrientationIs('LANDSCAPE');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.click('~buttonStartWebviewCD')
+      await app.setOrientation('LANDSCAPE')
+      await app.seeOrientationIs('LANDSCAPE')
+    })
+  })
 
   describe('app context and activity: #switchToContext, #switchToWeb, #switchToNative', () => {
     it('should switch context', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.click('~buttonStartWebviewCD');
-      await app.switchToContext('WEBVIEW_io.selendroid.testapp');
-      const val = await app.grabContext();
-      return assert.equal(val, 'WEBVIEW_io.selendroid.testapp');
-    });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.click('~buttonStartWebviewCD')
+      await app.switchToContext('WEBVIEW_io.selendroid.testapp')
+      const val = await app.grabContext()
+      return assert.equal(val, 'WEBVIEW_io.selendroid.testapp')
+    })
 
     it('should switch to native and web contexts @quick', async () => {
-      await app.resetApp();
-      await app.click('~buttonStartWebviewCD');
-      await app.see('WebView location');
-      await app.switchToWeb();
-      let val = await app.grabContext();
-      assert.equal(val, 'WEBVIEW_io.selendroid.testapp');
-      await app.see('Prefered Car');
-      assert.ok(app.isWeb);
-      await app.switchToNative();
-      val = await app.grabContext();
-      assert.equal(val, 'NATIVE_APP');
-      return assert.ok(!app.isWeb);
-    });
+      await app.resetApp()
+      await app.click('~buttonStartWebviewCD')
+      await app.see('WebView location')
+      await app.switchToWeb()
+      let val = await app.grabContext()
+      assert.equal(val, 'WEBVIEW_io.selendroid.testapp')
+      await app.see('Prefered Car')
+      assert.ok(app.isWeb)
+      await app.switchToNative()
+      val = await app.grabContext()
+      assert.equal(val, 'NATIVE_APP')
+      return assert.ok(!app.isWeb)
+    })
 
     it('should switch activity', async () => {
-      await app.startActivity('io.selendroid.testapp', '.RegisterUserActivity');
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.RegisterUserActivity');
-    });
-  });
+      await app.startActivity('io.selendroid.testapp', '.RegisterUserActivity')
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.RegisterUserActivity')
+    })
+  })
 
   describe('#setNetworkConnection, #setSettings', () => {
     it('should set Network Connection (airplane mode on)', async () => {
-      await app.setNetworkConnection(1);
-      const val = await app.grabNetworkConnection();
-      return assert.equal(val.value, 1);
-    });
+      await app.setNetworkConnection(1)
+      const val = await app.grabNetworkConnection()
+      return assert.equal(val.value, 1)
+    })
 
     it('should set custom settings', async () => {
-      await app.setSettings({ cyberdelia: 'open' });
-      const val = await app.grabSettings();
-      assert.deepEqual(val, { ignoreUnimportantViews: false, cyberdelia: 'open' });
-    });
-  });
+      await app.setSettings({ cyberdelia: 'open' })
+      const val = await app.grabSettings()
+      assert.deepEqual(val, { ignoreUnimportantViews: false, cyberdelia: 'open' })
+    })
+  })
 
   describe('#hideDeviceKeyboard', () => {
     it('should hide device Keyboard @quick', async () => {
-      await app.resetApp();
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.click('~startUserRegistrationCD')
       try {
-        await app.click('//android.widget.CheckBox');
+        await app.click('//android.widget.CheckBox')
       } catch (e) {
-        e.message.should.include('element');
+        e.message.should.include('element')
       }
-      await app.hideDeviceKeyboard('pressKey', 'Done');
-      await app.click('//android.widget.CheckBox');
-    });
+      await app.hideDeviceKeyboard('pressKey', 'Done')
+      await app.click('//android.widget.CheckBox')
+    })
 
     it('should assert if no keyboard', async () => {
       try {
-        await app.hideDeviceKeyboard('pressKey', 'Done');
+        await app.hideDeviceKeyboard('pressKey', 'Done')
       } catch (e) {
-        e.message.should.include('An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard');
+        e.message.should.include(
+          'An unknown server-side error occurred while processing the command. Original error: Soft keyboard not present, cannot hide keyboard',
+        )
       }
-    });
-  });
+    })
+  })
 
   describe('#sendDeviceKeyEvent', () => {
     it('should react on pressing keycode', async () => {
-      await app.sendDeviceKeyEvent(3);
-      await app.waitForVisible('~Apps');
-    });
-  });
+      await app.sendDeviceKeyEvent(3)
+      await app.waitForVisible('~Apps')
+    })
+  })
 
   describe('#openNotifications', () => {
     it('should react on notification opening', async () => {
       try {
-        await app.seeElement('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]');
+        await app.seeElement(
+          '//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]',
+        )
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('expected elements of //android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"] to be seen');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include(
+          'expected elements of //android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"] to be seen',
+        )
       }
-      await app.openNotifications();
-      await app.waitForVisible('//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]', 10);
-    });
-  });
+      await app.openNotifications()
+      await app.waitForVisible(
+        '//android.widget.FrameLayout[@resource-id="com.android.systemui:id/quick_settings_container"]',
+        10,
+      )
+    })
+  })
 
   describe('#makeTouchAction', () => {
     it('should react on touch actions', async () => {
-      await app.resetApp();
-      await app.waitForElement('~buttonStartWebviewCD', smallWait);
-      await app.tap('~buttonStartWebviewCD');
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.WebViewActivity');
-    });
+      await app.resetApp()
+      await app.waitForElement('~buttonStartWebviewCD', smallWait)
+      await app.tap('~buttonStartWebviewCD')
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.WebViewActivity')
+    })
 
     it('should react on swipe action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipe(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vx = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vx.match(/vx: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vx = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vx.match(/vx: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeDown action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeDown(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vy: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('run simplified swipeDown @quick', async () => {
-      await app.resetApp();
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.resetApp()
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeDown(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         120,
         100,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      assert.equal(type, 'FLICK');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      assert.equal(type, 'FLICK')
+    })
 
     it('should react on swipeUp action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeUp(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         1200,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vy: -\d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vy: -\d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeRight action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeRight(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vx: \d\d000\.0 pps/), 'to be like \d\d000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vx: \d\d000\.0 pps/), 'to be like dd000.0 pps')
+    })
 
     it('should react on swipeLeft action', async () => {
-      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+      await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
       await app.waitForText(
         'Gesture Type',
         10,
         "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-      );
+      )
       await app.swipeLeft(
         "//android.widget.LinearLayout[@resource-id = 'io.selendroid.testapp:id/LinearLayout1']",
         800,
         1000,
-      );
-      const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-      const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']");
-      assert.equal(type, 'FLICK');
-      assert.ok(vy.match(/vx: -\d\d000\.0 pps/), 'to be like 21000.0 pps');
-    });
+      )
+      const type = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+      )
+      const vy = await app.grabTextFrom(
+        "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view3']",
+      )
+      assert.equal(type, 'FLICK')
+      assert.ok(vy.match(/vx: -\d\d000\.0 pps/), 'to be like 21000.0 pps')
+    })
 
     it('should react on touchPerform action', async () => {
-      await app.touchPerform([{
-        action: 'press',
-        options: {
-          x: 100,
-          y: 200,
+      await app.touchPerform([
+        {
+          action: 'press',
+          options: {
+            x: 100,
+            y: 200,
+          },
         },
-      }, { action: 'release' }]);
-      const val = await app.grabCurrentActivity();
-      assert.equal(val, '.HomeScreenActivity');
-    });
+        { action: 'release' },
+      ])
+      const val = await app.grabCurrentActivity()
+      assert.equal(val, '.HomeScreenActivity')
+    })
 
     it('should assert when you dont scroll the document anymore', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
       try {
         await app.swipeTo(
           '//android.widget.CheckBox',
@@ -403,16 +436,16 @@ describe('Appium', function () {
           30,
           100,
           500,
-        );
+        )
       } catch (e) {
-        e.message.should.include('Scroll to the end and element android.widget.CheckBox was not found');
+        e.message.should.include('Scroll to the end and element android.widget.CheckBox was not found')
       }
-    });
+    })
 
     it('should react on swipeTo action', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
       await app.swipeTo(
         '//android.widget.CheckBox',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -420,101 +453,121 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-    });
+      )
+    })
 
     describe('#performTouchAction', () => {
       it('should react on swipeUp action @second', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(parseInt(vy.split(' ')[1], 10)).to.be.below(1006);
-      });
+        )
+        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(parseInt(vy.split(' ')[1], 10)).to.be.below(1006)
+      })
 
       it('should react on swipeDown action @second', async () => {
-        await app.resetApp();
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.resetApp()
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(parseInt(vy.split(' ')[1], 10)).to.be.above(-300);
-      });
+        )
+        await app.swipeUp("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']")
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(parseInt(vy.split(' ')[1], 10)).to.be.above(-300)
+      })
 
       it('should react on swipeLeft action', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeLeft("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(vy.split(' ')[1]).to.be.below(730);
-      });
+        )
+        await app.swipeLeft(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(vy.split(' ')[1]).to.be.below(730)
+      })
 
       it('should react on swipeRight action', async () => {
-        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']");
+        await app.click("//android.widget.Button[@resource-id = 'io.selendroid.testapp:id/touchTest']")
         await app.waitForText(
           'Gesture Type',
           10,
           "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
-        );
-        await app.swipeRight("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const type = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']");
-        const vy = await app.grabTextFrom("//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']");
-        assert.equal(type, 'FLICK');
-        expect(vy.split(' ')[1]).to.be.above(278);
-      });
-    });
-  });
+        )
+        await app.swipeRight(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const type = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/gesture_type_text_view']",
+        )
+        const vy = await app.grabTextFrom(
+          "//android.widget.TextView[@resource-id = 'io.selendroid.testapp:id/text_view4']",
+        )
+        assert.equal(type, 'FLICK')
+        expect(vy.split(' ')[1]).to.be.above(278)
+      })
+    })
+  })
 
   describe('#pullFile', () => {
     it('should pull file to local machine', async () => {
-      const savepath = path.join(__dirname, `/../data/output/testpullfile${new Date().getTime()}.png`);
-      await app.pullFile('/storage/emulated/0/DCIM/sauce_logo.png', savepath);
-      assert.ok(fileExists(savepath), null, 'file does not exists');
-    });
-  });
+      const savepath = path.join(__dirname, `/../data/output/testpullfile${new Date().getTime()}.png`)
+      await app.pullFile('/storage/emulated/0/DCIM/sauce_logo.png', savepath)
+      assert.ok(fileExists(savepath), null, 'file does not exists')
+    })
+  })
 
   describe('see text : #see', () => {
     it('should work inside elements @second', async () => {
-      await app.resetApp();
-      await app.see('EN Button', '~buttonTestCD');
-      await app.see('Hello');
-      await app.dontSee('Welcome', '~buttonTestCD');
-    });
+      await app.resetApp()
+      await app.see('EN Button', '~buttonTestCD')
+      await app.see('Hello')
+      await app.dontSee('Welcome', '~buttonTestCD')
+    })
 
     it('should work inside web view as normally @quick', async () => {
-      await app.resetApp();
-      await app.click('~buttonStartWebviewCD');
-      await app.switchToWeb();
-      await app.see('Prefered Car:');
-    });
-  });
+      await app.resetApp()
+      await app.click('~buttonStartWebviewCD')
+      await app.switchToWeb()
+      await app.see('Prefered Car:')
+    })
+  })
 
   describe('#appendField', () => {
     it('should be able to send special keys to element @second', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.click('~email of the customer');
-      await app.appendField('~email of the customer', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.click('~email of the customer')
+      await app.appendField('~email of the customer', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -522,70 +575,67 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
-      await app.see(
-        '1',
-        '#io.selendroid.testapp:id/label_email_data',
-      );
-    });
-  });
+      )
+      await app.click('//android.widget.Button')
+      await app.see('1', '#io.selendroid.testapp:id/label_email_data')
+    })
+  })
 
   describe('#seeInSource', () => {
     it('should check for text to be in HTML source', async () => {
-      await app.seeInSource('class="android.widget.Button" package="io.selendroid.testapp" content-desc="buttonTestCD"');
-      await app.dontSeeInSource('<meta');
-    });
-  });
+      await app.seeInSource('class="android.widget.Button" package="io.selendroid.testapp" content-desc="buttonTestCD"')
+      await app.dontSeeInSource('<meta')
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', async () => {
       try {
-        await app.waitForText('Nothing here', 1, '~buttonTestCD');
+        await app.waitForText('Nothing here', 1, '~buttonTestCD')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected element ~buttonTestCD to include "Nothing here"');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.be.equal('expected element ~buttonTestCD to include "Nothing here"')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeNumberOfElements @second', () => {
     it('should return 1 as count', async () => {
-      await app.resetApp();
-      await app.seeNumberOfElements('~buttonTestCD', 1);
-    });
-  });
+      await app.resetApp()
+      await app.seeNumberOfElements('~buttonTestCD', 1)
+    })
+  })
 
   describe('see element : #seeElement, #dontSeeElement', () => {
     it('should check visible elements on page @quick', async () => {
-      await app.resetApp();
-      await app.seeElement('//android.widget.Button[@content-desc = "buttonTestCD"]');
-      await app.dontSeeElement('#something-beyond');
-      await app.dontSeeElement('//input[@id="something-beyond"]');
-    });
-  });
+      await app.resetApp()
+      await app.seeElement('//android.widget.Button[@content-desc = "buttonTestCD"]')
+      await app.dontSeeElement('#something-beyond')
+      await app.dontSeeElement('//input[@id="something-beyond"]')
+    })
+  })
 
   describe('#click @quick', () => {
     it('should click by accessibility id', async () => {
-      await app.resetApp();
-      await app.tap('~startUserRegistrationCD');
-      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]');
-    });
+      await app.resetApp()
+      await app.tap('~startUserRegistrationCD')
+      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]')
+    })
 
     it('should click by xpath', async () => {
-      await app.resetApp();
-      await app.click('//android.widget.ImageButton[@content-desc = "startUserRegistrationCD"]');
-      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]');
-    });
-  });
+      await app.resetApp()
+      await app.click('//android.widget.ImageButton[@content-desc = "startUserRegistrationCD"]')
+      await app.seeElement('//android.widget.TextView[@content-desc="label_usernameCD"]')
+    })
+  })
 
   describe('#fillField, #appendField @second', () => {
     it('should fill field by accessibility id', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -593,20 +643,20 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing special',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
+      )
+    })
 
     it('should fill field by xpath', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('//android.widget.EditText[@content-desc="email of the customer"]', 'Nothing special');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('//android.widget.EditText[@content-desc="email of the customer"]', 'Nothing special')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -614,21 +664,21 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing special',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
+      )
+    })
 
     it('should append field value @second', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.appendField('~email of the customer', 'blabla');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.appendField('~email of the customer', 'blabla')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -636,46 +686,46 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
+      )
+      await app.click('//android.widget.Button')
       await app.see(
         'Nothing specialblabla',
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('#clearField', () => {
     it('should clear a given element', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click('~startUserRegistrationCD');
-      await app.fillField('~email of the customer', 'Nothing special');
-      await app.see('Nothing special', '~email of the customer');
-      await app.clearField('~email of the customer');
-      await app.dontSee('Nothing special', '~email of the customer');
-    });
-  });
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click('~startUserRegistrationCD')
+      await app.fillField('~email of the customer', 'Nothing special')
+      await app.see('Nothing special', '~email of the customer')
+      await app.clearField('~email of the customer')
+      await app.dontSee('Nothing special', '~email of the customer')
+    })
+  })
 
   describe('#grabTextFrom, #grabValueFrom, #grabAttributeFrom @quick', () => {
     it('should grab text from page', async () => {
-      await app.resetApp();
-      const val = await app.grabTextFrom('//android.widget.Button[@content-desc="buttonTestCD"]');
-      assert.equal(val, 'EN Button');
-    });
+      await app.resetApp()
+      const val = await app.grabTextFrom('//android.widget.Button[@content-desc="buttonTestCD"]')
+      assert.equal(val, 'EN Button')
+    })
 
     it('should grab attribute from element', async () => {
-      await app.resetApp();
-      const val = await app.grabAttributeFrom('//android.widget.Button[@content-desc="buttonTestCD"]', 'resourceId');
-      assert.equal(val, 'io.selendroid.testapp:id/buttonTest');
-    });
+      await app.resetApp()
+      const val = await app.grabAttributeFrom('//android.widget.Button[@content-desc="buttonTestCD"]', 'resourceId')
+      assert.equal(val, 'io.selendroid.testapp:id/buttonTest')
+    })
 
     it('should be able to grab elements', async () => {
-      await app.resetApp();
-      await app.tap('~startUserRegistrationCD');
-      await app.tap('~email of the customer');
-      await app.appendField('//android.widget.EditText[@content-desc="email of the customer"]', '1');
-      await app.hideDeviceKeyboard('pressKey', 'Done');
+      await app.resetApp()
+      await app.tap('~startUserRegistrationCD')
+      await app.tap('~email of the customer')
+      await app.appendField('//android.widget.EditText[@content-desc="email of the customer"]', '1')
+      await app.hideDeviceKeyboard('pressKey', 'Done')
       await app.swipeTo(
         '//android.widget.Button',
         '//android.widget.ScrollView/android.widget.LinearLayout',
@@ -683,66 +733,66 @@ describe('Appium', function () {
         30,
         100,
         700,
-      );
-      await app.click('//android.widget.Button');
-      await app.see(
-        '1',
-        '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
-      );
+      )
+      await app.click('//android.widget.Button')
+      await app.see('1', '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]')
       const id = await app.grabNumberOfVisibleElements(
         '//android.widget.TextView[@resource-id="io.selendroid.testapp:id/label_email_data"]',
         'contentDescription',
-      );
-      assert.strictEqual(1, id);
-    });
-  });
+      )
+      assert.strictEqual(1, id)
+    })
+  })
 
   describe('#saveScreenshot @quick', () => {
     beforeEach(() => {
-      global.output_dir = path.join(global.codecept_dir, 'output');
-    });
+      global.output_dir = path.join(global.codecept_dir, 'output')
+    })
 
     it('should create a screenshot file in output dir', async () => {
-      const sec = (new Date()).getUTCMilliseconds();
-      await app.saveScreenshot(`screenshot_${sec}.png`);
-      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists');
-    });
-  });
+      const sec = new Date().getUTCMilliseconds()
+      await app.saveScreenshot(`screenshot_${sec}.png`)
+      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists')
+    })
+  })
 
   describe('#runOnIOS, #runOnAndroid, #runInWeb', () => {
     it('should use Android locators', async () => {
-      await app.resetApp();
-      await app.waitForElement('~startUserRegistrationCD', smallWait);
-      await app.click({ android: '~startUserRegistrationCD', ios: 'fake-element' });
-      await app.see('Welcome to register a new User');
-    });
+      await app.resetApp()
+      await app.waitForElement('~startUserRegistrationCD', smallWait)
+      await app.click({ android: '~startUserRegistrationCD', ios: 'fake-element' })
+      await app.see('Welcome to register a new User')
+    })
 
     it('should execute only on Android @quick', () => {
-      let platform = null;
+      let platform = null
       app.runOnIOS(() => {
-        platform = 'ios';
-      });
+        platform = 'ios'
+      })
       app.runOnAndroid(() => {
-        platform = 'android';
-      });
+        platform = 'android'
+      })
       app.runOnAndroid({ platformVersion: '7.0' }, () => {
-        platform = 'android7';
-      });
+        platform = 'android7'
+      })
 
-      assert.equal('android', platform);
-    });
+      assert.equal('android', platform)
+    })
 
     it('should execute only on Android >= 5.0 @quick', () => {
-      app.runOnAndroid(caps => caps.platformVersion >= 5, () => {});
-    });
+      app.runOnAndroid(
+        (caps) => caps.platformVersion >= 5,
+        () => {},
+      )
+    })
 
     it('should execute only in Web', () => {
-      app.isWeb = true;
-      let executed = false;
+      app.isWeb = true
+      let executed = false
       app.runOnIOS(() => {
-        executed = true;
-      });
-      assert.ok(!executed);
-    });
-  });
-});
+        executed = true
+      })
+      assert.ok(!executed)
+    })
+  })
+})
diff --git a/test/helper/Expect_test.js b/test/helper/Expect_test.js
index 7db470e01..80d510834 100644
--- a/test/helper/Expect_test.js
+++ b/test/helper/Expect_test.js
@@ -1,26 +1,26 @@
-const path = require('path');
+const path = require('path')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
 
-const ExpectHelper = require('../../lib/helper/ExpectHelper');
+const ExpectHelper = require('../../lib/helper/ExpectHelper')
 
-global.codeceptjs = require('../../lib');
+global.codeceptjs = require('../../lib')
 
-let I;
+let I
 
 const goodApple = {
   skin: 'thin',
   colors: ['red', 'green', 'yellow'],
   taste: 10,
-};
+}
 const badApple = {
   colors: ['brown'],
   taste: 0,
   worms: 2,
-};
+}
 const fruitSchema = {
   title: 'fresh fruit schema v1',
   type: 'object',
@@ -42,385 +42,385 @@ const fruitSchema = {
       minimum: 5,
     },
   },
-};
+}
 
 describe('Expect Helper', function () {
-  this.timeout(3000);
-  this.retries(1);
+  this.timeout(3000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
-    I = new ExpectHelper();
-  });
+    I = new ExpectHelper()
+  })
 
   describe('#expectEqual', () => {
     it('should not show error', () => {
-      I.expectEqual('a', 'a');
-    });
+      I.expectEqual('a', 'a')
+    })
 
     it('should show error', () => {
       try {
-        I.expectEqual('a', 'b');
+        I.expectEqual('a', 'b')
       } catch (e) {
-        expect(e.message).to.eq('expected \'a\' to equal \'b\'');
+        expect(e.message).to.eq("expected 'a' to equal 'b'")
       }
-    });
-  });
+    })
+  })
 
   describe('#expectNotEqual', () => {
     it('should not show error', () => {
-      I.expectNotEqual('a', 'b');
-    });
+      I.expectNotEqual('a', 'b')
+    })
 
     it('should show error', () => {
       try {
-        I.expectNotEqual('a', 'a');
+        I.expectNotEqual('a', 'a')
       } catch (e) {
-        expect(e.message).to.eq('expected \'a\' to not equal \'a\'');
+        expect(e.message).to.eq("expected 'a' to not equal 'a'")
       }
-    });
-  });
+    })
+  })
 
   describe('#expectContain', () => {
     it('should not show error', () => {
-      I.expectContain('abc', 'a');
-    });
+      I.expectContain('abc', 'a')
+    })
 
     it('should show error', () => {
       try {
-        I.expectContain('abc', 'd');
+        I.expectContain('abc', 'd')
       } catch (e) {
-        expect(e.message).to.eq('expected \'abc\' to include \'d\'');
+        expect(e.message).to.eq("expected 'abc' to include 'd'")
       }
-    });
-  });
+    })
+  })
 
   describe('#expectNotContain', () => {
     it('should not show error', () => {
-      I.expectNotContain('abc', 'd');
-    });
+      I.expectNotContain('abc', 'd')
+    })
 
     it('should show error', () => {
       try {
-        I.expectNotContain('abc', 'a');
+        I.expectNotContain('abc', 'a')
       } catch (e) {
-        expect(e.message).to.eq('expected \'abc\' to not include \'a\'');
+        expect(e.message).to.eq("expected 'abc' to not include 'a'")
       }
-    });
-  });
+    })
+  })
 
   describe('#expectStartsWith', () => {
     it('should not show error', () => {
-      I.expectStartsWith('abc', 'a');
-    });
+      I.expectStartsWith('abc', 'a')
+    })
 
     it('should show error', () => {
       try {
-        I.expectStartsWith('abc', 'b');
+        I.expectStartsWith('abc', 'b')
       } catch (e) {
-        expect(e.message).to.eq('expected abc to start with b');
+        expect(e.message).to.eq('expected abc to start with b')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectNotStartsWith', () => {
     it('should not show error', () => {
-      I.expectNotStartsWith('abc', 'b');
-    });
+      I.expectNotStartsWith('abc', 'b')
+    })
 
     it('should show error', () => {
       try {
-        I.expectNotStartsWith('abc', 'a');
+        I.expectNotStartsWith('abc', 'a')
       } catch (e) {
-        expect(e.message).to.eq('expected abc not to start with a');
+        expect(e.message).to.eq('expected abc not to start with a')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectEndsWith', () => {
     it('should not show error', () => {
-      I.expectEndsWith('abc', 'c');
-    });
+      I.expectEndsWith('abc', 'c')
+    })
 
     it('should show error', () => {
       try {
-        I.expectEndsWith('abc', 'd');
+        I.expectEndsWith('abc', 'd')
       } catch (e) {
-        expect(e.message).to.eq('expected abc to end with d');
+        expect(e.message).to.eq('expected abc to end with d')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectNotEndsWith', () => {
     it('should not show error', () => {
-      I.expectNotEndsWith('abc', 'd');
-    });
+      I.expectNotEndsWith('abc', 'd')
+    })
 
     it('should show error', () => {
       try {
-        I.expectNotEndsWith('abc', 'd');
+        I.expectNotEndsWith('abc', 'd')
       } catch (e) {
-        expect(e.message).to.eq('expected abc not to end with c');
+        expect(e.message).to.eq('expected abc not to end with c')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectJsonSchema', () => {
     it('should not show error', () => {
-      I.expectJsonSchema(goodApple, fruitSchema);
-    });
+      I.expectJsonSchema(goodApple, fruitSchema)
+    })
 
     it('should show error', () => {
       try {
-        I.expectJsonSchema(badApple, fruitSchema);
+        I.expectJsonSchema(badApple, fruitSchema)
       } catch (e) {
-        expect(e.message).to.contain('expected value to match json-schema');
+        expect(e.message).to.contain('expected value to match json-schema')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectHasProperty', () => {
     it('should not show error', () => {
-      I.expectHasProperty(goodApple, 'skin');
-    });
+      I.expectHasProperty(goodApple, 'skin')
+    })
 
     it('should show error', () => {
       try {
-        I.expectHasProperty(badApple, 'skin');
+        I.expectHasProperty(badApple, 'skin')
       } catch (e) {
-        expect(e.message).to.contain('expected { Object (colors, taste');
+        expect(e.message).to.contain('expected { Object (colors, taste')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectHasAProperty', () => {
     it('should not show error', () => {
-      I.expectHasAProperty(goodApple, 'skin');
-    });
+      I.expectHasAProperty(goodApple, 'skin')
+    })
 
     it('should show error', () => {
       try {
-        I.expectHasAProperty(badApple, 'skin');
+        I.expectHasAProperty(badApple, 'skin')
       } catch (e) {
-        expect(e.message).to.contain('expected { Object (colors, taste');
+        expect(e.message).to.contain('expected { Object (colors, taste')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectToBeA', () => {
     it('should not show error', () => {
-      I.expectToBeA(goodApple, 'object');
-    });
-  });
+      I.expectToBeA(goodApple, 'object')
+    })
+  })
 
   describe('#expectToBeAn', () => {
     it('should not show error', () => {
-      I.expectToBeAn(goodApple, 'object');
-    });
+      I.expectToBeAn(goodApple, 'object')
+    })
 
     it('should show error', () => {
       try {
-        I.expectToBeAn(badApple, 'skin');
+        I.expectToBeAn(badApple, 'skin')
       } catch (e) {
-        expect(e.message).to.contain('expected { Object (colors, taste');
+        expect(e.message).to.contain('expected { Object (colors, taste')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectMatchRegex', () => {
     it('should not show error', () => {
-      I.expectMatchRegex('goodApple', /good/);
-    });
+      I.expectMatchRegex('goodApple', /good/)
+    })
 
     it('should show error', () => {
       try {
-        I.expectMatchRegex('Apple', /good/);
+        I.expectMatchRegex('Apple', /good/)
       } catch (e) {
-        expect(e.message).to.contain('to match /good/');
+        expect(e.message).to.contain('to match /good/')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectLengthOf', () => {
     it('should not show error', () => {
-      I.expectLengthOf('good', 4);
-    });
+      I.expectLengthOf('good', 4)
+    })
 
     it('should show error', () => {
       try {
-        I.expectLengthOf('Apple', 4);
+        I.expectLengthOf('Apple', 4)
       } catch (e) {
-        expect(e.message).to.contain('to have a length');
+        expect(e.message).to.contain('to have a length')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectTrue', () => {
     it('should not show error', () => {
-      I.expectTrue(true);
-    });
+      I.expectTrue(true)
+    })
 
     it('should show error', () => {
       try {
-        I.expectTrue(false);
+        I.expectTrue(false)
       } catch (e) {
-        expect(e.message).to.contain('expected false to be true');
+        expect(e.message).to.contain('expected false to be true')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectEmpty', () => {
     it('should not show error', () => {
-      I.expectEmpty('');
-    });
+      I.expectEmpty('')
+    })
 
     it('should show error', () => {
       try {
-        I.expectEmpty('false');
+        I.expectEmpty('false')
       } catch (e) {
-        expect(e.message).to.contain('expected \'false\' to be empty');
+        expect(e.message).to.contain("expected 'false' to be empty")
       }
-    });
-  });
+    })
+  })
 
   describe('#expectFalse', () => {
     it('should not show error', () => {
-      I.expectFalse(false);
-    });
+      I.expectFalse(false)
+    })
 
     it('should show error', () => {
       try {
-        I.expectFalse(true);
+        I.expectFalse(true)
       } catch (e) {
-        expect(e.message).to.contain('expected true to be false');
+        expect(e.message).to.contain('expected true to be false')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectAbove', () => {
     it('should not show error', () => {
-      I.expectAbove(2, 1);
-    });
+      I.expectAbove(2, 1)
+    })
 
     it('should show error', () => {
       try {
-        I.expectAbove(1, 2);
+        I.expectAbove(1, 2)
       } catch (e) {
-        expect(e.message).to.contain('expected 1 to be above 2');
+        expect(e.message).to.contain('expected 1 to be above 2')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectBelow', () => {
     it('should not show error', () => {
-      I.expectBelow(1, 2);
-    });
+      I.expectBelow(1, 2)
+    })
 
     it('should show error', () => {
       try {
-        I.expectBelow(2, 1);
+        I.expectBelow(2, 1)
       } catch (e) {
-        expect(e.message).to.contain('expected 2 to be below 1');
+        expect(e.message).to.contain('expected 2 to be below 1')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectLengthAboveThan', () => {
     it('should not show error', () => {
-      I.expectLengthAboveThan('hello', 4);
-    });
+      I.expectLengthAboveThan('hello', 4)
+    })
 
     it('should show error', () => {
       try {
-        I.expectLengthAboveThan('hello', 5);
+        I.expectLengthAboveThan('hello', 5)
       } catch (e) {
-        expect(e.message).to.contain('to have a length above 5');
+        expect(e.message).to.contain('to have a length above 5')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectLengthBelowThan', () => {
     it('should not show error', () => {
-      I.expectLengthBelowThan('hello', 6);
-    });
+      I.expectLengthBelowThan('hello', 6)
+    })
 
     it('should show error', () => {
       try {
-        I.expectLengthBelowThan('hello', 4);
+        I.expectLengthBelowThan('hello', 4)
       } catch (e) {
-        expect(e.message).to.contain('to have a length below 4');
+        expect(e.message).to.contain('to have a length below 4')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectLengthBelowThan', () => {
     it('should not show error', () => {
-      I.expectEqualIgnoreCase('hEllo', 'hello');
-    });
+      I.expectEqualIgnoreCase('hEllo', 'hello')
+    })
 
     it('should show error', () => {
       try {
-        I.expectEqualIgnoreCase('hEllo', 'hell0');
+        I.expectEqualIgnoreCase('hEllo', 'hell0')
       } catch (e) {
-        expect(e.message).to.contain('expected hEllo to equal hell0');
+        expect(e.message).to.contain('expected hEllo to equal hell0')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectDeepMembers', () => {
     it('should not show error', () => {
-      I.expectDeepMembers([1, 2, 3], [1, 2, 3]);
-    });
+      I.expectDeepMembers([1, 2, 3], [1, 2, 3])
+    })
 
     it('should show error', () => {
       try {
-        I.expectDeepMembers([1, 2, 3], [3]);
+        I.expectDeepMembers([1, 2, 3], [3])
       } catch (e) {
-        expect(e.message).to.contain('expected [ 1, 2, 3 ] to have the same members');
+        expect(e.message).to.contain('expected [ 1, 2, 3 ] to have the same members')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectDeepIncludeMembers', () => {
     it('should not show error', () => {
-      I.expectDeepIncludeMembers([3, 4, 5, 6], [3, 4, 5]);
-    });
+      I.expectDeepIncludeMembers([3, 4, 5, 6], [3, 4, 5])
+    })
 
     it('should show error', () => {
       try {
-        I.expectDeepIncludeMembers([3, 4, 5], [3, 4, 5, 6]);
+        I.expectDeepIncludeMembers([3, 4, 5], [3, 4, 5, 6])
       } catch (e) {
-        expect(e.message).to.contain('expected [ 3, 4, 5 ] to be a superset of [ 3, 4, 5, 6 ]');
+        expect(e.message).to.contain('expected [ 3, 4, 5 ] to be a superset of [ 3, 4, 5, 6 ]')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectDeepEqualExcluding', () => {
     it('should not show error', () => {
-      I.expectDeepEqualExcluding({ a: 1, b: 2 }, { b: 2, a: 1, c: 3 }, 'c');
-    });
+      I.expectDeepEqualExcluding({ a: 1, b: 2 }, { b: 2, a: 1, c: 3 }, 'c')
+    })
 
     it('should show error', () => {
       try {
-        I.expectDeepEqualExcluding({ a: 1, b: 2 }, { b: 2, a: 1, c: 3 }, 'a');
+        I.expectDeepEqualExcluding({ a: 1, b: 2 }, { b: 2, a: 1, c: 3 }, 'a')
       } catch (e) {
-        expect(e.message).to.contain('expected { b: 2 } to deeply equal');
+        expect(e.message).to.contain('expected { b: 2 } to deeply equal')
       }
-    });
-  });
+    })
+  })
 
   describe('#expectLengthBelowThan', () => {
     it('should not show error', () => {
-      I.expectMatchesPattern('123', /123/);
-    });
+      I.expectMatchesPattern('123', /123/)
+    })
 
     it('should show error', () => {
       try {
-        I.expectMatchesPattern('123', /1235/);
+        I.expectMatchesPattern('123', /1235/)
       } catch (e) {
-        expect(e.message).to.contain('didn\'t match target /1235/');
+        expect(e.message).to.contain("didn't match target /1235/")
       }
-    });
-  });
-});
+    })
+  })
+})
diff --git a/test/helper/JSONResponse_test.js b/test/helper/JSONResponse_test.js
index ee501091b..14e8f7d96 100644
--- a/test/helper/JSONResponse_test.js
+++ b/test/helper/JSONResponse_test.js
@@ -1,11 +1,11 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const joi = require('joi');
-const JSONResponse = require('../../lib/helper/JSONResponse');
-const Container = require('../../lib/container');
-global.codeceptjs = require('../../lib');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const joi = require('joi')
+const JSONResponse = require('../../lib/helper/JSONResponse')
+const Container = require('../../lib/container')
+global.codeceptjs = require('../../lib')
 
 const data = {
   posts: [
@@ -21,10 +21,10 @@ const data = {
   user: {
     name: 'davert',
   },
-};
+}
 
-let restHelper;
-let I;
+let restHelper
+let I
 
 describe('JSONResponse', () => {
   beforeEach(() => {
@@ -32,133 +32,129 @@ describe('JSONResponse', () => {
       helpers: {
         REST: {},
       },
-    });
+    })
 
-    I = new JSONResponse();
-    I._beforeSuite();
-    restHelper = Container.helpers('REST');
-  });
+    I = new JSONResponse()
+    I._beforeSuite()
+    restHelper = Container.helpers('REST')
+  })
 
   describe('response codes', () => {
     it('should check 200x codes', async () => {
-      restHelper.config.onResponse({ status: 204 });
-      I.seeResponseCodeIs(204);
-      I.dontSeeResponseCodeIs(200);
-      I.seeResponseCodeIsSuccessful();
-    });
+      restHelper.config.onResponse({ status: 204 })
+      I.seeResponseCodeIs(204)
+      I.dontSeeResponseCodeIs(200)
+      I.seeResponseCodeIsSuccessful()
+    })
 
     it('should check 300x codes', async () => {
-      restHelper.config.onResponse({ status: 304 });
-      I.seeResponseCodeIs(304);
-      I.dontSeeResponseCodeIs(200);
-      I.seeResponseCodeIsRedirection();
-    });
+      restHelper.config.onResponse({ status: 304 })
+      I.seeResponseCodeIs(304)
+      I.dontSeeResponseCodeIs(200)
+      I.seeResponseCodeIsRedirection()
+    })
 
     it('should check 400x codes', async () => {
-      restHelper.config.onResponse({ status: 404 });
-      I.seeResponseCodeIs(404);
-      I.dontSeeResponseCodeIs(200);
-      I.seeResponseCodeIsClientError();
-    });
+      restHelper.config.onResponse({ status: 404 })
+      I.seeResponseCodeIs(404)
+      I.dontSeeResponseCodeIs(200)
+      I.seeResponseCodeIsClientError()
+    })
 
     it('should check 500x codes', async () => {
-      restHelper.config.onResponse({ status: 504 });
-      I.seeResponseCodeIs(504);
-      I.dontSeeResponseCodeIs(200);
-      I.seeResponseCodeIsServerError();
-    });
+      restHelper.config.onResponse({ status: 504 })
+      I.seeResponseCodeIs(504)
+      I.dontSeeResponseCodeIs(200)
+      I.seeResponseCodeIsServerError()
+    })
 
     it('should throw error on invalid code', () => {
-      restHelper.config.onResponse({ status: 504 });
-      expect(() => I.seeResponseCodeIs(200)).to.throw('Response code');
-    });
-  });
+      restHelper.config.onResponse({ status: 504 })
+      expect(() => I.seeResponseCodeIs(200)).to.throw('Response code')
+    })
+  })
 
   describe('response data', () => {
     it('should check for json inclusion', () => {
-      restHelper.config.onResponse({ data });
+      restHelper.config.onResponse({ data })
       I.seeResponseContainsJson({
-        posts: [
-          { id: 2 },
-        ],
-      });
+        posts: [{ id: 2 }],
+      })
       I.seeResponseContainsJson({
-        posts: [
-          { id: 1, author: 'davert' },
-        ],
-      });
-      expect(() => I.seeResponseContainsJson({ posts: [{ id: 2, author: 'boss' }] })).to.throw('expected { …(2) } to deeply match { Object (posts) }');
-    });
+        posts: [{ id: 1, author: 'davert' }],
+      })
+      expect(() => I.seeResponseContainsJson({ posts: [{ id: 2, author: 'boss' }] })).to.throw(
+        'expected { …(2) } to deeply match { Object (posts) }',
+      )
+    })
 
     it('should check for json inclusion - returned Array', () => {
-      const arrayData = [{ ...data }];
-      restHelper.config.onResponse({ data: arrayData });
+      const arrayData = [{ ...data }]
+      restHelper.config.onResponse({ data: arrayData })
       I.seeResponseContainsJson({
-        posts: [
-          { id: 2 },
-        ],
-      });
+        posts: [{ id: 2 }],
+      })
       I.seeResponseContainsJson({
-        posts: [
-          { id: 1, author: 'davert' },
-        ],
-      });
-      expect(() => I.seeResponseContainsJson({ posts: [{ id: 2, author: 'boss' }] })).to.throw('No elements in array matched {"posts":[{"id":2,"author":"boss"}]}');
-    });
+        posts: [{ id: 1, author: 'davert' }],
+      })
+      expect(() => I.seeResponseContainsJson({ posts: [{ id: 2, author: 'boss' }] })).to.throw(
+        'No elements in array matched {"posts":[{"id":2,"author":"boss"}]}',
+      )
+    })
 
     it('should check for json inclusion - returned Array of 2 items', () => {
-      const arrayData = [{ ...data }, { posts: { id: 3 } }];
-      restHelper.config.onResponse({ data: arrayData });
+      const arrayData = [{ ...data }, { posts: { id: 3 } }]
+      restHelper.config.onResponse({ data: arrayData })
       I.seeResponseContainsJson({
         posts: { id: 3 },
-      });
-    });
+      })
+    })
 
     it('should simply check for json inclusion', () => {
-      restHelper.config.onResponse({ data: { user: { name: 'jon', email: 'jon@doe.com' } } });
-      I.seeResponseContainsJson({ user: { name: 'jon' } });
-      I.dontSeeResponseContainsJson({ user: { name: 'jo' } });
-      I.dontSeeResponseContainsJson({ name: 'joe' });
-    });
+      restHelper.config.onResponse({ data: { user: { name: 'jon', email: 'jon@doe.com' } } })
+      I.seeResponseContainsJson({ user: { name: 'jon' } })
+      I.dontSeeResponseContainsJson({ user: { name: 'jo' } })
+      I.dontSeeResponseContainsJson({ name: 'joe' })
+    })
 
     it('should simply check for json inclusion - returned Array', () => {
-      restHelper.config.onResponse({ data: [{ user: { name: 'jon', email: 'jon@doe.com' } }] });
-      I.seeResponseContainsJson({ user: { name: 'jon' } });
-      I.dontSeeResponseContainsJson({ user: { name: 'jo' } });
-      I.dontSeeResponseContainsJson({ name: 'joe' });
-    });
+      restHelper.config.onResponse({ data: [{ user: { name: 'jon', email: 'jon@doe.com' } }] })
+      I.seeResponseContainsJson({ user: { name: 'jon' } })
+      I.dontSeeResponseContainsJson({ user: { name: 'jo' } })
+      I.dontSeeResponseContainsJson({ name: 'joe' })
+    })
 
     it('should simply check for json equality', () => {
-      restHelper.config.onResponse({ data: { user: 1 } });
-      I.seeResponseEquals({ user: 1 });
-    });
+      restHelper.config.onResponse({ data: { user: 1 } })
+      I.seeResponseEquals({ user: 1 })
+    })
 
     it('should simply check for json equality - returned Array', () => {
-      restHelper.config.onResponse({ data: [{ user: 1 }] });
-      I.seeResponseEquals([{ user: 1 }]);
-    });
+      restHelper.config.onResponse({ data: [{ user: 1 }] })
+      I.seeResponseEquals([{ user: 1 }])
+    })
 
     it('should check json contains keys', () => {
-      restHelper.config.onResponse({ data: { user: 1, post: 2 } });
-      I.seeResponseContainsKeys(['user', 'post']);
-    });
+      restHelper.config.onResponse({ data: { user: 1, post: 2 } })
+      I.seeResponseContainsKeys(['user', 'post'])
+    })
 
     it('should check json contains keys - returned Array', () => {
-      restHelper.config.onResponse({ data: [{ user: 1, post: 2 }] });
-      I.seeResponseContainsKeys(['user', 'post']);
-    });
+      restHelper.config.onResponse({ data: [{ user: 1, post: 2 }] })
+      I.seeResponseContainsKeys(['user', 'post'])
+    })
 
     it('should check for json by callback', () => {
-      restHelper.config.onResponse({ data });
+      restHelper.config.onResponse({ data })
       const fn = ({ expect, data }) => {
-        expect(data).to.have.keys(['posts', 'user']);
-      };
-      I.seeResponseValidByCallback(fn);
-      expect(fn.toString()).to.include('expect(data).to.have');
-    });
+        expect(data).to.have.keys(['posts', 'user'])
+      }
+      I.seeResponseValidByCallback(fn)
+      expect(fn.toString()).to.include('expect(data).to.have')
+    })
 
     it('should check for json by joi schema', () => {
-      restHelper.config.onResponse({ data });
+      restHelper.config.onResponse({ data })
       const schema = joi.object({
         posts: joi.array().items({
           id: joi.number(),
@@ -168,12 +164,12 @@ describe('JSONResponse', () => {
         user: joi.object({
           name: joi.string(),
         }),
-      });
+      })
       const fn = () => {
-        return schema;
-      };
-      I.seeResponseMatchesJsonSchema(fn);
-      I.seeResponseMatchesJsonSchema(schema);
-    });
-  });
-});
+        return schema
+      }
+      I.seeResponseMatchesJsonSchema(fn)
+      I.seeResponseMatchesJsonSchema(schema)
+    })
+  })
+})
diff --git a/test/helper/MockServer_test.js b/test/helper/MockServer_test.js
index d22109a80..1faa6af4e 100644
--- a/test/helper/MockServer_test.js
+++ b/test/helper/MockServer_test.js
@@ -1,52 +1,52 @@
-const path = require('path');
+const path = require('path')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const { like } = require('pactum-matchers');
-const MockServer = require('../../lib/helper/MockServer');
-const REST = require('../../lib/helper/REST');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const { like } = require('pactum-matchers')
+const MockServer = require('../../lib/helper/MockServer')
+const REST = require('../../lib/helper/REST')
 
-global.codeceptjs = require('../../lib');
+global.codeceptjs = require('../../lib')
 
-let I;
-let restClient;
-const port = 65000;
-const api_url = `http://0.0.0.0:${port}`;
+let I
+let restClient
+const port = 65000
+const api_url = `http://0.0.0.0:${port}`
 
 describe('MockServer Helper', function () {
-  this.timeout(3000);
-  this.retries(1);
+  this.timeout(3000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
-    I = new MockServer({ port });
+    I = new MockServer({ port })
     restClient = new REST({
       endpoint: api_url,
       defaultHeaders: {
         'X-Test': 'test',
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    await I.startMockServer();
-  });
+    await I.startMockServer()
+  })
 
   afterEach(async () => {
-    await I.stopMockServer();
-  });
+    await I.stopMockServer()
+  })
 
   describe('#startMockServer', () => {
     it('should start the mock server with custom port', async () => {
-      global.debugMode = true;
-      await I.startMockServer(6789);
-      await I.stopMockServer();
-      global.debugMode = undefined;
-    });
-  });
+      global.debugMode = true
+      await I.startMockServer(6789)
+      await I.stopMockServer()
+      global.debugMode = undefined
+    })
+  })
 
   describe('#addInteractionToMockServer', () => {
     it('should return the correct response', async () => {
@@ -61,15 +61,15 @@ describe('MockServer Helper', function () {
             say: 'hello to mock server',
           },
         },
-      });
-      const res = await restClient.sendGetRequest('/api/hello');
-      expect(res.data).to.eql({ say: 'hello to mock server' });
-    });
+      })
+      const res = await restClient.sendGetRequest('/api/hello')
+      expect(res.data).to.eql({ say: 'hello to mock server' })
+    })
 
     it('should return 404 when not found route', async () => {
-      const res = await restClient.sendGetRequest('/api/notfound');
-      expect(res.status).to.eql(404);
-    });
+      const res = await restClient.sendGetRequest('/api/notfound')
+      expect(res.status).to.eql(404)
+    })
 
     it('should return the strong Match on Query Params', async () => {
       await I.addInteractionToMockServer({
@@ -86,7 +86,7 @@ describe('MockServer Helper', function () {
             user: 1,
           },
         },
-      });
+      })
 
       await I.addInteractionToMockServer({
         request: {
@@ -102,12 +102,12 @@ describe('MockServer Helper', function () {
             user: 2,
           },
         },
-      });
-      let res = await restClient.sendGetRequest('/api/users?id=1');
-      expect(res.data).to.eql({ user: 1 });
-      res = await restClient.sendGetRequest('/api/users?id=2');
-      expect(res.data).to.eql({ user: 2 });
-    });
+      })
+      let res = await restClient.sendGetRequest('/api/users?id=1')
+      expect(res.data).to.eql({ user: 1 })
+      res = await restClient.sendGetRequest('/api/users?id=2')
+      expect(res.data).to.eql({ user: 2 })
+    })
 
     it('should check the stateful behavior', async () => {
       await I.addInteractionToMockServer({
@@ -127,9 +127,9 @@ describe('MockServer Helper', function () {
             id: '$S{ProjectId}',
           },
         },
-      });
-      const res = await restClient.sendGetRequest('/api/projects/10');
-      expect(res.data).to.eql({ id: '10' });
-    });
-  });
-});
+      })
+      const res = await restClient.sendGetRequest('/api/projects/10')
+      expect(res.data).to.eql({ id: '10' })
+    })
+  })
+})
diff --git a/test/helper/Playwright_test.js b/test/helper/Playwright_test.js
index 2dfcb799b..d36bd4347 100644
--- a/test/helper/Playwright_test.js
+++ b/test/helper/Playwright_test.js
@@ -1,39 +1,39 @@
-let assert;
-let expect;
-import('chai').then(chai => {
-  assert = chai.assert;
-  expect = chai.expect;
-});
+let assert
+let expect
+import('chai').then((chai) => {
+  assert = chai.assert
+  expect = chai.expect
+})
 
-const path = require('path');
-const fs = require('fs');
+const path = require('path')
+const fs = require('fs')
 
-const playwright = require('playwright');
+const playwright = require('playwright')
 
-const TestHelper = require('../support/TestHelper');
-const Playwright = require('../../lib/helper/Playwright');
+const TestHelper = require('../support/TestHelper')
+const Playwright = require('../../lib/helper/Playwright')
 
-const AssertionFailedError = require('../../lib/assert/error');
-const webApiTests = require('./webapi');
-const FileSystem = require('../../lib/helper/FileSystem');
-const { deleteDir } = require('../../lib/utils');
-const Secret = require('../../lib/secret');
-global.codeceptjs = require('../../lib');
+const AssertionFailedError = require('../../lib/assert/error')
+const webApiTests = require('./webapi')
+const FileSystem = require('../../lib/helper/FileSystem')
+const { deleteDir } = require('../../lib/utils')
+const Secret = require('../../lib/secret')
+global.codeceptjs = require('../../lib')
 
-const dataFile = path.join(__dirname, '/../data/app/db');
-const formContents = require('../../lib/utils').test.submittedData(dataFile);
+const dataFile = path.join(__dirname, '/../data/app/db')
+const formContents = require('../../lib/utils').test.submittedData(dataFile)
 
-let I;
-let page;
-let FS;
-const siteUrl = TestHelper.siteUrl();
+let I
+let page
+let FS
+const siteUrl = TestHelper.siteUrl()
 
 describe('Playwright', function () {
-  this.timeout(35000);
-  this.retries(1);
+  this.timeout(35000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Playwright({
       url: siteUrl,
@@ -48,163 +48,164 @@ describe('Playwright', function () {
         args: ['--no-sandbox', '--disable-setuid-sandbox'],
       },
       defaultPopupAction: 'accept',
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('restart browser: #restartBrowser', () => {
     it('should open a new tab after restart of browser', async () => {
-      await I.restartBrowser();
-      await I.wait(1);
-      const numPages = await I.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
-    });
-  });
+      await I.restartBrowser()
+      await I.wait(1)
+      const numPages = await I.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
+    })
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await I.amOnPage('/');
-      const url = await page.url();
-      await url.should.eql(`${siteUrl}/`);
-    });
+      await I.amOnPage('/')
+      const url = await page.url()
+      await url.should.eql(`${siteUrl}/`)
+    })
     it('should open any page of configured site', async () => {
-      await I.amOnPage('/info');
-      const url = await page.url();
-      return url.should.eql(`${siteUrl}/info`);
-    });
+      await I.amOnPage('/info')
+      const url = await page.url()
+      return url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await I.amOnPage(siteUrl);
-      const url = await page.url();
-      return url.should.eql(`${siteUrl}/`);
-    });
+      await I.amOnPage(siteUrl)
+      const url = await page.url()
+      return url.should.eql(`${siteUrl}/`)
+    })
 
     it('should open any page of configured site without leading slash', async () => {
-      await I.amOnPage('info');
-      const url = await page.url();
-      return url.should.eql(`${siteUrl}/info`);
-    });
+      await I.amOnPage('info')
+      const url = await page.url()
+      return url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open blank page', async () => {
-      await I.amOnPage('about:blank');
-      const url = await page.url();
-      return url.should.eql('about:blank');
-    });
-  });
+      await I.amOnPage('about:blank')
+      const url = await page.url()
+      return url.should.eql('about:blank')
+    })
+  })
 
   describe('grabDataFromPerformanceTiming', () => {
     it('should return data from performance timing', async () => {
-      await I.amOnPage('/');
-      const res = await I.grabDataFromPerformanceTiming();
-      expect(res).to.have.property('responseEnd');
-      expect(res).to.have.property('domInteractive');
-      expect(res).to.have.property('domContentLoadedEventEnd');
-      expect(res).to.have.property('loadEventEnd');
-    });
-  });
+      await I.amOnPage('/')
+      const res = await I.grabDataFromPerformanceTiming()
+      expect(res).to.have.property('responseEnd')
+      expect(res).to.have.property('domInteractive')
+      expect(res).to.have.property('domContentLoadedEventEnd')
+      expect(res).to.have.property('loadEventEnd')
+    })
+  })
 
   describe('#seeCssPropertiesOnElements', () => {
     it('should check background-color css property for given element', async () => {
       try {
-        await I.amOnPage('https://codecept.io/helpers/Playwright/');
-        await I.seeCssPropertiesOnElements('.navbar', { 'background-color': 'rgb(128, 90, 213)' });
+        await I.amOnPage('https://codecept.io/helpers/Playwright/')
+        await I.seeCssPropertiesOnElements('.navbar', { 'background-color': 'rgb(128, 90, 213)' })
       } catch (e) {
-        e.message.should.include('expected element (.navbar) to have CSS property { \'background-color\': \'rgb(128, 90, 213)\' }');
+        e.message.should.include(
+          "expected element (.navbar) to have CSS property { 'background-color': 'rgb(128, 90, 213)' }",
+        )
       }
-    });
-  });
+    })
+  })
 
-  webApiTests.tests();
+  webApiTests.tests()
 
   describe('#click', () => {
     it('should not try to click on invisible elements', async () => {
-      await I.amOnPage('/invisible_elements');
-      await I.click('Hello World');
-    });
-  });
+      await I.amOnPage('/invisible_elements')
+      await I.click('Hello World')
+    })
+  })
   describe('#grabCheckedElementStatus', () => {
     it('check grabCheckedElementStatus', async () => {
-      await I.amOnPage('/invisible_elements');
-      let result = await I.grabCheckedElementStatus({ id: 'html' });
-      assert.equal(result, true);
-      result = await I.grabCheckedElementStatus({ id: 'css' });
-      assert.equal(result, false);
-      result = await I.grabCheckedElementStatus({ id: 'js' });
-      assert.equal(result, true);
-      result = await I.grabCheckedElementStatus({ id: 'ts' });
-      assert.equal(result, false);
+      await I.amOnPage('/invisible_elements')
+      let result = await I.grabCheckedElementStatus({ id: 'html' })
+      assert.equal(result, true)
+      result = await I.grabCheckedElementStatus({ id: 'css' })
+      assert.equal(result, false)
+      result = await I.grabCheckedElementStatus({ id: 'js' })
+      assert.equal(result, true)
+      result = await I.grabCheckedElementStatus({ id: 'ts' })
+      assert.equal(result, false)
       try {
-        await I.grabCheckedElementStatus({ id: 'basic' });
+        await I.grabCheckedElementStatus({ id: 'basic' })
       } catch (e) {
-        assert.equal(e.message, 'Element is not a checkbox or radio input');
+        assert.equal(e.message, 'Element is not a checkbox or radio input')
       }
-    });
-  });
+    })
+  })
   describe('#grabDisabledElementStatus', () => {
     it('check isElementDisabled', async () => {
-      await I.amOnPage('/invisible_elements');
-      let result = await I.grabDisabledElementStatus({ id: 'fortran' });
-      assert.equal(result, true);
-      result = await I.grabDisabledElementStatus({ id: 'basic' });
-      assert.equal(result, false);
-    });
-  });
+      await I.amOnPage('/invisible_elements')
+      let result = await I.grabDisabledElementStatus({ id: 'fortran' })
+      assert.equal(result, true)
+      result = await I.grabDisabledElementStatus({ id: 'basic' })
+      assert.equal(result, false)
+    })
+  })
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(() => window.__waitJs, 3));
-    });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction(() => window.__waitJs, 3))
+    })
 
     it('should pass arguments and wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(varName => window[varName], ['__waitJs'], 3));
-    });
-  });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction((varName) => window[varName], ['__waitJs'], 3))
+    })
+  })
 
   describe('#waitForVisible #waitForInvisible - within block', () => {
     it('should wait for visible element', async () => {
-      await I.amOnPage('/iframe');
+      await I.amOnPage('/iframe')
       await I._withinBegin({
         frame: '#number-frame-1234',
-      });
+      })
 
-      await I.waitForVisible('h1');
-    });
+      await I.waitForVisible('h1')
+    })
 
     it('should wait for invisible element', async () => {
-      await I.amOnPage('/iframe');
+      await I.amOnPage('/iframe')
       await I._withinBegin({
         frame: '#number-frame-1234',
-      });
+      })
 
-      await I.waitForInvisible('h9');
-    });
+      await I.waitForInvisible('h9')
+    })
 
     it('should wait for element to hide', async () => {
-      await I.amOnPage('/iframe');
+      await I.amOnPage('/iframe')
       await I._withinBegin({
         frame: '#number-frame-1234',
-      });
+      })
 
-      await I.waitToHide('h9');
-    });
-  });
+      await I.waitToHide('h9')
+    })
+  })
 
   describe('#waitToHide', () => {
     it('should wait for hidden element', () => {
@@ -212,818 +213,898 @@ describe('Playwright', function () {
         .then(() => I.see('Step One Button'))
         .then(() => I.waitToHide('#step_1', 2))
         .then(() => I.dontSeeElement('#step_1'))
-        .then(() => I.dontSee('Step One Button'));
-    });
+        .then(() => I.dontSee('Step One Button'))
+    })
 
     it('should wait for hidden element by XPath', () => {
       return I.amOnPage('/form/wait_invisible')
         .then(() => I.see('Step One Button'))
         .then(() => I.waitToHide('//div[@id="step_1"]', 2))
         .then(() => I.dontSeeElement('//div[@id="step_1"]'))
-        .then(() => I.dontSee('Step One Button'));
-    });
-  });
+        .then(() => I.dontSee('Step One Button'))
+    })
+  })
 
   describe('#waitNumberOfVisibleElements', () => {
-    it('should wait for a specified number of elements on the page', () => I.amOnPage('/info')
-      .then(() => I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3))
-      .then(() => I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 2, 0.1))
-      .then(() => {
-        throw Error('It should never get this far');
-      })
-      .catch((e) => {
-        e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec');
-      }));
-
-    it('should wait for a specified number of elements on the page using a css selector', () => I.amOnPage('/info')
-      .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 3))
-      .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
-      .then(() => {
-        throw Error('It should never get this far');
-      })
-      .catch((e) => {
-        e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec');
-      }));
-
-    it('should wait for a specified number of elements which are not yet attached to the DOM', () => I.amOnPage('/form/wait_num_elements')
-      .then(() => I.waitNumberOfVisibleElements('.title', 2, 3))
-      .then(() => I.see('Hello'))
-      .then(() => I.see('World')));
+    it('should wait for a specified number of elements on the page', () =>
+      I.amOnPage('/info')
+        .then(() => I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3))
+        .then(() => I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 2, 0.1))
+        .then(() => {
+          throw Error('It should never get this far')
+        })
+        .catch((e) => {
+          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec')
+        }))
+
+    it('should wait for a specified number of elements on the page using a css selector', () =>
+      I.amOnPage('/info')
+        .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 3))
+        .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
+        .then(() => {
+          throw Error('It should never get this far')
+        })
+        .catch((e) => {
+          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec')
+        }))
+
+    it('should wait for a specified number of elements which are not yet attached to the DOM', () =>
+      I.amOnPage('/form/wait_num_elements')
+        .then(() => I.waitNumberOfVisibleElements('.title', 2, 3))
+        .then(() => I.see('Hello'))
+        .then(() => I.see('World')))
 
     it('should wait for 0 number of visible elements', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.waitNumberOfVisibleElements('#step_1', 0);
-    });
-  });
+      await I.amOnPage('/form/wait_invisible')
+      await I.waitNumberOfVisibleElements('#step_1', 0)
+    })
+  })
 
   describe('#moveCursorTo', () => {
-    it('should trigger hover event', () => I.amOnPage('/form/hover')
-      .then(() => I.moveCursorTo('#hover'))
-      .then(() => I.see('Hovered', '#show')));
+    it('should trigger hover event', () =>
+      I.amOnPage('/form/hover')
+        .then(() => I.moveCursorTo('#hover'))
+        .then(() => I.see('Hovered', '#show')))
 
-    it('should not trigger hover event because of the offset is beyond the element', () => I.amOnPage('/form/hover')
-      .then(() => I.moveCursorTo('#hover', 100, 100))
-      .then(() => I.dontSee('Hovered', '#show')));
-  });
+    it('should not trigger hover event because of the offset is beyond the element', () =>
+      I.amOnPage('/form/hover')
+        .then(() => I.moveCursorTo('#hover', 100, 100))
+        .then(() => I.dontSee('Hovered', '#show')))
+  })
 
   describe('#switchToNextTab, #switchToPreviousTab, #openNewTab, #closeCurrentTab, #closeOtherTabs, #grabNumberOfOpenTabs, #waitForNumberOfTabs', () => {
-    it('should only have 1 tab open when the browser starts and navigates to the first page', () => I.amOnPage('/')
-      .then(() => I.wait(1))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 1)));
-
-    it('should switch to next tab', () => I.amOnPage('/info')
-      .then(() => I.wait(1))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 1))
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeCurrentUrlEquals('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 2)));
-
-    it('should assert when there is no ability to switch to next tab', () => I.amOnPage('/')
-      .then(() => I.click('More info'))
-      .then(() => I.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
-      .then(() => I.switchToNextTab(2))
-      .then(() => I.wait(2))
-      .then(() => assert.equal(true, false, 'Throw an error if it gets this far (which it should not)!'))
-      .catch((e) => {
-        assert.equal(e.message, 'There is no ability to switch to next tab with offset 2');
-      }));
-
-    it('should close current tab', () => I.amOnPage('/info')
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeInCurrentUrl('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 2))
-      .then(() => I.closeCurrentTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('/info'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 1)));
-
-    it('should close other tabs', () => I.amOnPage('/')
-      .then(() => I.openNewTab())
-      .then(() => I.waitForNumberOfTabs(2))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.amOnPage('/info'))
-      .then(() => I.openNewTab())
-      .then(() => I.amOnPage('/login'))
-      .then(() => I.closeOtherTabs())
-      .then(() => I.waitForNumberOfTabs(1))
-      .then(() => I.seeInCurrentUrl('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 1)));
-
-    it('should open new tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => assert.equal(numPages, 2)));
-
-    it('should switch to previous tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.switchToPreviousTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeInCurrentUrl('/info')));
-
-    it('should assert when there is no ability to switch to previous tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.waitInUrl('about:blank'))
-      .then(() => I.switchToPreviousTab(2))
-      .then(() => I.wait(2))
-      .then(() => I.waitInUrl('/info'))
-      .catch((e) => {
-        assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2');
-      }));
-  });
+    it('should only have 1 tab open when the browser starts and navigates to the first page', () =>
+      I.amOnPage('/')
+        .then(() => I.wait(1))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 1)))
+
+    it('should switch to next tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.wait(1))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 1))
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeCurrentUrlEquals('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 2)))
+
+    it('should assert when there is no ability to switch to next tab', () =>
+      I.amOnPage('/')
+        .then(() => I.click('More info'))
+        .then(() => I.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
+        .then(() => I.switchToNextTab(2))
+        .then(() => I.wait(2))
+        .then(() => assert.equal(true, false, 'Throw an error if it gets this far (which it should not)!'))
+        .catch((e) => {
+          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2')
+        }))
+
+    it('should close current tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeInCurrentUrl('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 2))
+        .then(() => I.closeCurrentTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('/info'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 1)))
+
+    it('should close other tabs', () =>
+      I.amOnPage('/')
+        .then(() => I.openNewTab())
+        .then(() => I.waitForNumberOfTabs(2))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.amOnPage('/info'))
+        .then(() => I.openNewTab())
+        .then(() => I.amOnPage('/login'))
+        .then(() => I.closeOtherTabs())
+        .then(() => I.waitForNumberOfTabs(1))
+        .then(() => I.seeInCurrentUrl('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 1)))
+
+    it('should open new tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => assert.equal(numPages, 2)))
+
+    it('should switch to previous tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.switchToPreviousTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeInCurrentUrl('/info')))
+
+    it('should assert when there is no ability to switch to previous tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.waitInUrl('about:blank'))
+        .then(() => I.switchToPreviousTab(2))
+        .then(() => I.wait(2))
+        .then(() => I.waitInUrl('/info'))
+        .catch((e) => {
+          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2')
+        }))
+  })
 
   describe('popup : #acceptPopup, #seeInPopup, #cancelPopup, #grabPopupText', () => {
-    it('should accept popup window', () => I.amOnPage('/form/popup')
-      .then(() => I.amAcceptingPopups())
-      .then(() => I.click('Confirm'))
-      .then(() => I.acceptPopup())
-      .then(() => I.see('Yes', '#result')));
-
-    it('should accept popup window (using default popup action type)', () => I.amOnPage('/form/popup')
-      .then(() => I.click('Confirm'))
-      .then(() => I.acceptPopup())
-      .then(() => I.see('Yes', '#result')));
-
-    it('should cancel popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Confirm'))
-      .then(() => I.cancelPopup())
-      .then(() => I.see('No', '#result')));
-
-    it('should check text in popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Alert'))
-      .then(() => I.seeInPopup('Really?'))
-      .then(() => I.cancelPopup()));
-
-    it('should grab text from popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Alert'))
-      .then(() => I.grabPopupText())
-      .then(text => assert.equal(text, 'Really?')));
-
-    it('should return null if no popup is visible (do not throw an error)', () => I.amOnPage('/form/popup')
-      .then(() => I.grabPopupText())
-      .then(text => assert.equal(text, null)));
-  });
+    it('should accept popup window', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amAcceptingPopups())
+        .then(() => I.click('Confirm'))
+        .then(() => I.acceptPopup())
+        .then(() => I.see('Yes', '#result')))
+
+    it('should accept popup window (using default popup action type)', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.click('Confirm'))
+        .then(() => I.acceptPopup())
+        .then(() => I.see('Yes', '#result')))
+
+    it('should cancel popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Confirm'))
+        .then(() => I.cancelPopup())
+        .then(() => I.see('No', '#result')))
+
+    it('should check text in popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Alert'))
+        .then(() => I.seeInPopup('Really?'))
+        .then(() => I.cancelPopup()))
+
+    it('should grab text from popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Alert'))
+        .then(() => I.grabPopupText())
+        .then((text) => assert.equal(text, 'Really?')))
+
+    it('should return null if no popup is visible (do not throw an error)', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.grabPopupText())
+        .then((text) => assert.equal(text, null)))
+  })
 
   describe('#seeNumberOfElements', () => {
-    it('should return 1 as count', () => I.amOnPage('/')
-      .then(() => I.seeNumberOfElements('#area1', 1)));
-  });
+    it('should return 1 as count', () => I.amOnPage('/').then(() => I.seeNumberOfElements('#area1', 1)))
+  })
 
   describe('#switchTo', () => {
     it('should switch reference to iframe content', () => {
-      I.amOnPage('/iframe');
-      I.switchTo('[name="content"]');
-      I.see('Information');
-      I.see('Lots of valuable data here');
-    });
-
-    it('should return error if iframe selector is invalid', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('#invalidIframeSelector'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
-      }));
-
-    it('should return error if iframe selector is not iframe', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('h1'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
-      }));
+      I.amOnPage('/iframe')
+      I.switchTo('[name="content"]')
+      I.see('Information')
+      I.see('Lots of valuable data here')
+    })
+
+    it('should return error if iframe selector is invalid', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('#invalidIframeSelector'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
+        }))
+
+    it('should return error if iframe selector is not iframe', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('h1'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
+        }))
 
     it('should return to parent frame given a null locator', async () => {
-      I.amOnPage('/iframe');
-      I.switchTo('[name="content"]');
-      I.see('Information');
-      I.see('Lots of valuable data here');
-      I.switchTo(null);
-      I.see('Iframe test');
-    });
+      I.amOnPage('/iframe')
+      I.switchTo('[name="content"]')
+      I.see('Information')
+      I.see('Lots of valuable data here')
+      I.switchTo(null)
+      I.see('Iframe test')
+    })
 
     it('should switch to iframe using css', () => {
-      I.amOnPage('/iframe');
-      I.switchTo('iframe#number-frame-1234');
-      I.see('Information');
-      I.see('Lots of valuable data here');
-    });
+      I.amOnPage('/iframe')
+      I.switchTo('iframe#number-frame-1234')
+      I.see('Information')
+      I.see('Lots of valuable data here')
+    })
 
     it('should switch to iframe using css when there are more than one iframes', () => {
-      I.amOnPage('/iframes');
-      I.switchTo('iframe#number-frame-1234');
-      I.see('Information');
-    });
-  });
+      I.amOnPage('/iframes')
+      I.switchTo('iframe#number-frame-1234')
+      I.see('Information')
+    })
+  })
 
   describe('#seeInSource, #grabSource', () => {
-    it('should check for text to be in HTML source', () => I.amOnPage('/')
-      .then(() => I.seeInSource('<title>TestEd Beta 2.0</title>'))
-      .then(() => I.dontSeeInSource('<meta')));
-
-    it('should grab the source', () => I.amOnPage('/')
-      .then(() => I.grabSource())
-      .then(source => assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved')));
-  });
+    it('should check for text to be in HTML source', () =>
+      I.amOnPage('/')
+        .then(() => I.seeInSource('<title>TestEd Beta 2.0</title>'))
+        .then(() => I.dontSeeInSource('<meta')))
+
+    it('should grab the source', () =>
+      I.amOnPage('/')
+        .then(() => I.grabSource())
+        .then((source) =>
+          assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved'),
+        ))
+  })
 
   describe('#seeTitleEquals', () => {
-    it('should check that title is equal to provided one', () => I.amOnPage('/')
-      .then(() => I.seeTitleEquals('TestEd Beta 2.0'))
-      .then(() => I.seeTitleEquals('TestEd Beta 2.'))
-      .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected web page title "TestEd Beta 2.0" to equal "TestEd Beta 2."');
-      }));
-  });
+    it('should check that title is equal to provided one', () =>
+      I.amOnPage('/')
+        .then(() => I.seeTitleEquals('TestEd Beta 2.0'))
+        .then(() => I.seeTitleEquals('TestEd Beta 2.'))
+        .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('expected web page title "TestEd Beta 2.0" to equal "TestEd Beta 2."')
+        }))
+  })
 
   describe('#seeTextEquals', () => {
-    it('should check text is equal to provided one', () => I.amOnPage('/')
-      .then(() => I.seeTextEquals('Welcome to test app!', 'h1'))
-      .then(() => I.seeTextEquals('Welcome to test app', 'h1'))
-      .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"');
-      }));
-  });
+    it('should check text is equal to provided one', () =>
+      I.amOnPage('/')
+        .then(() => I.seeTextEquals('Welcome to test app!', 'h1'))
+        .then(() => I.seeTextEquals('Welcome to test app', 'h1'))
+        .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"')
+        }))
+  })
 
   describe('#selectOption', () => {
     it('should select option by label and partial option text', async () => {
-      await I.amOnPage('/form/select');
-      await I.selectOption('Select your age', '21-');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'adult');
-    });
-  });
+      await I.amOnPage('/form/select')
+      await I.selectOption('Select your age', '21-')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'adult')
+    })
+  })
 
   describe('#_locateClickable', () => {
-    it('should locate a button to click', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateClickable('Submit'))
-      .then((res) => {
-        res.length.should.be.equal(1);
-      }));
-
-    it('should not locate a non-existing checkbox using _locateClickable', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateClickable('I disagree'))
-      .then(res => res.length.should.be.equal(0)));
-  });
+    it('should locate a button to click', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateClickable('Submit'))
+        .then((res) => {
+          res.length.should.be.equal(1)
+        }))
+
+    it('should not locate a non-existing checkbox using _locateClickable', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateClickable('I disagree'))
+        .then((res) => res.length.should.be.equal(0)))
+  })
 
   describe('#_locateCheckable', () => {
-    it('should locate a checkbox', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateCheckable('I Agree'))
-      .then(res => res.should.be.not.undefined));
-  });
+    it('should locate a checkbox', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateCheckable('I Agree'))
+        .then((res) => res.should.be.not.undefined))
+  })
 
   describe('#_locateFields', () => {
-    it('should locate a field', () => I.amOnPage('/form/field')
-      .then(() => I._locateFields('Name'))
-      .then(res => res.length.should.be.equal(1)));
+    it('should locate a field', () =>
+      I.amOnPage('/form/field')
+        .then(() => I._locateFields('Name'))
+        .then((res) => res.length.should.be.equal(1)))
 
-    it('should not locate a non-existing field', () => I.amOnPage('/form/field')
-      .then(() => I._locateFields('Mother-in-law'))
-      .then(res => res.length.should.be.equal(0)));
-  });
+    it('should not locate a non-existing field', () =>
+      I.amOnPage('/form/field')
+        .then(() => I._locateFields('Mother-in-law'))
+        .then((res) => res.length.should.be.equal(0)))
+  })
 
   describe('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
-    it('should throw error if field is not empty', () => I.amOnPage('/form/empty')
-      .then(() => I.seeInField('#empty_input', 'Ayayay'))
-      .catch((e) => {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"');
-      }));
+    it('should throw error if field is not empty', () =>
+      I.amOnPage('/form/empty')
+        .then(() => I.seeInField('#empty_input', 'Ayayay'))
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError)
+          e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"')
+        }))
 
     it('should check values in checkboxes', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('checkbox[]', 'not seen one');
-      await I.seeInField('checkbox[]', 'see test one');
-      await I.dontSeeInField('checkbox[]', 'not seen two');
-      await I.seeInField('checkbox[]', 'see test two');
-      await I.dontSeeInField('checkbox[]', 'not seen three');
-      await I.seeInField('checkbox[]', 'see test three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('checkbox[]', 'not seen one')
+      await I.seeInField('checkbox[]', 'see test one')
+      await I.dontSeeInField('checkbox[]', 'not seen two')
+      await I.seeInField('checkbox[]', 'see test two')
+      await I.dontSeeInField('checkbox[]', 'not seen three')
+      await I.seeInField('checkbox[]', 'see test three')
+    })
 
     it('should check values are the secret type in checkboxes', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen one'));
-      await I.seeInField('checkbox[]', Secret.secret('see test one'));
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen two'));
-      await I.seeInField('checkbox[]', Secret.secret('see test two'));
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen three'));
-      await I.seeInField('checkbox[]', Secret.secret('see test three'));
-    });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen one'))
+      await I.seeInField('checkbox[]', Secret.secret('see test one'))
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen two'))
+      await I.seeInField('checkbox[]', Secret.secret('see test two'))
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen three'))
+      await I.seeInField('checkbox[]', Secret.secret('see test three'))
+    })
 
     it('should check values with boolean', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('checkbox1', true);
-      await I.dontSeeInField('checkbox1', false);
-      await I.seeInField('checkbox2', false);
-      await I.dontSeeInField('checkbox2', true);
-      await I.seeInField('radio2', true);
-      await I.dontSeeInField('radio2', false);
-      await I.seeInField('radio3', false);
-      await I.dontSeeInField('radio3', true);
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('checkbox1', true)
+      await I.dontSeeInField('checkbox1', false)
+      await I.seeInField('checkbox2', false)
+      await I.dontSeeInField('checkbox2', true)
+      await I.seeInField('radio2', true)
+      await I.dontSeeInField('radio2', false)
+      await I.seeInField('radio3', false)
+      await I.dontSeeInField('radio3', true)
+    })
 
     it('should check values in radio', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('radio1', 'see test one');
-      await I.dontSeeInField('radio1', 'not seen one');
-      await I.dontSeeInField('radio1', 'not seen two');
-      await I.dontSeeInField('radio1', 'not seen three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('radio1', 'see test one')
+      await I.dontSeeInField('radio1', 'not seen one')
+      await I.dontSeeInField('radio1', 'not seen two')
+      await I.dontSeeInField('radio1', 'not seen three')
+    })
 
     it('should check values in select', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('select1', 'see test one');
-      await I.dontSeeInField('select1', 'not seen one');
-      await I.dontSeeInField('select1', 'not seen two');
-      await I.dontSeeInField('select1', 'not seen three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('select1', 'see test one')
+      await I.dontSeeInField('select1', 'not seen one')
+      await I.dontSeeInField('select1', 'not seen two')
+      await I.dontSeeInField('select1', 'not seen three')
+    })
 
     it('should check for empty select field', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('select3', '');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('select3', '')
+    })
 
     it('should check for select multiple field', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('select2', 'not seen one');
-      await I.seeInField('select2', 'see test one');
-      await I.dontSeeInField('select2', 'not seen two');
-      await I.seeInField('select2', 'see test two');
-      await I.dontSeeInField('select2', 'not seen three');
-      await I.seeInField('select2', 'see test three');
-    });
-  });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('select2', 'not seen one')
+      await I.seeInField('select2', 'see test one')
+      await I.dontSeeInField('select2', 'not seen two')
+      await I.seeInField('select2', 'see test two')
+      await I.dontSeeInField('select2', 'not seen three')
+      await I.seeInField('select2', 'see test three')
+    })
+  })
 
   describe('#clearField', () => {
     it('should clear input', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', 'value that is cleared using I.clearField()');
-      await I.clearField('Name');
-      await I.dontSeeInField('Name', 'value that is cleared using I.clearField()');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', 'value that is cleared using I.clearField()')
+      await I.clearField('Name')
+      await I.dontSeeInField('Name', 'value that is cleared using I.clearField()')
+    })
 
     it('should clear div textarea', async () => {
-      await I.amOnPage('/form/field');
-      await I.clearField('#textarea');
-      await I.dontSeeInField('#textarea', 'I look like textarea');
-    });
+      await I.amOnPage('/form/field')
+      await I.clearField('#textarea')
+      await I.dontSeeInField('#textarea', 'I look like textarea')
+    })
 
     it('should clear textarea', async () => {
-      await I.amOnPage('/form/textarea');
-      await I.fillField('#description', 'value that is cleared using I.clearField()');
-      await I.clearField('#description');
-      await I.dontSeeInField('#description', 'value that is cleared using I.clearField()');
-    });
+      await I.amOnPage('/form/textarea')
+      await I.fillField('#description', 'value that is cleared using I.clearField()')
+      await I.clearField('#description')
+      await I.dontSeeInField('#description', 'value that is cleared using I.clearField()')
+    })
 
     xit('should clear contenteditable', async () => {
-      const isClearMethodPresent = await I.usePlaywrightTo('check if new Playwright .clear() method present', async ({ page }) => {
-        return typeof page.locator().clear === 'function';
-      });
+      const isClearMethodPresent = await I.usePlaywrightTo(
+        'check if new Playwright .clear() method present',
+        async ({ page }) => {
+          return typeof page.locator().clear === 'function'
+        },
+      )
       if (!isClearMethodPresent) {
-        this.skip();
+        this.skip()
       }
 
-      await I.amOnPage('/form/contenteditable');
-      await I.clearField('#contenteditableDiv');
-      await I.dontSee('This is editable. Click here to edit this text.', '#contenteditableDiv');
-    });
-  });
+      await I.amOnPage('/form/contenteditable')
+      await I.clearField('#contenteditableDiv')
+      await I.dontSee('This is editable. Click here to edit this text.', '#contenteditableDiv')
+    })
+  })
 
   describe('#pressKey, #pressKeyDown, #pressKeyUp', () => {
     it('should be able to send special keys to element', async () => {
-      await I.amOnPage('/form/field');
-      await I.appendField('Name', '-');
+      await I.amOnPage('/form/field')
+      await I.appendField('Name', '-')
 
-      await I.pressKey(['Right Shift', 'Home']);
-      await I.pressKey('Delete');
+      await I.pressKey(['Right Shift', 'Home'])
+      await I.pressKey('Delete')
 
       // Sequence only executes up to first non-modifier key ('Digit1')
-      await I.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4']);
-      await I.pressKey('1');
-      await I.pressKey('2');
-      await I.pressKey('3');
-      await I.pressKey('ArrowLeft');
-      await I.pressKey('Left Arrow');
-      await I.pressKey('arrow_left');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('a');
-      await I.pressKey('KeyB');
-      await I.pressKeyUp('ShiftLeft');
-      await I.pressKey('C');
-      await I.seeInField('Name', '!ABC123');
-    });
+      await I.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4'])
+      await I.pressKey('1')
+      await I.pressKey('2')
+      await I.pressKey('3')
+      await I.pressKey('ArrowLeft')
+      await I.pressKey('Left Arrow')
+      await I.pressKey('arrow_left')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('a')
+      await I.pressKey('KeyB')
+      await I.pressKeyUp('ShiftLeft')
+      await I.pressKey('C')
+      await I.seeInField('Name', '!ABC123')
+    })
 
     it('should use modifier key based on operating system', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', 'value that is cleared using select all shortcut');
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', 'value that is cleared using select all shortcut')
 
-      await I.pressKey(['ControlOrCommand', 'a']);
-      await I.pressKey('Backspace');
-      await I.dontSeeInField('Name', 'value that is cleared using select all shortcut');
-    });
+      await I.pressKey(['ControlOrCommand', 'a'])
+      await I.pressKey('Backspace')
+      await I.dontSeeInField('Name', 'value that is cleared using select all shortcut')
+    })
 
     it('should show correct numpad or punctuation key when Shift modifier is active', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', '');
-
-      await I.pressKey(';');
-      await I.pressKey(['Shift', ';']);
-      await I.pressKey(['Shift', 'Semicolon']);
-      await I.pressKey('=');
-      await I.pressKey(['Shift', '=']);
-      await I.pressKey(['Shift', 'Equal']);
-      await I.pressKey('*');
-      await I.pressKey(['Shift', '*']);
-      await I.pressKey(['Shift', 'Multiply']);
-      await I.pressKey('+');
-      await I.pressKey(['Shift', '+']);
-      await I.pressKey(['Shift', 'Add']);
-      await I.pressKey(',');
-      await I.pressKey(['Shift', ',']);
-      await I.pressKey(['Shift', 'Comma']);
-      await I.pressKey(['Shift', 'NumpadComma']);
-      await I.pressKey(['Shift', 'Separator']);
-      await I.pressKey('-');
-      await I.pressKey(['Shift', '-']);
-      await I.pressKey(['Shift', 'Subtract']);
-      await I.pressKey('.');
-      await I.pressKey(['Shift', '.']);
-      await I.pressKey('/');
-      await I.pressKey(['Shift', '/']);
-      await I.pressKey(['Shift', 'Divide']);
-      await I.pressKey(['Shift', 'Slash']);
-
-      await I.seeInField('Name', ';::=++***+++,<<<<-_-.>/?/?');
-    });
-  });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', '')
+
+      await I.pressKey(';')
+      await I.pressKey(['Shift', ';'])
+      await I.pressKey(['Shift', 'Semicolon'])
+      await I.pressKey('=')
+      await I.pressKey(['Shift', '='])
+      await I.pressKey(['Shift', 'Equal'])
+      await I.pressKey('*')
+      await I.pressKey(['Shift', '*'])
+      await I.pressKey(['Shift', 'Multiply'])
+      await I.pressKey('+')
+      await I.pressKey(['Shift', '+'])
+      await I.pressKey(['Shift', 'Add'])
+      await I.pressKey(',')
+      await I.pressKey(['Shift', ','])
+      await I.pressKey(['Shift', 'Comma'])
+      await I.pressKey(['Shift', 'NumpadComma'])
+      await I.pressKey(['Shift', 'Separator'])
+      await I.pressKey('-')
+      await I.pressKey(['Shift', '-'])
+      await I.pressKey(['Shift', 'Subtract'])
+      await I.pressKey('.')
+      await I.pressKey(['Shift', '.'])
+      await I.pressKey('/')
+      await I.pressKey(['Shift', '/'])
+      await I.pressKey(['Shift', 'Divide'])
+      await I.pressKey(['Shift', 'Slash'])
+
+      await I.seeInField('Name', ';::=++***+++,<<<<-_-.>/?/?')
+    })
+  })
 
   describe('#waitForEnabled', () => {
-    it('should wait for input text field to be enabled', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled('#text', 2))
-      .then(() => I.fillField('#text', 'hello world'))
-      .then(() => I.seeInField('#text', 'hello world')));
-
-    it('should wait for input text field to be enabled by xpath', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled("//*[@name = 'test']", 2))
-      .then(() => I.fillField('#text', 'hello world'))
-      .then(() => I.seeInField('#text', 'hello world')));
-
-    it('should wait for a button to be enabled', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled('#text', 2))
-      .then(() => I.click('#button'))
-      .then(() => I.see('button was clicked', '#message')));
-  });
+    it('should wait for input text field to be enabled', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled('#text', 2))
+        .then(() => I.fillField('#text', 'hello world'))
+        .then(() => I.seeInField('#text', 'hello world')))
+
+    it('should wait for input text field to be enabled by xpath', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled("//*[@name = 'test']", 2))
+        .then(() => I.fillField('#text', 'hello world'))
+        .then(() => I.seeInField('#text', 'hello world')))
+
+    it('should wait for a button to be enabled', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled('#text', 2))
+        .then(() => I.click('#button'))
+        .then(() => I.see('button was clicked', '#message')))
+  })
+
+  describe('#waitForDisabled', () => {
+    it('should wait for input text field to be disabled', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled('#text', 1)))
+
+    it('should wait for input text field to be enabled by xpath', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled("//*[@name = 'test']", 1)))
+
+    it('should wait for a button to be disabled', () =>
+      I.amOnPage('/form/wait_disabled').then(() => I.waitForDisabled('#text', 1)))
+  })
 
   describe('#waitForValue', () => {
-    it('should wait for expected value for given locator', () => I.amOnPage('/info')
-      .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно'))
-      .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1))
-      .then(() => {
-        throw Error('It should never get this far');
-      })
-      .catch((e) => {
-        e.message.should.include('element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec');
-      }));
-
-    it('should wait for expected value for given css locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.seeInField('#text', 'Hamburg'))
-      .then(() => I.waitForValue('#text', 'Brisbane', 2.5))
-      .then(() => I.seeInField('#text', 'Brisbane')));
-
-    it('should wait for expected value for given xpath locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.seeInField('#text', 'Hamburg'))
-      .then(() => I.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5))
-      .then(() => I.seeInField('#text', 'Brisbane')));
-
-    it('should only wait for one of the matching elements to contain the value given xpath locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.waitForValue('//input[@type = "text"]', 'Brisbane', 4))
-      .then(() => I.seeInField('#text', 'Brisbane'))
-      .then(() => I.seeInField('#text2', 'London')));
-
-    it('should only wait for one of the matching elements to contain the value given css locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.waitForValue('.inputbox', 'Brisbane', 4))
-      .then(() => I.seeInField('#text', 'Brisbane'))
-      .then(() => I.seeInField('#text2', 'London')));
-  });
+    it('should wait for expected value for given locator', () =>
+      I.amOnPage('/info')
+        .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно'))
+        .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1))
+        .then(() => {
+          throw Error('It should never get this far')
+        })
+        .catch((e) => {
+          e.message.should.include(
+            'element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec',
+          )
+        }))
+
+    it('should wait for expected value for given css locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.seeInField('#text', 'Hamburg'))
+        .then(() => I.waitForValue('#text', 'Brisbane', 2.5))
+        .then(() => I.seeInField('#text', 'Brisbane')))
+
+    it('should wait for expected value for given xpath locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.seeInField('#text', 'Hamburg'))
+        .then(() => I.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5))
+        .then(() => I.seeInField('#text', 'Brisbane')))
+
+    it('should only wait for one of the matching elements to contain the value given xpath locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.waitForValue('//input[@type = "text"]', 'Brisbane', 4))
+        .then(() => I.seeInField('#text', 'Brisbane'))
+        .then(() => I.seeInField('#text2', 'London')))
+
+    it('should only wait for one of the matching elements to contain the value given css locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.waitForValue('.inputbox', 'Brisbane', 4))
+        .then(() => I.seeInField('#text', 'Brisbane'))
+        .then(() => I.seeInField('#text2', 'London')))
+  })
 
   describe('#grabHTMLFrom', () => {
-    it('should grab inner html from an element using xpath query', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFrom('//title'))
-      .then(html => assert.equal(html, 'TestEd Beta 2.0')));
-
-    it('should grab inner html from an element using id query', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFrom('#area1'))
-      .then(html => assert.equal(html.trim(), '<a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>')));
-
-    it('should grab inner html from multiple elements', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFromAll('//a'))
-      .then(html => assert.equal(html.length, 5)));
-
-    it('should grab inner html from within an iframe', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo({ frame: 'iframe' }))
-      .then(() => I.grabHTMLFrom('#new-tab'))
-      .then(html => assert.equal(html.trim(), '<a href="/login" target="_blank">New tab</a>')));
-  });
+    it('should grab inner html from an element using xpath query', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFrom('//title'))
+        .then((html) => assert.equal(html, 'TestEd Beta 2.0')))
+
+    it('should grab inner html from an element using id query', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFrom('#area1'))
+        .then((html) => assert.equal(html.trim(), '<a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>')))
+
+    it('should grab inner html from multiple elements', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFromAll('//a'))
+        .then((html) => assert.equal(html.length, 5)))
+
+    it('should grab inner html from within an iframe', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo({ frame: 'iframe' }))
+        .then(() => I.grabHTMLFrom('#new-tab'))
+        .then((html) => assert.equal(html.trim(), '<a href="/login" target="_blank">New tab</a>')))
+  })
 
   describe('#grabBrowserLogs', () => {
-    it('should grab browser logs', () => I.amOnPage('/')
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().indexOf('Test log entry') > -1);
-        assert.equal(matchingLogs.length, 1);
-      }));
-
-    it('should grab browser logs in new tab', () => I.amOnPage('/')
-      .then(() => I.openNewTab())
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().indexOf('Test log entry') > -1);
-        assert.equal(matchingLogs.length, 1);
-      }));
-
-    it('should grab browser logs in two tabs', () => I.amOnPage('/')
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry 1');
-      }))
-      .then(() => I.openNewTab())
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry 2');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().includes('Test log entry'));
-        assert.equal(matchingLogs.length, 2);
-      }));
-
-    it('should grab browser logs in next tab', () => I.amOnPage('/info')
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().indexOf('Test log entry') > -1);
-        assert.equal(matchingLogs.length, 1);
-      }));
-  });
+    it('should grab browser logs', () =>
+      I.amOnPage('/')
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().indexOf('Test log entry') > -1)
+          assert.equal(matchingLogs.length, 1)
+        }))
+
+    it('should grab browser logs in new tab', () =>
+      I.amOnPage('/')
+        .then(() => I.openNewTab())
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().indexOf('Test log entry') > -1)
+          assert.equal(matchingLogs.length, 1)
+        }))
+
+    it('should grab browser logs in two tabs', () =>
+      I.amOnPage('/')
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry 1')
+          }),
+        )
+        .then(() => I.openNewTab())
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry 2')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().includes('Test log entry'))
+          assert.equal(matchingLogs.length, 2)
+        }))
+
+    it('should grab browser logs in next tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().indexOf('Test log entry') > -1)
+          assert.equal(matchingLogs.length, 1)
+        }))
+  })
 
   describe('#dragAndDrop', () => {
-    it('Drag item from source to target (no iframe) @dragNdrop - customized steps', () => I.amOnPage('https://jqueryui.com/resources/demos/droppable/default.html')
-      .then(() => I.seeElementInDOM('#draggable'))
-      .then(() => I.dragAndDrop('#draggable', '#droppable'))
-      .then(() => I.see('Dropped')));
-
-    it('Drag item from source to target (no iframe) @dragNdrop - using Playwright API', () => I.amOnPage('https://jqueryui.com/resources/demos/droppable/default.html')
-      .then(() => I.seeElementInDOM('#draggable'))
-      .then(() => I.dragAndDrop('#draggable', '#droppable', { force: true }))
-      .then(() => I.see('Dropped')));
-
-    xit('Drag and drop from within an iframe', () => I.amOnPage('https://jqueryui.com/droppable')
-      .then(() => I.resizeWindow(700, 700))
-      .then(() => I.switchTo('//iframe[@class="demo-frame"]'))
-      .then(() => I.seeElementInDOM('#draggable'))
-      .then(() => I.dragAndDrop('#draggable', '#droppable'))
-      .then(() => I.see('Dropped')));
-  });
+    it('Drag item from source to target (no iframe) @dragNdrop - customized steps', () =>
+      I.amOnPage('https://jqueryui.com/resources/demos/droppable/default.html')
+        .then(() => I.seeElementInDOM('#draggable'))
+        .then(() => I.dragAndDrop('#draggable', '#droppable'))
+        .then(() => I.see('Dropped')))
+
+    it('Drag item from source to target (no iframe) @dragNdrop - using Playwright API', () =>
+      I.amOnPage('https://jqueryui.com/resources/demos/droppable/default.html')
+        .then(() => I.seeElementInDOM('#draggable'))
+        .then(() => I.dragAndDrop('#draggable', '#droppable', { force: true }))
+        .then(() => I.see('Dropped')))
+
+    xit('Drag and drop from within an iframe', () =>
+      I.amOnPage('https://jqueryui.com/droppable')
+        .then(() => I.resizeWindow(700, 700))
+        .then(() => I.switchTo('//iframe[@class="demo-frame"]'))
+        .then(() => I.seeElementInDOM('#draggable'))
+        .then(() => I.dragAndDrop('#draggable', '#droppable'))
+        .then(() => I.see('Dropped')))
+  })
 
   describe('#switchTo frame', () => {
-    it('should switch to frame using name', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo('iframe'))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1')));
-
-    it('should switch to root frame', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo('iframe'))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1'))
-      .then(() => I.switchTo())
-      .then(() => I.see('Iframe test', 'h1')));
-
-    it('should switch to frame using frame number', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo(0))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1')));
-  });
+    it('should switch to frame using name', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo('iframe'))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1')))
+
+    it('should switch to root frame', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo('iframe'))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1'))
+        .then(() => I.switchTo())
+        .then(() => I.see('Iframe test', 'h1')))
+
+    it('should switch to frame using frame number', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo(0))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1')))
+  })
 
   describe('#dragSlider', () => {
     it('should drag scrubber to given position', async () => {
-      await I.amOnPage('/form/page_slider');
-      await I.seeElementInDOM('#slidecontainer input');
-      const before = await I.grabValueFrom('#slidecontainer input');
-      await I.dragSlider('#slidecontainer input', 20);
-      const after = await I.grabValueFrom('#slidecontainer input');
-      assert.notEqual(before, after);
-    });
-  });
+      await I.amOnPage('/form/page_slider')
+      await I.seeElementInDOM('#slidecontainer input')
+      const before = await I.grabValueFrom('#slidecontainer input')
+      await I.dragSlider('#slidecontainer input', 20)
+      const after = await I.grabValueFrom('#slidecontainer input')
+      assert.notEqual(before, after)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await I.amOnPage('/info');
-      await I.uncheckOption('interesting');
-      await I.dontSeeCheckboxIsChecked('interesting');
-    });
+      await I.amOnPage('/info')
+      await I.uncheckOption('interesting')
+      await I.dontSeeCheckboxIsChecked('interesting')
+    })
 
     it('should NOT uncheck option that is NOT currently checked', async () => {
-      await I.amOnPage('/info');
-      await I.uncheckOption('interesting');
+      await I.amOnPage('/info')
+      await I.uncheckOption('interesting')
       // Unchecking again should not affect the current 'unchecked' status
-      await I.uncheckOption('interesting');
-      await I.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await I.uncheckOption('interesting')
+      await I.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('#usePlaywrightTo', () => {
     it('should return title', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       const title = await I.usePlaywrightTo('test', async ({ page }) => {
-        return page.title();
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
+        return page.title()
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
 
     it('should pass expected parameters', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       const params = await I.usePlaywrightTo('test', async (params) => {
-        return params;
-      });
-      expect(params.page).to.exist;
-      expect(params.browserContext).to.exist;
-      expect(params.browser).to.exist;
-    });
-  });
+        return params
+      })
+      expect(params.page).to.exist
+      expect(params.browserContext).to.exist
+      expect(params.browser).to.exist
+    })
+  })
 
   describe('#mockRoute, #stopMockingRoute', () => {
     it('should mock a route', async () => {
-      await I.amOnPage('/form/fetch_call');
-      await I.mockRoute('https://reqres.in/api/comments/1', route => {
+      await I.amOnPage('/form/fetch_call')
+      await I.mockRoute('https://reqres.in/api/comments/1', (route) => {
         route.fulfill({
           status: 200,
           headers: { 'Access-Control-Allow-Origin': '*' },
           contentType: 'application/json',
           body: '{"name": "this was mocked" }',
-        });
-      });
-      await I.click('GET COMMENTS');
-      await I.see('this was mocked');
-      await I.stopMockingRoute('https://reqres.in/api/comments/1');
-      await I.click('GET COMMENTS');
-      await I.see('data');
-      await I.dontSee('this was mocked');
-    });
-  });
+        })
+      })
+      await I.click('GET COMMENTS')
+      await I.see('this was mocked')
+      await I.stopMockingRoute('https://reqres.in/api/comments/1')
+      await I.click('GET COMMENTS')
+      await I.see('data')
+      await I.dontSee('this was mocked')
+    })
+  })
 
   describe('#makeApiRequest', () => {
     it('should make 3rd party API request', async () => {
-      const response = await I.makeApiRequest('get', 'https://reqres.in/api/users?page=2');
-      expect(response.status()).to.equal(200);
-      expect(await response.json()).to.include.keys(['page']);
-    });
+      const response = await I.makeApiRequest('get', 'https://reqres.in/api/users?page=2')
+      expect(response.status()).to.equal(200)
+      expect(await response.json()).to.include.keys(['page'])
+    })
 
     it('should make local API request', async () => {
-      const response = await I.makeApiRequest('get', '/form/fetch_call');
-      expect(response.status()).to.equal(200);
-    });
+      const response = await I.makeApiRequest('get', '/form/fetch_call')
+      expect(response.status()).to.equal(200)
+    })
 
     it('should convert to axios response with onResponse hook', async () => {
-      let response;
-      I.config.onResponse = (resp) => response = resp;
-      await I.makeApiRequest('get', 'https://reqres.in/api/users?page=2');
-      expect(response).to.be.ok;
-      expect(response.status).to.equal(200);
-      expect(response.data).to.include.keys(['page', 'total']);
-    });
-  });
+      let response
+      I.config.onResponse = (resp) => (response = resp)
+      await I.makeApiRequest('get', 'https://reqres.in/api/users?page=2')
+      expect(response).to.be.ok
+      expect(response.status).to.equal(200)
+      expect(response.data).to.include.keys(['page', 'total'])
+    })
+  })
 
   describe('#grabElementBoundingRect', () => {
     it('should get the element bounding rectangle', async () => {
-      await I.amOnPage('/image');
-      const size = await I.grabElementBoundingRect('#logo');
-      expect(size.x).is.greaterThan(39); // 40 or more
-      expect(size.y).is.greaterThan(39);
-      expect(size.width).is.greaterThan(0);
-      expect(size.height).is.greaterThan(0);
-      expect(size.width).to.eql(100);
-      expect(size.height).to.eql(100);
-    });
+      await I.amOnPage('/image')
+      const size = await I.grabElementBoundingRect('#logo')
+      expect(size.x).is.greaterThan(39) // 40 or more
+      expect(size.y).is.greaterThan(39)
+      expect(size.width).is.greaterThan(0)
+      expect(size.height).is.greaterThan(0)
+      expect(size.width).to.eql(100)
+      expect(size.height).to.eql(100)
+    })
 
     it('should get the element width', async () => {
-      await I.amOnPage('/image');
-      const width = await I.grabElementBoundingRect('#logo', 'width');
-      expect(width).is.greaterThan(0);
-      expect(width).to.eql(100);
-    });
+      await I.amOnPage('/image')
+      const width = await I.grabElementBoundingRect('#logo', 'width')
+      expect(width).is.greaterThan(0)
+      expect(width).to.eql(100)
+    })
 
     it('should get the element height', async () => {
-      await I.amOnPage('/image');
-      const height = await I.grabElementBoundingRect('#logo', 'height');
-      expect(height).is.greaterThan(0);
-      expect(height).to.eql(100);
-    });
-  });
+      await I.amOnPage('/image')
+      const height = await I.grabElementBoundingRect('#logo', 'height')
+      expect(height).is.greaterThan(0)
+      expect(height).to.eql(100)
+    })
+  })
 
   describe('#handleDownloads - with passed folder', () => {
     before(() => {
       // create download folder;
-      global.output_dir = path.join(`${__dirname}/../data/output`);
+      global.output_dir = path.join(`${__dirname}/../data/output`)
 
-      FS = new FileSystem();
-      FS._before();
-      FS.amInPath('output/downloadHere');
-    });
+      FS = new FileSystem()
+      FS._before()
+      FS.amInPath('output/downloadHere')
+    })
 
     it('should download file', async () => {
-      await I.amOnPage('/form/download');
-      await I.handleDownloads('downloadHere/avatar.jpg');
-      await I.click('Download file');
-      await FS.waitForFile('avatar.jpg', 5);
-    });
-  });
+      await I.amOnPage('/form/download')
+      await I.handleDownloads('downloadHere/avatar.jpg')
+      await I.click('Download file')
+      await FS.waitForFile('avatar.jpg', 5)
+    })
+  })
 
   describe('#handleDownloads - with default folder', () => {
     before(() => {
       // create download folder;
-      global.output_dir = path.join(`${__dirname}/../data/output`);
+      global.output_dir = path.join(`${__dirname}/../data/output`)
 
-      FS = new FileSystem();
-      FS._before();
-      FS.amInPath('output');
-    });
+      FS = new FileSystem()
+      FS._before()
+      FS.amInPath('output')
+    })
 
     it('should download file', async () => {
-      await I.amOnPage('/form/download');
-      await I.handleDownloads('avatar.jpg');
-      await I.click('Download file');
-      await FS.waitForFile('avatar.jpg', 5);
-    });
-  });
+      await I.amOnPage('/form/download')
+      await I.handleDownloads('avatar.jpg')
+      await I.click('Download file')
+      await FS.waitForFile('avatar.jpg', 5)
+    })
+  })
 
   describe('#waitForURL', () => {
     it('should wait for URL', () => {
-      I.amOnPage('/');
-      I.click('More info');
-      I.waitForURL('/info');
-      I.see('Information');
-    });
+      I.amOnPage('/')
+      I.click('More info')
+      I.waitForURL('/info')
+      I.see('Information')
+    })
 
     it('should wait for regex URL', () => {
-      I.amOnPage('/');
-      I.click('More info');
-      I.waitForURL(/info/);
-      I.see('Information');
-    });
-  });
-});
-
-let remoteBrowser;
+      I.amOnPage('/')
+      I.click('More info')
+      I.waitForURL(/info/)
+      I.see('Information')
+    })
+  })
+})
+
+let remoteBrowser
 async function createRemoteBrowser() {
   if (remoteBrowser) {
-    await remoteBrowser.close();
+    await remoteBrowser.close()
   }
   remoteBrowser = await playwright.chromium.launchServer({
     webSocket: true,
     // args: ['--no-sandbox', '--disable-setuid-sandbox'],
     headless: true,
-  });
+  })
   remoteBrowser.on('disconnected', () => {
-    remoteBrowser = null;
-  });
-  return remoteBrowser;
+    remoteBrowser = null
+  })
+  return remoteBrowser
 }
 
 describe('Playwright (remote browser) websocket', function () {
-  this.timeout(35000);
-  this.retries(1);
+  this.timeout(35000)
+  this.retries(1)
 
   const helperConfig = {
     chromium: {
@@ -1039,86 +1120,86 @@ describe('Playwright (remote browser) websocket', function () {
     waitForTimeout: 5000,
     waitForAction: 500,
     windowSize: '500x700',
-  };
+  }
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    I = new Playwright(helperConfig);
-    I._init();
-  });
+    global.codecept_dir = path.join(__dirname, '/../data')
+    I = new Playwright(helperConfig)
+    I._init()
+  })
 
   beforeEach(async () => {
     // Mimick remote session by creating another browser instance
-    const remoteBrowser = await createRemoteBrowser();
+    const remoteBrowser = await createRemoteBrowser()
     // I.isRunning = false;
     // Set websocket endpoint to other browser instance
-  });
+  })
 
   afterEach(async () => {
-    await I._after();
-    return remoteBrowser && remoteBrowser.close();
-  });
+    await I._after()
+    return remoteBrowser && remoteBrowser.close()
+  })
 
   describe('#_startBrowser', () => {
     it('should throw an exception when endpoint is unreachable', async () => {
-      I._setConfig({ ...helperConfig, chromium: { browserWSEndpoint: 'ws://unreachable/' } });
+      I._setConfig({ ...helperConfig, chromium: { browserWSEndpoint: 'ws://unreachable/' } })
       try {
-        await I._startBrowser();
-        throw Error('It should never get this far');
+        await I._startBrowser()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot connect to websocket');
+        e.message.should.include('Cannot connect to websocket')
       }
-    });
+    })
 
     it('should connect to legacy API endpoint', async () => {
-      const wsEndpoint = await remoteBrowser.wsEndpoint();
-      I._setConfig({ ...helperConfig, chromium: { browserWSEndpoint: { wsEndpoint } } });
-      await I._before();
-      await I.amOnPage('/');
-      await I.see('Welcome to test app');
-    });
+      const wsEndpoint = await remoteBrowser.wsEndpoint()
+      I._setConfig({ ...helperConfig, chromium: { browserWSEndpoint: { wsEndpoint } } })
+      await I._before()
+      await I.amOnPage('/')
+      await I.see('Welcome to test app')
+    })
 
     it('should connect to remote browsers', async () => {
-      helperConfig.chromium.browserWSEndpoint = await remoteBrowser.wsEndpoint();
-      I._setConfig(helperConfig);
+      helperConfig.chromium.browserWSEndpoint = await remoteBrowser.wsEndpoint()
+      I._setConfig(helperConfig)
 
-      await I._before();
-      await I.amOnPage('/');
-      await I.see('Welcome to test app');
-    });
+      await I._before()
+      await I.amOnPage('/')
+      await I.see('Welcome to test app')
+    })
 
     it('should manage pages in remote browser', async () => {
-      helperConfig.chromium.browserWSEndpoint = await remoteBrowser.wsEndpoint();
-      I._setConfig(helperConfig);
+      helperConfig.chromium.browserWSEndpoint = await remoteBrowser.wsEndpoint()
+      I._setConfig(helperConfig)
 
-      await I._before();
-      assert.ok(I.isRemoteBrowser);
-      const context = await I.browserContext;
+      await I._before()
+      assert.ok(I.isRemoteBrowser)
+      const context = await I.browserContext
       // Session was cleared
-      let currentPages = await context.pages();
-      assert.equal(currentPages.length, 1);
+      let currentPages = await context.pages()
+      assert.equal(currentPages.length, 1)
 
-      let numPages = await I.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
+      let numPages = await I.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
 
-      await I.openNewTab();
+      await I.openNewTab()
 
-      numPages = await I.grabNumberOfOpenTabs();
-      assert.equal(numPages, 2);
+      numPages = await I.grabNumberOfOpenTabs()
+      assert.equal(numPages, 2)
 
-      await I._stopBrowser();
+      await I._stopBrowser()
 
-      currentPages = await context.pages();
-      assert.equal(currentPages.length, 0);
-    });
-  });
-});
+      currentPages = await context.pages()
+      assert.equal(currentPages.length, 0)
+    })
+  })
+})
 
 describe('Playwright - BasicAuth', function () {
-  this.timeout(35000);
+  this.timeout(35000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Playwright({
       url: 'http://localhost:8000',
@@ -1133,36 +1214,37 @@ describe('Playwright - BasicAuth', function () {
       },
       defaultPopupAction: 'accept',
       basicAuth: { username: 'admin', password: 'admin' },
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(() => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-    });
-  });
+      page = I.page
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('open page with provided basic auth', () => {
     it('should be authenticated ', async () => {
-      await I.amOnPage('/basic_auth');
-      await I.see('You entered admin as your password.');
-    });
-  });
-});
+      await I.amOnPage('/basic_auth')
+      await I.see('You entered admin as your password.')
+    })
+  })
+})
 
 describe('Playwright - Emulation', () => {
   before(() => {
-    const { devices } = require('playwright');
-    global.codecept_dir = path.join(__dirname, '/../data');
+    const { devices } = require('playwright')
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Playwright({
       url: 'http://localhost:8000',
@@ -1176,32 +1258,32 @@ describe('Playwright - Emulation', () => {
       chrome: {
         args: ['--no-sandbox', '--disable-setuid-sandbox'],
       },
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(() => {
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('should open page as iPhone ', async () => {
-    await I.amOnPage('/');
-    const width = await I.executeScript('window.innerWidth');
-    assert.equal(width, 980);
-  });
-});
+    await I.amOnPage('/')
+    const width = await I.executeScript('window.innerWidth')
+    assert.equal(width, 980)
+  })
+})
 
 describe('Playwright - PERSISTENT', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Playwright({
       url: 'http://localhost:8000',
@@ -1215,30 +1297,30 @@ describe('Playwright - PERSISTENT', () => {
         args: ['--no-sandbox', '--disable-setuid-sandbox'],
         userDataDir: '/tmp/playwright-tmp',
       },
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(() => {
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('should launch a persistent context', async () => {
-    assert.equal(I._getType(), 'BrowserContext');
-  });
-});
+    assert.equal(I._getType(), 'BrowserContext')
+  })
+})
 
 describe('Playwright - Electron', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Playwright({
       waitForTimeout: 5000,
@@ -1249,71 +1331,71 @@ describe('Playwright - Electron', () => {
         executablePath: require('electron'),
         args: [path.join(codecept_dir, '/electron/')],
       },
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   describe('#amOnPage', () => {
     it('should throw an error', async () => {
       try {
-        await I.amOnPage('/');
-        throw Error('It should never get this far');
+        await I.amOnPage('/')
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot open pages inside an Electron container');
+        e.message.should.include('Cannot open pages inside an Electron container')
       }
-    });
-  });
+    })
+  })
 
   describe('#openNewTab', () => {
     it('should throw an error', async () => {
       try {
-        await I.openNewTab();
-        throw Error('It should never get this far');
+        await I.openNewTab()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot open new tabs inside an Electron container');
+        e.message.should.include('Cannot open new tabs inside an Electron container')
       }
-    });
-  });
+    })
+  })
 
   describe('#switchToNextTab', () => {
     it('should throw an error', async () => {
       try {
-        await I.switchToNextTab();
-        throw Error('It should never get this far');
+        await I.switchToNextTab()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot switch tabs inside an Electron container');
+        e.message.should.include('Cannot switch tabs inside an Electron container')
       }
-    });
-  });
+    })
+  })
 
   describe('#switchToPreviousTab', () => {
     it('should throw an error', async () => {
       try {
-        await I.switchToNextTab();
-        throw Error('It should never get this far');
+        await I.switchToNextTab()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot switch tabs inside an Electron container');
+        e.message.should.include('Cannot switch tabs inside an Electron container')
       }
-    });
-  });
+    })
+  })
 
   describe('#closeCurrentTab', () => {
     it('should throw an error', async () => {
       try {
-        await I.closeCurrentTab();
-        throw Error('It should never get this far');
+        await I.closeCurrentTab()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot close current tab inside an Electron container');
+        e.message.should.include('Cannot close current tab inside an Electron container')
       }
-    });
-  });
-});
+    })
+  })
+})
 
 describe('Playwright - Performance Metrics', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    global.output_dir = path.join(`${__dirname}/../data/output`);
+    global.codecept_dir = path.join(__dirname, '/../data')
+    global.output_dir = path.join(`${__dirname}/../data/output`)
 
     I = new Playwright({
       url: siteUrl,
@@ -1321,39 +1403,40 @@ describe('Playwright - Performance Metrics', () => {
       show: false,
       restart: true,
       browser: 'chromium',
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('grabs performance metrics', async () => {
-    await I.amOnPage('https://codecept.io');
-    const metrics = await I.grabMetrics();
-    expect(metrics.length).to.greaterThan(0);
-    expect(metrics[0].name).to.equal('Timestamp');
-  });
-});
+    await I.amOnPage('https://codecept.io')
+    const metrics = await I.grabMetrics()
+    expect(metrics.length).to.greaterThan(0)
+    expect(metrics[0].name).to.equal('Timestamp')
+  })
+})
 
 describe('Playwright - Video & Trace & HAR', () => {
-  const test = { title: 'a failed test', artifacts: {} };
+  const test = { title: 'a failed test', artifacts: {} }
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    global.output_dir = path.join(`${__dirname}/../data/output`);
+    global.codecept_dir = path.join(__dirname, '/../data')
+    global.output_dir = path.join(`${__dirname}/../data/output`)
 
     I = new Playwright({
       url: siteUrl,
@@ -1370,48 +1453,49 @@ describe('Playwright - Video & Trace & HAR', () => {
         },
       },
       recordHar: {},
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     webApiTests.init({
-      I, siteUrl,
-    });
-    deleteDir(path.join(global.output_dir, 'video'));
-    deleteDir(path.join(global.output_dir, 'trace'));
-    deleteDir(path.join(global.output_dir, 'har'));
+      I,
+      siteUrl,
+    })
+    deleteDir(path.join(global.output_dir, 'video'))
+    deleteDir(path.join(global.output_dir, 'trace'))
+    deleteDir(path.join(global.output_dir, 'har'))
     return I._before(test).then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('checks that video is recorded', async () => {
-    await I.amOnPage('/');
-    await I.dontSee('this should be an error');
-    await I.click('More info');
-    await I.dontSee('this should be an error');
-    await I._failed(test);
-    assert(test.artifacts);
-    expect(Object.keys(test.artifacts)).to.include('trace');
-    expect(Object.keys(test.artifacts)).to.include('video');
-    expect(Object.keys(test.artifacts)).to.include('har');
-
-    assert.ok(fs.existsSync(test.artifacts.trace));
-    expect(test.artifacts.video).to.include(path.join(global.output_dir, 'video'));
-    expect(test.artifacts.trace).to.include(path.join(global.output_dir, 'trace'));
-    expect(test.artifacts.har).to.include(path.join(global.output_dir, 'har'));
-  });
-});
+    await I.amOnPage('/')
+    await I.dontSee('this should be an error')
+    await I.click('More info')
+    await I.dontSee('this should be an error')
+    await I._failed(test)
+    assert(test.artifacts)
+    expect(Object.keys(test.artifacts)).to.include('trace')
+    expect(Object.keys(test.artifacts)).to.include('video')
+    expect(Object.keys(test.artifacts)).to.include('har')
+
+    assert.ok(fs.existsSync(test.artifacts.trace))
+    expect(test.artifacts.video).to.include(path.join(global.output_dir, 'video'))
+    expect(test.artifacts.trace).to.include(path.join(global.output_dir, 'trace'))
+    expect(test.artifacts.har).to.include(path.join(global.output_dir, 'har'))
+  })
+})
 describe('Playwright - HAR', () => {
   before(() => {
-    global.codecept_dir = path.join(process.cwd());
+    global.codecept_dir = path.join(process.cwd())
 
     I = new Playwright({
       url: siteUrl,
@@ -1419,63 +1503,64 @@ describe('Playwright - HAR', () => {
       show: false,
       restart: true,
       browser: 'chromium',
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('replay from HAR - non existing file', async () => {
     try {
-      await I.replayFromHar('./non-existing-file.har');
-      await I.amOnPage('https://demo.playwright.dev/api-mocking');
+      await I.replayFromHar('./non-existing-file.har')
+      await I.amOnPage('https://demo.playwright.dev/api-mocking')
     } catch (e) {
-      expect(e.message).to.include('cannot be found on local system');
+      expect(e.message).to.include('cannot be found on local system')
     }
-  });
+  })
 
   it('replay from HAR', async () => {
-    const harFile = './test/data/sandbox/testHar.har';
-    await I.replayFromHar(harFile);
-    await I.amOnPage('https://demo.playwright.dev/api-mocking');
-    await I.see('CodeceptJS');
-  });
+    const harFile = './test/data/sandbox/testHar.har'
+    await I.replayFromHar(harFile)
+    await I.amOnPage('https://demo.playwright.dev/api-mocking')
+    await I.see('CodeceptJS')
+  })
 
   describe('#grabWebElements, #grabWebElement', () => {
     it('should return an array of WebElement', async () => {
-      await I.amOnPage('/form/focus_blur_elements');
+      await I.amOnPage('/form/focus_blur_elements')
 
-      const webElements = await I.grabWebElements('#button');
-      assert.equal(webElements[0], 'locator(\'#button\').first()');
-      assert.isAbove(webElements.length, 0);
-    });
+      const webElements = await I.grabWebElements('#button')
+      assert.equal(webElements[0], "locator('#button').first()")
+      assert.isAbove(webElements.length, 0)
+    })
 
     it('should return a WebElement', async () => {
-      await I.amOnPage('/form/focus_blur_elements');
+      await I.amOnPage('/form/focus_blur_elements')
 
-      const webElement = await I.grabWebElement('#button');
-      assert.equal(webElement, 'locator(\'#button\').first()');
-    });
-  });
-});
+      const webElement = await I.grabWebElement('#button')
+      assert.equal(webElement, "locator('#button').first()")
+    })
+  })
+})
 
 describe('using data-testid attribute', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    global.output_dir = path.join(`${__dirname}/../data/output`);
+    global.codecept_dir = path.join(__dirname, '/../data')
+    global.output_dir = path.join(`${__dirname}/../data/output`)
 
     I = new Playwright({
       url: siteUrl,
@@ -1483,35 +1568,35 @@ describe('using data-testid attribute', () => {
       show: false,
       restart: true,
       browser: 'chromium',
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('should find element by pw locator', async () => {
-    await I.amOnPage('/');
+    await I.amOnPage('/')
 
-    const webElements = await I.grabWebElements({ pw: '[data-testid="welcome"]' });
-    assert.equal(webElements[0]._selector, '[data-testid="welcome"] >> nth=0');
-    assert.equal(webElements.length, 1);
-  });
+    const webElements = await I.grabWebElements({ pw: '[data-testid="welcome"]' })
+    assert.equal(webElements[0]._selector, '[data-testid="welcome"] >> nth=0')
+    assert.equal(webElements.length, 1)
+  })
 
   it('should find element by h1[data-testid="welcome"]', async () => {
-    await I.amOnPage('/');
+    await I.amOnPage('/')
 
-    const webElements = await I.grabWebElements('h1[data-testid="welcome"]');
-    assert.equal(webElements[0]._selector, 'h1[data-testid="welcome"] >> nth=0');
-    assert.equal(webElements.length, 1);
-  });
-});
+    const webElements = await I.grabWebElements('h1[data-testid="welcome"]')
+    assert.equal(webElements[0]._selector, 'h1[data-testid="welcome"] >> nth=0')
+    assert.equal(webElements.length, 1)
+  })
+})
diff --git a/test/helper/Puppeteer_test.js b/test/helper/Puppeteer_test.js
index a22187e7f..9d3ff1aca 100644
--- a/test/helper/Puppeteer_test.js
+++ b/test/helper/Puppeteer_test.js
@@ -1,34 +1,34 @@
-let expect;
-let assert;
-import('chai').then(chai => {
-  expect = chai.expect;
-  assert = chai.assert;
-});
-const path = require('path');
-
-const puppeteer = require('puppeteer');
-
-const fs = require('fs');
-const TestHelper = require('../support/TestHelper');
-const Puppeteer = require('../../lib/helper/Puppeteer');
-
-const AssertionFailedError = require('../../lib/assert/error');
-const webApiTests = require('./webapi');
-const Secret = require('../../lib/secret');
-const { deleteDir } = require('../../lib/utils');
-global.codeceptjs = require('../../lib');
-
-let I;
-let browser;
-let page;
-let FS;
-const siteUrl = TestHelper.siteUrl();
+let expect
+let assert
+import('chai').then((chai) => {
+  expect = chai.expect
+  assert = chai.assert
+})
+const path = require('path')
+
+const puppeteer = require('puppeteer')
+
+const fs = require('fs')
+const TestHelper = require('../support/TestHelper')
+const Puppeteer = require('../../lib/helper/Puppeteer')
+
+const AssertionFailedError = require('../../lib/assert/error')
+const webApiTests = require('./webapi')
+const Secret = require('../../lib/secret')
+const { deleteDir } = require('../../lib/utils')
+global.codeceptjs = require('../../lib')
+
+let I
+let browser
+let page
+let FS
+const siteUrl = TestHelper.siteUrl()
 
 describe('Puppeteer - BasicAuth', function () {
-  this.timeout(10000);
+  this.timeout(10000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Puppeteer({
       url: siteUrl,
@@ -41,43 +41,44 @@ describe('Puppeteer - BasicAuth', function () {
       },
       defaultPopupAction: 'accept',
       basicAuth: { username: 'admin', password: 'admin' },
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(() => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('open page with provided basic auth', () => {
     it('should be authenticated ', async () => {
-      await I.amOnPage('/basic_auth');
-      await I.see('You entered admin as your password.');
-    });
+      await I.amOnPage('/basic_auth')
+      await I.see('You entered admin as your password.')
+    })
     it('should be authenticated on second run', async () => {
-      await I.amOnPage('/basic_auth');
-      await I.see('You entered admin as your password.');
-    });
-  });
-});
+      await I.amOnPage('/basic_auth')
+      await I.see('You entered admin as your password.')
+    })
+  })
+})
 
 describe('Puppeteer', function () {
-  this.timeout(35000);
-  this.retries(1);
+  this.timeout(35000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
 
     I = new Puppeteer({
       url: siteUrl,
@@ -89,90 +90,92 @@ describe('Puppeteer', function () {
         args: ['--no-sandbox', '--disable-setuid-sandbox'],
       },
       defaultPopupAction: 'accept',
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(() => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('Session', () => {
     it('should not fail for localStorage.clear() on about:blank', async () => {
-      I.options.restart = false;
-      return I.page.goto('about:blank')
+      I.options.restart = false
+      return I.page
+        .goto('about:blank')
         .then(() => I._after())
-        .then(() => { I.options.restart = true; })
+        .then(() => {
+          I.options.restart = true
+        })
         .catch((e) => {
-          I.options.restart = true;
-          throw new Error(e);
-        });
-    });
-  });
+          I.options.restart = true
+          throw new Error(e)
+        })
+    })
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await I.amOnPage('/');
-      const url = await page.url();
-      await url.should.eql(`${siteUrl}/`);
-    });
+      await I.amOnPage('/')
+      const url = await page.url()
+      await url.should.eql(`${siteUrl}/`)
+    })
     it('should open any page of configured site', async () => {
-      await I.amOnPage('/info');
-      const url = await page.url();
-      return url.should.eql(`${siteUrl}/info`);
-    });
+      await I.amOnPage('/info')
+      const url = await page.url()
+      return url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await I.amOnPage(siteUrl);
-      const url = await page.url();
-      return url.should.eql(`${siteUrl}/`);
-    });
+      await I.amOnPage(siteUrl)
+      const url = await page.url()
+      return url.should.eql(`${siteUrl}/`)
+    })
 
     it('should be unauthenticated ', async () => {
       try {
-        await I.amOnPage('/basic_auth');
-        await I.dontSee('You entered admin as your password.');
+        await I.amOnPage('/basic_auth')
+        await I.dontSee('You entered admin as your password.')
       } catch (e) {
-        expect(e.message).to.eq('net::ERR_INVALID_AUTH_CREDENTIALS at http://localhost:8000/basic_auth');
+        expect(e.message).to.eq('net::ERR_INVALID_AUTH_CREDENTIALS at http://localhost:8000/basic_auth')
       }
-    });
-  });
+    })
+  })
 
   describe('grabDataFromPerformanceTiming', () => {
     it('should return data from performance timing', async () => {
-      await I.amOnPage('/');
-      const res = await I.grabDataFromPerformanceTiming();
-      expect(res).to.have.property('responseEnd');
-      expect(res).to.have.property('domInteractive');
-      expect(res).to.have.property('domContentLoadedEventEnd');
-      expect(res).to.have.property('loadEventEnd');
-    });
-  });
+      await I.amOnPage('/')
+      const res = await I.grabDataFromPerformanceTiming()
+      expect(res).to.have.property('responseEnd')
+      expect(res).to.have.property('domInteractive')
+      expect(res).to.have.property('domContentLoadedEventEnd')
+      expect(res).to.have.property('loadEventEnd')
+    })
+  })
 
-  webApiTests.tests();
+  webApiTests.tests()
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(() => window.__waitJs, 3));
-    });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction(() => window.__waitJs, 3))
+    })
 
     it('should pass arguments and wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(varName => window[varName], ['__waitJs'], 3));
-    });
-  });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction((varName) => window[varName], ['__waitJs'], 3))
+    })
+  })
 
   describe('#waitToHide', () => {
     it('should wait for hidden element', () => {
@@ -180,810 +183,886 @@ describe('Puppeteer', function () {
         .then(() => I.see('Step One Button'))
         .then(() => I.waitToHide('#step_1', 2))
         .then(() => I.dontSeeElement('#step_1'))
-        .then(() => I.dontSee('Step One Button'));
-    });
+        .then(() => I.dontSee('Step One Button'))
+    })
 
     it('should wait for hidden element by XPath', () => {
       return I.amOnPage('/form/wait_invisible')
         .then(() => I.see('Step One Button'))
         .then(() => I.waitToHide('//div[@id="step_1"]', 2))
         .then(() => I.dontSeeElement('//div[@id="step_1"]'))
-        .then(() => I.dontSee('Step One Button'));
-    });
-  });
+        .then(() => I.dontSee('Step One Button'))
+    })
+  })
 
   describe('#waitNumberOfVisibleElements', () => {
     it('should wait for a specified number of elements on the page', async () => {
       try {
-        await I.amOnPage('/info');
-        await I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3);
+        await I.amOnPage('/info')
+        await I.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3)
       } catch (e) {
-        e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec');
+        e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec')
       }
-    });
-
-    it('should wait for a specified number of elements on the page using a css selector', () => I.amOnPage('/info')
-      .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 3))
-      .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
-      .then(() => {
-        throw Error('It should never get this far');
-      })
-      .catch((e) => {
-        e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec');
-      }));
+    })
+
+    it('should wait for a specified number of elements on the page using a css selector', () =>
+      I.amOnPage('/info')
+        .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 3))
+        .then(() => I.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
+        .then(() => {
+          throw Error('It should never get this far')
+        })
+        .catch((e) => {
+          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec')
+        }))
 
-    it('should wait for a specified number of elements which are not yet attached to the DOM', () => I.amOnPage('/form/wait_num_elements')
-      .then(() => I.waitNumberOfVisibleElements('.title', 2, 3))
-      .then(() => I.see('Hello'))
-      .then(() => I.see('World')));
+    it('should wait for a specified number of elements which are not yet attached to the DOM', () =>
+      I.amOnPage('/form/wait_num_elements')
+        .then(() => I.waitNumberOfVisibleElements('.title', 2, 3))
+        .then(() => I.see('Hello'))
+        .then(() => I.see('World')))
 
     it('should wait for 0 number of visible elements', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.waitNumberOfVisibleElements('#step_1', 0);
-    });
-  });
+      await I.amOnPage('/form/wait_invisible')
+      await I.waitNumberOfVisibleElements('#step_1', 0)
+    })
+  })
 
   describe('#moveCursorTo', () => {
-    it('should trigger hover event', () => I.amOnPage('/form/hover')
-      .then(() => I.moveCursorTo('#hover'))
-      .then(() => I.see('Hovered', '#show')));
+    it('should trigger hover event', () =>
+      I.amOnPage('/form/hover')
+        .then(() => I.moveCursorTo('#hover'))
+        .then(() => I.see('Hovered', '#show')))
 
-    it('should not trigger hover event because of the offset is beyond the element', () => I.amOnPage('/form/hover')
-      .then(() => I.moveCursorTo('#hover', 100, 100))
-      .then(() => I.dontSee('Hovered', '#show')));
-  });
+    it('should not trigger hover event because of the offset is beyond the element', () =>
+      I.amOnPage('/form/hover')
+        .then(() => I.moveCursorTo('#hover', 100, 100))
+        .then(() => I.dontSee('Hovered', '#show')))
+  })
 
   describe('#switchToNextTab, #switchToPreviousTab, #openNewTab, #closeCurrentTab, #closeOtherTabs, #grabNumberOfOpenTabs, #waitForNumberOfTabs', () => {
-    it('should only have 1 tab open when the browser starts and navigates to the first page', () => I.amOnPage('/')
-      .then(() => I.wait(1))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(1)));
-
-    it('should switch to next tab', () => I.amOnPage('/info')
-      .then(() => I.wait(1))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(1))
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.waitForNumberOfTabs(2))
-      .then(() => I.seeCurrentUrlEquals('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(2)));
-
-    it('should assert when there is no ability to switch to next tab', () => I.amOnPage('/')
-      .then(() => I.click('More info'))
-      .then(() => I.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
-      .then(() => I.switchToNextTab(2))
-      .then(() => I.wait(2))
-      .then(() => expect(true, 'Throw an error if it gets this far (which it should not)!').to.eq(false))
-      .catch((e) => {
-        expect(e.message).to.eq('There is no ability to switch to next tab with offset 2');
-      }));
-
-    it('should close current tab', () => I.amOnPage('/info')
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeInCurrentUrl('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(2))
-      .then(() => I.closeCurrentTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('/info'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(1)));
-
-    it('should close other tabs', () => I.amOnPage('/')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.amOnPage('/info'))
-      .then(() => I.click('New tab'))
-      .then(() => I.switchToNextTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeInCurrentUrl('/login'))
-      .then(() => I.closeOtherTabs())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('/login'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(1)));
-
-    it('should open new tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.grabNumberOfOpenTabs())
-      .then(numPages => expect(numPages).to.eq(2)));
-
-    it('should switch to previous tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.seeInCurrentUrl('about:blank'))
-      .then(() => I.switchToPreviousTab())
-      .then(() => I.wait(2))
-      .then(() => I.seeInCurrentUrl('/info')));
-
-    it('should assert when there is no ability to switch to previous tab', () => I.amOnPage('/info')
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.waitInUrl('about:blank'))
-      .then(() => I.switchToPreviousTab(2))
-      .then(() => I.wait(2))
-      .then(() => I.waitInUrl('/info'))
-      .catch((e) => {
-        expect(e.message).to.eq('There is no ability to switch to previous tab with offset 2');
-      }));
-  });
+    it('should only have 1 tab open when the browser starts and navigates to the first page', () =>
+      I.amOnPage('/')
+        .then(() => I.wait(1))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(1)))
+
+    it('should switch to next tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.wait(1))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(1))
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() => I.waitForNumberOfTabs(2))
+        .then(() => I.seeCurrentUrlEquals('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(2)))
+
+    it('should assert when there is no ability to switch to next tab', () =>
+      I.amOnPage('/')
+        .then(() => I.click('More info'))
+        .then(() => I.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
+        .then(() => I.switchToNextTab(2))
+        .then(() => I.wait(2))
+        .then(() => expect(true, 'Throw an error if it gets this far (which it should not)!').to.eq(false))
+        .catch((e) => {
+          expect(e.message).to.eq('There is no ability to switch to next tab with offset 2')
+        }))
+
+    it('should close current tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeInCurrentUrl('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(2))
+        .then(() => I.closeCurrentTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('/info'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(1)))
+
+    it('should close other tabs', () =>
+      I.amOnPage('/')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.amOnPage('/info'))
+        .then(() => I.click('New tab'))
+        .then(() => I.switchToNextTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeInCurrentUrl('/login'))
+        .then(() => I.closeOtherTabs())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('/login'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(1)))
+
+    it('should open new tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.grabNumberOfOpenTabs())
+        .then((numPages) => expect(numPages).to.eq(2)))
+
+    it('should switch to previous tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.seeInCurrentUrl('about:blank'))
+        .then(() => I.switchToPreviousTab())
+        .then(() => I.wait(2))
+        .then(() => I.seeInCurrentUrl('/info')))
+
+    it('should assert when there is no ability to switch to previous tab', () =>
+      I.amOnPage('/info')
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.waitInUrl('about:blank'))
+        .then(() => I.switchToPreviousTab(2))
+        .then(() => I.wait(2))
+        .then(() => I.waitInUrl('/info'))
+        .catch((e) => {
+          expect(e.message).to.eq('There is no ability to switch to previous tab with offset 2')
+        }))
+  })
 
   describe('popup : #acceptPopup, #seeInPopup, #cancelPopup, #grabPopupText', () => {
-    it('should accept popup window', () => I.amOnPage('/form/popup')
-      .then(() => I.amAcceptingPopups())
-      .then(() => I.click('Confirm'))
-      .then(() => I.acceptPopup())
-      .then(() => I.see('Yes', '#result')));
-
-    it('should accept popup window (using default popup action type)', () => I.amOnPage('/form/popup')
-      .then(() => I.click('Confirm'))
-      .then(() => I.acceptPopup())
-      .then(() => I.see('Yes', '#result')));
-
-    it('should cancel popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Confirm'))
-      .then(() => I.cancelPopup())
-      .then(() => I.see('No', '#result')));
-
-    it('should check text in popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Alert'))
-      .then(() => I.seeInPopup('Really?'))
-      .then(() => I.cancelPopup()));
-
-    it('should grab text from popup', () => I.amOnPage('/form/popup')
-      .then(() => I.amCancellingPopups())
-      .then(() => I.click('Alert'))
-      .then(() => I.grabPopupText())
-      .then(text => assert.equal(text, 'Really?')));
-
-    it('should return null if no popup is visible (do not throw an error)', () => I.amOnPage('/form/popup')
-      .then(() => I.grabPopupText())
-      .then(text => assert.equal(text, null)));
-  });
+    it('should accept popup window', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amAcceptingPopups())
+        .then(() => I.click('Confirm'))
+        .then(() => I.acceptPopup())
+        .then(() => I.see('Yes', '#result')))
+
+    it('should accept popup window (using default popup action type)', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.click('Confirm'))
+        .then(() => I.acceptPopup())
+        .then(() => I.see('Yes', '#result')))
+
+    it('should cancel popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Confirm'))
+        .then(() => I.cancelPopup())
+        .then(() => I.see('No', '#result')))
+
+    it('should check text in popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Alert'))
+        .then(() => I.seeInPopup('Really?'))
+        .then(() => I.cancelPopup()))
+
+    it('should grab text from popup', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.amCancellingPopups())
+        .then(() => I.click('Alert'))
+        .then(() => I.grabPopupText())
+        .then((text) => assert.equal(text, 'Really?')))
+
+    it('should return null if no popup is visible (do not throw an error)', () =>
+      I.amOnPage('/form/popup')
+        .then(() => I.grabPopupText())
+        .then((text) => assert.equal(text, null)))
+  })
 
   describe('#seeNumberOfElements', () => {
-    it('should return 1 as count', () => I.amOnPage('/')
-      .then(() => I.seeNumberOfElements('#area1', 1)));
-  });
+    it('should return 1 as count', () => I.amOnPage('/').then(() => I.seeNumberOfElements('#area1', 1)))
+  })
 
   describe('#switchTo', () => {
-    it('should switch reference to iframe content', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('[name="content"]'))
-      .then(() => I.see('Information'))
-      .then(() => I.see('Lots of valuable data here')));
-
-    it('should return error if iframe selector is invalid', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('#invalidIframeSelector'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
-      }));
-
-    it('should return error if iframe selector is not iframe', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('h1'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
-      }));
-
-    it('should return to parent frame given a null locator', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo('[name="content"]'))
-      .then(() => I.see('Information'))
-      .then(() => I.see('Lots of valuable data here'))
-      .then(() => I.switchTo(null))
-      .then(() => I.see('Iframe test')));
-  });
+    it('should switch reference to iframe content', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('[name="content"]'))
+        .then(() => I.see('Information'))
+        .then(() => I.see('Lots of valuable data here')))
+
+    it('should return error if iframe selector is invalid', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('#invalidIframeSelector'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
+        }))
 
-  describe('#seeInSource, #grabSource', () => {
-    it('should check for text to be in HTML source', () => I.amOnPage('/')
-      .then(() => I.seeInSource('<title>TestEd Beta 2.0</title>'))
-      .then(() => I.dontSeeInSource('<meta')));
+    it('should return error if iframe selector is not iframe', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('h1'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
+        }))
+
+    it('should return to parent frame given a null locator', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo('[name="content"]'))
+        .then(() => I.see('Information'))
+        .then(() => I.see('Lots of valuable data here'))
+        .then(() => I.switchTo(null))
+        .then(() => I.see('Iframe test')))
+  })
 
-    it('should grab the source', () => I.amOnPage('/')
-      .then(() => I.grabSource())
-      .then(source => assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved')));
-  });
+  describe('#seeInSource, #grabSource', () => {
+    it('should check for text to be in HTML source', () =>
+      I.amOnPage('/')
+        .then(() => I.seeInSource('<title>TestEd Beta 2.0</title>'))
+        .then(() => I.dontSeeInSource('<meta')))
+
+    it('should grab the source', () =>
+      I.amOnPage('/')
+        .then(() => I.grabSource())
+        .then((source) =>
+          assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved'),
+        ))
+  })
 
   describe('#seeTitleEquals', () => {
-    it('should check that title is equal to provided one', () => I.amOnPage('/')
-      .then(() => I.seeTitleEquals('TestEd Beta 2.0'))
-      .then(() => I.seeTitleEquals('TestEd Beta 2.'))
-      .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected web page title "TestEd Beta 2.0" to equal "TestEd Beta 2."');
-      }));
-  });
+    it('should check that title is equal to provided one', () =>
+      I.amOnPage('/')
+        .then(() => I.seeTitleEquals('TestEd Beta 2.0'))
+        .then(() => I.seeTitleEquals('TestEd Beta 2.'))
+        .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('expected web page title "TestEd Beta 2.0" to equal "TestEd Beta 2."')
+        }))
+  })
 
   describe('#seeTextEquals', () => {
-    it('should check text is equal to provided one', () => I.amOnPage('/')
-      .then(() => I.seeTextEquals('Welcome to test app!', 'h1'))
-      .then(() => I.seeTextEquals('Welcome to test app', 'h1'))
-      .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
-      .catch((e) => {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"');
-      }));
-  });
+    it('should check text is equal to provided one', () =>
+      I.amOnPage('/')
+        .then(() => I.seeTextEquals('Welcome to test app!', 'h1'))
+        .then(() => I.seeTextEquals('Welcome to test app', 'h1'))
+        .then(() => assert.equal(true, false, 'Throw an error because it should not get this far!'))
+        .catch((e) => {
+          e.should.be.instanceOf(Error)
+          e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"')
+        }))
+  })
 
   describe('#_locateClickable', () => {
-    it('should locate a button to click', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateClickable('Submit'))
-      .then((res) => {
-        res.length.should.be.equal(1);
-      }));
-
-    it('should not locate a non-existing checkbox using _locateClickable', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateClickable('I disagree'))
-      .then(res => res.length.should.be.equal(0)));
-  });
+    it('should locate a button to click', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateClickable('Submit'))
+        .then((res) => {
+          res.length.should.be.equal(1)
+        }))
+
+    it('should not locate a non-existing checkbox using _locateClickable', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateClickable('I disagree'))
+        .then((res) => res.length.should.be.equal(0)))
+  })
 
   describe('#_locateCheckable', () => {
-    it('should locate a checkbox', () => I.amOnPage('/form/checkbox')
-      .then(() => I._locateCheckable('I Agree'))
-      .then(res => res.should.be.ok));
-  });
+    it('should locate a checkbox', () =>
+      I.amOnPage('/form/checkbox')
+        .then(() => I._locateCheckable('I Agree'))
+        .then((res) => res.should.be.ok))
+  })
 
   describe('#_locateFields', () => {
-    it('should locate a field', () => I.amOnPage('/form/field')
-      .then(() => I._locateFields('Name'))
-      .then(res => res.length.should.be.equal(1)));
+    it('should locate a field', () =>
+      I.amOnPage('/form/field')
+        .then(() => I._locateFields('Name'))
+        .then((res) => res.length.should.be.equal(1)))
 
-    it('should not locate a non-existing field', () => I.amOnPage('/form/field')
-      .then(() => I._locateFields('Mother-in-law'))
-      .then(res => res.length.should.be.equal(0)));
-  });
+    it('should not locate a non-existing field', () =>
+      I.amOnPage('/form/field')
+        .then(() => I._locateFields('Mother-in-law'))
+        .then((res) => res.length.should.be.equal(0)))
+  })
 
   describe('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
-    it('should throw error if field is not empty', () => I.amOnPage('/form/empty')
-      .then(() => I.seeInField('#empty_input', 'Ayayay'))
-      .catch((e) => {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"');
-      }));
+    it('should throw error if field is not empty', () =>
+      I.amOnPage('/form/empty')
+        .then(() => I.seeInField('#empty_input', 'Ayayay'))
+        .catch((e) => {
+          e.should.be.instanceOf(AssertionFailedError)
+          e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"')
+        }))
 
     it('should check values in checkboxes', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('checkbox[]', 'not seen one');
-      await I.seeInField('checkbox[]', 'see test one');
-      await I.dontSeeInField('checkbox[]', 'not seen two');
-      await I.seeInField('checkbox[]', 'see test two');
-      await I.dontSeeInField('checkbox[]', 'not seen three');
-      await I.seeInField('checkbox[]', 'see test three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('checkbox[]', 'not seen one')
+      await I.seeInField('checkbox[]', 'see test one')
+      await I.dontSeeInField('checkbox[]', 'not seen two')
+      await I.seeInField('checkbox[]', 'see test two')
+      await I.dontSeeInField('checkbox[]', 'not seen three')
+      await I.seeInField('checkbox[]', 'see test three')
+    })
 
     it('should check values are the secret type in checkboxes', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen one'));
-      await I.seeInField('checkbox[]', Secret.secret('see test one'));
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen two'));
-      await I.seeInField('checkbox[]', Secret.secret('see test two'));
-      await I.dontSeeInField('checkbox[]', Secret.secret('not seen three'));
-      await I.seeInField('checkbox[]', Secret.secret('see test three'));
-    });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen one'))
+      await I.seeInField('checkbox[]', Secret.secret('see test one'))
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen two'))
+      await I.seeInField('checkbox[]', Secret.secret('see test two'))
+      await I.dontSeeInField('checkbox[]', Secret.secret('not seen three'))
+      await I.seeInField('checkbox[]', Secret.secret('see test three'))
+    })
 
     it('should check values with boolean', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('checkbox1', true);
-      await I.dontSeeInField('checkbox1', false);
-      await I.seeInField('checkbox2', false);
-      await I.dontSeeInField('checkbox2', true);
-      await I.seeInField('radio2', true);
-      await I.dontSeeInField('radio2', false);
-      await I.seeInField('radio3', false);
-      await I.dontSeeInField('radio3', true);
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('checkbox1', true)
+      await I.dontSeeInField('checkbox1', false)
+      await I.seeInField('checkbox2', false)
+      await I.dontSeeInField('checkbox2', true)
+      await I.seeInField('radio2', true)
+      await I.dontSeeInField('radio2', false)
+      await I.seeInField('radio3', false)
+      await I.dontSeeInField('radio3', true)
+    })
 
     it('should check values in radio', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('radio1', 'see test one');
-      await I.dontSeeInField('radio1', 'not seen one');
-      await I.dontSeeInField('radio1', 'not seen two');
-      await I.dontSeeInField('radio1', 'not seen three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('radio1', 'see test one')
+      await I.dontSeeInField('radio1', 'not seen one')
+      await I.dontSeeInField('radio1', 'not seen two')
+      await I.dontSeeInField('radio1', 'not seen three')
+    })
 
     it('should check values in select', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('select1', 'see test one');
-      await I.dontSeeInField('select1', 'not seen one');
-      await I.dontSeeInField('select1', 'not seen two');
-      await I.dontSeeInField('select1', 'not seen three');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('select1', 'see test one')
+      await I.dontSeeInField('select1', 'not seen one')
+      await I.dontSeeInField('select1', 'not seen two')
+      await I.dontSeeInField('select1', 'not seen three')
+    })
 
     it('should check for empty select field', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.seeInField('select3', '');
-    });
+      await I.amOnPage('/form/field_values')
+      await I.seeInField('select3', '')
+    })
 
     it('should check for select multiple field', async () => {
-      await I.amOnPage('/form/field_values');
-      await I.dontSeeInField('select2', 'not seen one');
-      await I.seeInField('select2', 'see test one');
-      await I.dontSeeInField('select2', 'not seen two');
-      await I.seeInField('select2', 'see test two');
-      await I.dontSeeInField('select2', 'not seen three');
-      await I.seeInField('select2', 'see test three');
-    });
-  });
+      await I.amOnPage('/form/field_values')
+      await I.dontSeeInField('select2', 'not seen one')
+      await I.seeInField('select2', 'see test one')
+      await I.dontSeeInField('select2', 'not seen two')
+      await I.seeInField('select2', 'see test two')
+      await I.dontSeeInField('select2', 'not seen three')
+      await I.seeInField('select2', 'see test three')
+    })
+  })
 
   describe('#pressKey, #pressKeyDown, #pressKeyUp', () => {
     it('should be able to send special keys to element', async () => {
-      await I.amOnPage('/form/field');
-      await I.appendField('Name', '-');
+      await I.amOnPage('/form/field')
+      await I.appendField('Name', '-')
 
-      await I.pressKey(['Right Shift', 'Home']);
-      await I.pressKey('Delete');
+      await I.pressKey(['Right Shift', 'Home'])
+      await I.pressKey('Delete')
 
       // Sequence only executes up to first non-modifier key ('Digit1')
-      await I.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4']);
-      await I.pressKey('1');
-      await I.pressKey('2');
-      await I.pressKey('3');
-      await I.pressKey('ArrowLeft');
-      await I.pressKey('Left Arrow');
-      await I.pressKey('arrow_left');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('a');
-      await I.pressKey('KeyB');
-      await I.pressKeyUp('ShiftLeft');
-      await I.pressKey('C');
-      await I.seeInField('Name', '!ABC123');
-    });
+      await I.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4'])
+      await I.pressKey('1')
+      await I.pressKey('2')
+      await I.pressKey('3')
+      await I.pressKey('ArrowLeft')
+      await I.pressKey('Left Arrow')
+      await I.pressKey('arrow_left')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('a')
+      await I.pressKey('KeyB')
+      await I.pressKeyUp('ShiftLeft')
+      await I.pressKey('C')
+      await I.seeInField('Name', '!ABC123')
+    })
 
     it('should use modifier key based on operating system', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', 'value that is cleared using select all shortcut');
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', 'value that is cleared using select all shortcut')
 
-      await I.pressKey(['ControlOrCommand', 'a']);
-      await I.pressKey('Backspace');
-      await I.dontSeeInField('Name', 'value that is cleared using select all shortcut');
-    });
+      await I.pressKey(['ControlOrCommand', 'a'])
+      await I.pressKey('Backspace')
+      await I.dontSeeInField('Name', 'value that is cleared using select all shortcut')
+    })
 
     it('should show correct numpad or punctuation key when Shift modifier is active', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', '');
-
-      await I.pressKey(';');
-      await I.pressKey(['Shift', ';']);
-      await I.pressKey(['Shift', 'Semicolon']);
-      await I.pressKey('=');
-      await I.pressKey(['Shift', '=']);
-      await I.pressKey(['Shift', 'Equal']);
-      await I.pressKey('*');
-      await I.pressKey(['Shift', '*']);
-      await I.pressKey(['Shift', 'Multiply']);
-      await I.pressKey('+');
-      await I.pressKey(['Shift', '+']);
-      await I.pressKey(['Shift', 'Add']);
-      await I.pressKey(',');
-      await I.pressKey(['Shift', ',']);
-      await I.pressKey(['Shift', 'Comma']);
-      await I.pressKey(['Shift', 'NumpadComma']);
-      await I.pressKey(['Shift', 'Separator']);
-      await I.pressKey('-');
-      await I.pressKey(['Shift', '-']);
-      await I.pressKey(['Shift', 'Subtract']);
-      await I.pressKey('.');
-      await I.pressKey(['Shift', '.']);
-      await I.pressKey(['Shift', 'Decimal']);
-      await I.pressKey(['Shift', 'Period']);
-      await I.pressKey('/');
-      await I.pressKey(['Shift', '/']);
-      await I.pressKey(['Shift', 'Divide']);
-      await I.pressKey(['Shift', 'Slash']);
-
-      await I.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', '')
+
+      await I.pressKey(';')
+      await I.pressKey(['Shift', ';'])
+      await I.pressKey(['Shift', 'Semicolon'])
+      await I.pressKey('=')
+      await I.pressKey(['Shift', '='])
+      await I.pressKey(['Shift', 'Equal'])
+      await I.pressKey('*')
+      await I.pressKey(['Shift', '*'])
+      await I.pressKey(['Shift', 'Multiply'])
+      await I.pressKey('+')
+      await I.pressKey(['Shift', '+'])
+      await I.pressKey(['Shift', 'Add'])
+      await I.pressKey(',')
+      await I.pressKey(['Shift', ','])
+      await I.pressKey(['Shift', 'Comma'])
+      await I.pressKey(['Shift', 'NumpadComma'])
+      await I.pressKey(['Shift', 'Separator'])
+      await I.pressKey('-')
+      await I.pressKey(['Shift', '-'])
+      await I.pressKey(['Shift', 'Subtract'])
+      await I.pressKey('.')
+      await I.pressKey(['Shift', '.'])
+      await I.pressKey(['Shift', 'Decimal'])
+      await I.pressKey(['Shift', 'Period'])
+      await I.pressKey('/')
+      await I.pressKey(['Shift', '/'])
+      await I.pressKey(['Shift', 'Divide'])
+      await I.pressKey(['Shift', 'Slash'])
+
+      await I.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?')
+    })
 
     it('should show correct number key when Shift modifier is active', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', '');
-
-      await I.pressKey('0');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('0');
-      await I.pressKey('Digit0');
-      await I.pressKey('Numpad0');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('1');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('1');
-      await I.pressKey('Digit1');
-      await I.pressKey('Numpad1');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('2');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('2');
-      await I.pressKey('Digit2');
-      await I.pressKey('Numpad2');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('3');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('3');
-      await I.pressKey('Digit3');
-      await I.pressKey('Numpad3');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('4');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('4');
-      await I.pressKey('Digit4');
-      await I.pressKey('Numpad4');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('5');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('5');
-      await I.pressKey('Digit5');
-      await I.pressKey('Numpad5');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('6');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('6');
-      await I.pressKey('Digit6');
-      await I.pressKey('Numpad6');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('7');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('7');
-      await I.pressKey('Digit7');
-      await I.pressKey('Numpad7');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('8');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('8');
-      await I.pressKey('Digit8');
-      await I.pressKey('Numpad8');
-      await I.pressKeyUp('Shift');
-
-      await I.pressKey('9');
-      await I.pressKeyDown('Shift');
-      await I.pressKey('9');
-      await I.pressKey('Digit9');
-      await I.pressKey('Numpad9');
-      await I.pressKeyUp('Shift');
-
-      await I.seeInField('Name', '0))01!!12@@23##34$$45%%56^^67&&78**89((9');
-    });
-  });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', '')
+
+      await I.pressKey('0')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('0')
+      await I.pressKey('Digit0')
+      await I.pressKey('Numpad0')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('1')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('1')
+      await I.pressKey('Digit1')
+      await I.pressKey('Numpad1')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('2')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('2')
+      await I.pressKey('Digit2')
+      await I.pressKey('Numpad2')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('3')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('3')
+      await I.pressKey('Digit3')
+      await I.pressKey('Numpad3')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('4')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('4')
+      await I.pressKey('Digit4')
+      await I.pressKey('Numpad4')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('5')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('5')
+      await I.pressKey('Digit5')
+      await I.pressKey('Numpad5')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('6')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('6')
+      await I.pressKey('Digit6')
+      await I.pressKey('Numpad6')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('7')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('7')
+      await I.pressKey('Digit7')
+      await I.pressKey('Numpad7')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('8')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('8')
+      await I.pressKey('Digit8')
+      await I.pressKey('Numpad8')
+      await I.pressKeyUp('Shift')
+
+      await I.pressKey('9')
+      await I.pressKeyDown('Shift')
+      await I.pressKey('9')
+      await I.pressKey('Digit9')
+      await I.pressKey('Numpad9')
+      await I.pressKeyUp('Shift')
+
+      await I.seeInField('Name', '0))01!!12@@23##34$$45%%56^^67&&78**89((9')
+    })
+  })
 
   describe('#waitForEnabled', () => {
-    it('should wait for input text field to be enabled', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled('#text', 2))
-      .then(() => I.fillField('#text', 'hello world'))
-      .then(() => I.seeInField('#text', 'hello world')));
-
-    it('should wait for input text field to be enabled by xpath', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled("//*[@name = 'test']", 2))
-      .then(() => I.fillField('#text', 'hello world'))
-      .then(() => I.seeInField('#text', 'hello world')));
-
-    it('should wait for a button to be enabled', () => I.amOnPage('/form/wait_enabled')
-      .then(() => I.waitForEnabled('#text', 2))
-      .then(() => I.click('#button'))
-      .then(() => I.see('button was clicked', '#message')));
-  });
+    it('should wait for input text field to be enabled', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled('#text', 2))
+        .then(() => I.fillField('#text', 'hello world'))
+        .then(() => I.seeInField('#text', 'hello world')))
+
+    it('should wait for input text field to be enabled by xpath', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled("//*[@name = 'test']", 2))
+        .then(() => I.fillField('#text', 'hello world'))
+        .then(() => I.seeInField('#text', 'hello world')))
+
+    it('should wait for a button to be enabled', () =>
+      I.amOnPage('/form/wait_enabled')
+        .then(() => I.waitForEnabled('#text', 2))
+        .then(() => I.click('#button'))
+        .then(() => I.see('button was clicked', '#message')))
+  })
 
   describe('#waitForText', () => {
     it('should wait for text after load body', async () => {
-      await I.amOnPage('/redirect_long');
-      await I.waitForText('Hi there and greetings!', 5);
-    });
-  });
+      await I.amOnPage('/redirect_long')
+      await I.waitForText('Hi there and greetings!', 5)
+    })
+  })
 
   describe('#waitForValue', () => {
-    it('should wait for expected value for given locator', () => I.amOnPage('/info')
-      .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно'))
-      .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1))
-      .then(() => {
-        throw Error('It should never get this far');
-      })
-      .catch((e) => {
-        e.message.should.include('element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec');
-      }));
-
-    it('should wait for expected value for given css locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.seeInField('#text', 'Hamburg'))
-      .then(() => I.waitForValue('#text', 'Brisbane', 2.5))
-      .then(() => I.seeInField('#text', 'Brisbane')));
-
-    it('should wait for expected value for given xpath locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.seeInField('#text', 'Hamburg'))
-      .then(() => I.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5))
-      .then(() => I.seeInField('#text', 'Brisbane')));
-
-    it('should only wait for one of the matching elements to contain the value given xpath locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.waitForValue('//input[@type = "text"]', 'Brisbane', 4))
-      .then(() => I.seeInField('#text', 'Brisbane'))
-      .then(() => I.seeInField('#text2', 'London')));
-
-    it('should only wait for one of the matching elements to contain the value given css locator', () => I.amOnPage('/form/wait_value')
-      .then(() => I.waitForValue('.inputbox', 'Brisbane', 4))
-      .then(() => I.seeInField('#text', 'Brisbane'))
-      .then(() => I.seeInField('#text2', 'London')));
-  });
+    it('should wait for expected value for given locator', () =>
+      I.amOnPage('/info')
+        .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно'))
+        .then(() => I.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1))
+        .then(() => {
+          throw Error('It should never get this far')
+        })
+        .catch((e) => {
+          e.message.should.include(
+            'element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec',
+          )
+        }))
+
+    it('should wait for expected value for given css locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.seeInField('#text', 'Hamburg'))
+        .then(() => I.waitForValue('#text', 'Brisbane', 2.5))
+        .then(() => I.seeInField('#text', 'Brisbane')))
+
+    it('should wait for expected value for given xpath locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.seeInField('#text', 'Hamburg'))
+        .then(() => I.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5))
+        .then(() => I.seeInField('#text', 'Brisbane')))
+
+    it('should only wait for one of the matching elements to contain the value given xpath locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.waitForValue('//input[@type = "text"]', 'Brisbane', 4))
+        .then(() => I.seeInField('#text', 'Brisbane'))
+        .then(() => I.seeInField('#text2', 'London')))
+
+    it('should only wait for one of the matching elements to contain the value given css locator', () =>
+      I.amOnPage('/form/wait_value')
+        .then(() => I.waitForValue('.inputbox', 'Brisbane', 4))
+        .then(() => I.seeInField('#text', 'Brisbane'))
+        .then(() => I.seeInField('#text2', 'London')))
+  })
 
   describe('#grabHTMLFrom', () => {
-    it('should grab inner html from an element using xpath query', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFrom('//title'))
-      .then(html => assert.equal(html, 'TestEd Beta 2.0')));
-
-    it('should grab inner html from an element using id query', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFrom('#area1'))
-      .then(html => assert.equal(html.trim(), '<a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>')));
-
-    it('should grab inner html from multiple elements', () => I.amOnPage('/')
-      .then(() => I.grabHTMLFromAll('//a'))
-      .then(html => assert.equal(html.length, 5)));
-
-    it('should grab inner html from within an iframe', () => I.amOnPage('/iframe')
-      .then(() => I.switchTo({ frame: 'iframe' }))
-      .then(() => I.grabHTMLFrom('#new-tab'))
-      .then(html => assert.equal(html.trim(), '<a href="/login" target="_blank">New tab</a>')));
-  });
+    it('should grab inner html from an element using xpath query', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFrom('//title'))
+        .then((html) => assert.equal(html, 'TestEd Beta 2.0')))
+
+    it('should grab inner html from an element using id query', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFrom('#area1'))
+        .then((html) => assert.equal(html.trim(), '<a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>')))
+
+    it('should grab inner html from multiple elements', () =>
+      I.amOnPage('/')
+        .then(() => I.grabHTMLFromAll('//a'))
+        .then((html) => assert.equal(html.length, 5)))
+
+    it('should grab inner html from within an iframe', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.switchTo({ frame: 'iframe' }))
+        .then(() => I.grabHTMLFrom('#new-tab'))
+        .then((html) => assert.equal(html.trim(), '<a href="/login" target="_blank">New tab</a>')))
+  })
 
   describe('#grabBrowserLogs', () => {
-    it('should grab browser logs', () => I.amOnPage('/')
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().indexOf('Test log entry') > -1);
-        assert.equal(matchingLogs.length, 1);
-      }));
-
-    it('should grab browser logs across pages', () => I.amOnPage('/')
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry 1');
-      }))
-      .then(() => I.openNewTab())
-      .then(() => I.wait(1))
-      .then(() => I.amOnPage('/info'))
-      .then(() => I.executeScript(() => {
-        console.log('Test log entry 2');
-      }))
-      .then(() => I.grabBrowserLogs())
-      .then((logs) => {
-        const matchingLogs = logs.filter(log => log.text().indexOf('Test log entry') > -1);
-        assert.equal(matchingLogs.length, 2);
-      }));
-  });
+    it('should grab browser logs', () =>
+      I.amOnPage('/')
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().indexOf('Test log entry') > -1)
+          assert.equal(matchingLogs.length, 1)
+        }))
+
+    it('should grab browser logs across pages', () =>
+      I.amOnPage('/')
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry 1')
+          }),
+        )
+        .then(() => I.openNewTab())
+        .then(() => I.wait(1))
+        .then(() => I.amOnPage('/info'))
+        .then(() =>
+          I.executeScript(() => {
+            console.log('Test log entry 2')
+          }),
+        )
+        .then(() => I.grabBrowserLogs())
+        .then((logs) => {
+          const matchingLogs = logs.filter((log) => log.text().indexOf('Test log entry') > -1)
+          assert.equal(matchingLogs.length, 2)
+        }))
+  })
 
   describe('#dragAndDrop', () => {
-    it('Drag item from source to target (no iframe) @dragNdrop', () => I.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html')
-      .then(() => I.seeElementInDOM('#draggable'))
-      .then(() => I.dragAndDrop('#draggable', '#droppable'))
-      .then(() => I.see('Dropped')));
-
-    it('Drag and drop from within an iframe', () => I.amOnPage('http://jqueryui.com/droppable')
-      .then(() => I.resizeWindow(700, 700))
-      .then(() => I.switchTo('//iframe[@class="demo-frame"]'))
-      .then(() => I.seeElementInDOM('#draggable'))
-      .then(() => I.dragAndDrop('#draggable', '#droppable'))
-      .then(() => I.see('Dropped')));
-  });
+    it('Drag item from source to target (no iframe) @dragNdrop', () =>
+      I.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html')
+        .then(() => I.seeElementInDOM('#draggable'))
+        .then(() => I.dragAndDrop('#draggable', '#droppable'))
+        .then(() => I.see('Dropped')))
+
+    it('Drag and drop from within an iframe', () =>
+      I.amOnPage('http://jqueryui.com/droppable')
+        .then(() => I.resizeWindow(700, 700))
+        .then(() => I.switchTo('//iframe[@class="demo-frame"]'))
+        .then(() => I.seeElementInDOM('#draggable'))
+        .then(() => I.dragAndDrop('#draggable', '#droppable'))
+        .then(() => I.see('Dropped')))
+  })
 
   describe('#switchTo frame', () => {
-    it('should switch to frame using name', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo('iframe'))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1')));
-
-    it('should switch to root frame', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo('iframe'))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1'))
-      .then(() => I.switchTo())
-      .then(() => I.see('Iframe test', 'h1')));
-
-    it('should switch to frame using frame number', () => I.amOnPage('/iframe')
-      .then(() => I.see('Iframe test', 'h1'))
-      .then(() => I.dontSee('Information', 'h1'))
-      .then(() => I.switchTo(0))
-      .then(() => I.see('Information', 'h1'))
-      .then(() => I.dontSee('Iframe test', 'h1')));
-  });
+    it('should switch to frame using name', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo('iframe'))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1')))
+
+    it('should switch to root frame', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo('iframe'))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1'))
+        .then(() => I.switchTo())
+        .then(() => I.see('Iframe test', 'h1')))
+
+    it('should switch to frame using frame number', () =>
+      I.amOnPage('/iframe')
+        .then(() => I.see('Iframe test', 'h1'))
+        .then(() => I.dontSee('Information', 'h1'))
+        .then(() => I.switchTo(0))
+        .then(() => I.see('Information', 'h1'))
+        .then(() => I.dontSee('Iframe test', 'h1')))
+  })
 
   describe('#dragSlider', () => {
     it('should drag scrubber to given position', async () => {
-      await I.amOnPage('/form/page_slider');
-      await I.seeElementInDOM('#slidecontainer input');
-      const before = await I.grabValueFrom('#slidecontainer input');
-      await I.dragSlider('#slidecontainer input', 20);
-      const after = await I.grabValueFrom('#slidecontainer input');
-      assert.notEqual(before, after);
-    });
-  });
+      await I.amOnPage('/form/page_slider')
+      await I.seeElementInDOM('#slidecontainer input')
+      const before = await I.grabValueFrom('#slidecontainer input')
+      await I.dragSlider('#slidecontainer input', 20)
+      const after = await I.grabValueFrom('#slidecontainer input')
+      assert.notEqual(before, after)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await I.amOnPage('/info');
-      await I.uncheckOption('interesting');
-      await I.dontSeeCheckboxIsChecked('interesting');
-    });
+      await I.amOnPage('/info')
+      await I.uncheckOption('interesting')
+      await I.dontSeeCheckboxIsChecked('interesting')
+    })
 
     it('should NOT uncheck option that is NOT currently checked', async () => {
-      await I.amOnPage('/info');
-      await I.uncheckOption('interesting');
+      await I.amOnPage('/info')
+      await I.uncheckOption('interesting')
       // Unchecking again should not affect the current 'unchecked' status
-      await I.uncheckOption('interesting');
-      await I.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await I.uncheckOption('interesting')
+      await I.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('#grabElementBoundingRect', () => {
     it('should get the element bounding rectangle', async () => {
-      await I.amOnPage('/form/hidden');
-      const size = await I.grabElementBoundingRect('input[type=submit]');
-      expect(size.x).is.greaterThan(0);
-      expect(size.y).is.greaterThan(0);
-      expect(size.width).is.greaterThan(0);
-      expect(size.height).is.greaterThan(0);
-    });
+      await I.amOnPage('/form/hidden')
+      const size = await I.grabElementBoundingRect('input[type=submit]')
+      expect(size.x).is.greaterThan(0)
+      expect(size.y).is.greaterThan(0)
+      expect(size.width).is.greaterThan(0)
+      expect(size.height).is.greaterThan(0)
+    })
 
     it('should get the element width', async () => {
-      await I.amOnPage('/form/hidden');
-      const width = await I.grabElementBoundingRect('input[type=submit]', 'width');
-      expect(width).is.greaterThan(0);
-    });
+      await I.amOnPage('/form/hidden')
+      const width = await I.grabElementBoundingRect('input[type=submit]', 'width')
+      expect(width).is.greaterThan(0)
+    })
 
     it('should get the element height', async () => {
-      await I.amOnPage('/form/hidden');
-      const height = await I.grabElementBoundingRect('input[type=submit]', 'height');
-      expect(height).is.greaterThan(0);
-    });
-  });
+      await I.amOnPage('/form/hidden')
+      const height = await I.grabElementBoundingRect('input[type=submit]', 'height')
+      expect(height).is.greaterThan(0)
+    })
+  })
 
   describe('#waitForClickable', () => {
     it('should wait for clickable', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: 'input#text' });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: 'input#text' })
+    })
 
     it('should wait for clickable by XPath', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ xpath: './/input[@id="text"]' });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ xpath: './/input[@id="text"]' })
+    })
 
     it('should fail for disabled element', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #button} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #button} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for disabled element by XPath', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ xpath: './/button[@id="button"]' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {xpath: .//button[@id="button"]} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ xpath: './/button[@id="button"]' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {xpath: .//button[@id="button"]} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by top', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#notInViewportTop' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #notInViewportTop} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#notInViewportTop' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #notInViewportTop} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by bottom', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#notInViewportBottom' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #notInViewportBottom} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#notInViewportBottom' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #notInViewportBottom} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by left', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#notInViewportLeft' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #notInViewportLeft} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#notInViewportLeft' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #notInViewportLeft} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by right', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#notInViewportRight' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #notInViewportRight} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#notInViewportRight' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #notInViewportRight} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for overlapping element', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.waitForClickable({ css: '#div2_button' }, 0.1);
-      await I.waitForClickable({ css: '#div1_button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element {css: #div1_button} still not clickable after 0.1 sec');
-      });
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.waitForClickable({ css: '#div2_button' }, 0.1)
+      await I.waitForClickable({ css: '#div1_button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element {css: #div1_button} still not clickable after 0.1 sec')
+        })
+    })
 
     it('should pass if element change class', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.click('button_save');
-      await I.waitForClickable('//button[@name="button_publish"]');
-    });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.click('button_save')
+      await I.waitForClickable('//button[@name="button_publish"]')
+    })
 
     xit('should fail if element change class and not clickable', async () => {
-      await I.amOnPage('/form/wait_for_clickable');
-      await I.click('button_save');
-      await I.waitForClickable('//button[@name="button_publish"]', 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element //button[@name="button_publish"] still not clickable after 0.1 sec');
-      });
-    });
-  });
+      await I.amOnPage('/form/wait_for_clickable')
+      await I.click('button_save')
+      await I.waitForClickable('//button[@name="button_publish"]', 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element //button[@name="button_publish"] still not clickable after 0.1 sec')
+        })
+    })
+  })
 
   describe('#usePuppeteerTo', () => {
     it('should return title', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       const title = await I.usePuppeteerTo('test', async ({ page }) => {
-        return page.title();
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
-  });
+        return page.title()
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
+  })
 
   describe('#mockRoute, #stopMockingRoute', () => {
     it('should mock a route', async () => {
-      await I.amOnPage('/form/fetch_call');
-      await I.mockRoute('https://reqres.in/api/comments/1', request => {
+      await I.amOnPage('/form/fetch_call')
+      await I.mockRoute('https://reqres.in/api/comments/1', (request) => {
         request.respond({
           status: 200,
           headers: { 'Access-Control-Allow-Origin': '*' },
           contentType: 'application/json',
           body: '{"name": "this was mocked" }',
-        });
-      });
-      await I.click('GET COMMENTS');
-      await I.see('this was mocked');
-      await I.stopMockingRoute('https://reqres.in/api/comments/1');
-      await I.click('GET COMMENTS');
-      await I.see('data');
-      await I.dontSee('this was mocked');
-    });
-  });
-});
-
-let remoteBrowser;
+        })
+      })
+      await I.click('GET COMMENTS')
+      await I.see('this was mocked')
+      await I.stopMockingRoute('https://reqres.in/api/comments/1')
+      await I.click('GET COMMENTS')
+      await I.see('data')
+      await I.dontSee('this was mocked')
+    })
+  })
+})
+
+let remoteBrowser
 async function createRemoteBrowser() {
   remoteBrowser = await puppeteer.launch({
     args: ['--no-sandbox', '--disable-setuid-sandbox'],
     headless: true,
-  });
-  return remoteBrowser;
+  })
+  return remoteBrowser
 }
 
 const helperConfig = {
@@ -999,129 +1078,131 @@ const helperConfig = {
   waitForTimeout: 5000,
   waitForAction: 500,
   windowSize: '500x700',
-};
+}
 
 describe('Puppeteer (remote browser)', function () {
-  this.timeout(35000);
-  this.retries(1);
+  this.timeout(35000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    I = new Puppeteer(helperConfig);
-    I._init();
-    return I._beforeSuite();
-  });
+    global.codecept_dir = path.join(__dirname, '/../data')
+    I = new Puppeteer(helperConfig)
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     // Mimick remote session by creating another browser instance
-    await createRemoteBrowser();
+    await createRemoteBrowser()
     // Set websocket endpoint to other browser instance
-    helperConfig.chrome.browserWSEndpoint = await remoteBrowser.wsEndpoint();
-    I._setConfig(helperConfig);
+    helperConfig.chrome.browserWSEndpoint = await remoteBrowser.wsEndpoint()
+    I._setConfig(helperConfig)
 
-    return I._before();
-  });
+    return I._before()
+  })
 
   afterEach(() => {
-    return I._after()
-      .then(() => {
-        remoteBrowser && remoteBrowser.close();
-      });
-  });
+    return I._after().then(() => {
+      remoteBrowser && remoteBrowser.close()
+    })
+  })
 
   describe('#_startBrowser', () => {
     it('should throw an exception when endpoint is unreachable', async () => {
-      helperConfig.chrome.browserWSEndpoint = 'ws://unreachable/';
-      I._setConfig(helperConfig);
+      helperConfig.chrome.browserWSEndpoint = 'ws://unreachable/'
+      I._setConfig(helperConfig)
       try {
-        await I._startBrowser();
-        throw Error('It should never get this far');
+        await I._startBrowser()
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('Cannot connect to websocket endpoint.\n\nPlease make sure remote browser is running and accessible.');
+        e.message.should.include(
+          'Cannot connect to websocket endpoint.\n\nPlease make sure remote browser is running and accessible.',
+        )
       }
-    });
+    })
 
     xit('should clear any prior existing pages on remote browser', async () => {
-      const remotePages = await remoteBrowser.pages();
-      assert.equal(remotePages.length, 1);
+      const remotePages = await remoteBrowser.pages()
+      assert.equal(remotePages.length, 1)
       for (let p = 1; p < 5; p++) {
-        await remoteBrowser.newPage();
+        await remoteBrowser.newPage()
       }
-      const existingPages = await remoteBrowser.pages();
-      assert.equal(existingPages.length, 5);
+      const existingPages = await remoteBrowser.pages()
+      assert.equal(existingPages.length, 5)
 
-      await I._startBrowser();
+      await I._startBrowser()
       // Session was cleared
-      let currentPages = await remoteBrowser.pages();
-      assert.equal(currentPages.length, 1);
+      let currentPages = await remoteBrowser.pages()
+      assert.equal(currentPages.length, 1)
 
-      let numPages = await I.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
+      let numPages = await I.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
 
-      await I.openNewTab();
+      await I.openNewTab()
 
-      numPages = await I.grabNumberOfOpenTabs();
-      assert.equal(numPages, 2);
+      numPages = await I.grabNumberOfOpenTabs()
+      assert.equal(numPages, 2)
 
-      await I._stopBrowser();
+      await I._stopBrowser()
 
-      currentPages = await remoteBrowser.pages();
-      assert.equal(currentPages.length, 0);
-    });
-  });
-});
+      currentPages = await remoteBrowser.pages()
+      assert.equal(currentPages.length, 0)
+    })
+  })
+})
 
 describe('Puppeteer - Trace', () => {
-  const test = { title: 'a failed test', artifacts: {} };
+  const test = { title: 'a failed test', artifacts: {} }
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    global.output_dir = path.join(`${__dirname}/../data/output`);
+    global.codecept_dir = path.join(__dirname, '/../data')
+    global.output_dir = path.join(`${__dirname}/../data/output`)
 
     I = new Puppeteer({
       url: siteUrl,
       windowSize: '500x700',
       show: false,
       trace: true,
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   beforeEach(async () => {
     webApiTests.init({
-      I, siteUrl,
-    });
-    deleteDir(path.join(global.output_dir, 'trace'));
+      I,
+      siteUrl,
+    })
+    deleteDir(path.join(global.output_dir, 'trace'))
     return I._before(test).then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(async () => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   it('checks that trace is recorded', async () => {
-    await I.amOnPage('/');
-    await I.dontSee('this should be an error');
-    await I.click('More info');
-    await I.dontSee('this should be an error');
-    await I._failed(test);
-    assert(test.artifacts);
-    expect(Object.keys(test.artifacts)).to.include('trace');
-
-    assert.ok(fs.existsSync(test.artifacts.trace));
-    expect(test.artifacts.trace).to.include(path.join(global.output_dir, 'trace'));
-  });
+    await I.amOnPage('/')
+    await I.dontSee('this should be an error')
+    await I.click('More info')
+    await I.dontSee('this should be an error')
+    await I._failed(test)
+    assert(test.artifacts)
+    expect(Object.keys(test.artifacts)).to.include('trace')
+
+    assert.ok(fs.existsSync(test.artifacts.trace))
+    expect(test.artifacts.trace).to.include(path.join(global.output_dir, 'trace'))
+  })
 
   describe('#grabWebElements', () => {
     it('should return an array of WebElement', async () => {
-      await I.amOnPage('/form/focus_blur_elements');
-
-      const webElements = await I.grabWebElements('#button');
-      assert.include(webElements[0].constructor.name, 'CdpElementHandle');
-      assert.isAbove(webElements.length, 0);
-    });
-  });
-});
+      await I.amOnPage('/form/focus_blur_elements')
+
+      const webElements = await I.grabWebElements('#button')
+      assert.include(webElements[0].constructor.name, 'CdpElementHandle')
+      assert.isAbove(webElements.length, 0)
+    })
+  })
+})
diff --git a/test/helper/TestCafe_test.js b/test/helper/TestCafe_test.js
index 8d115ce22..5481810f2 100644
--- a/test/helper/TestCafe_test.js
+++ b/test/helper/TestCafe_test.js
@@ -1,22 +1,22 @@
-const path = require('path');
-const assert = require('assert');
+const path = require('path')
+const assert = require('assert')
 
-const TestHelper = require('../support/TestHelper');
-const TestCafe = require('../../lib/helper/TestCafe');
-const webApiTests = require('./webapi');
-global.codeceptjs = require('../../lib');
+const TestHelper = require('../support/TestHelper')
+const TestCafe = require('../../lib/helper/TestCafe')
+const webApiTests = require('./webapi')
+global.codeceptjs = require('../../lib')
 
-let I;
-const siteUrl = TestHelper.siteUrl();
+let I
+const siteUrl = TestHelper.siteUrl()
 
 describe('TestCafe', function () {
-  this.timeout(35000);
-  this.retries(1);
+  this.timeout(35000)
+  this.retries(1)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
-    global.output_dir = path.join(__dirname, '/../data/output');
-    global.codeceptjs = require('../../lib/index');
+    global.codecept_dir = path.join(__dirname, '/../data')
+    global.output_dir = path.join(__dirname, '/../data/output')
+    global.codeceptjs = require('../../lib/index')
 
     I = new TestCafe({
       url: siteUrl,
@@ -25,69 +25,68 @@ describe('TestCafe', function () {
       browser: 'chrome',
       restart: false,
       waitForTimeout: 5000,
-    });
-    I._init();
-    return I._beforeSuite();
-  });
+    })
+    I._init()
+    return I._beforeSuite()
+  })
 
   after(() => {
-    return I._finishTest();
-  });
+    return I._finishTest()
+  })
 
   beforeEach(() => {
     webApiTests.init({
-      I, siteUrl,
-    });
+      I,
+      siteUrl,
+    })
     return I._before().then(() => {
-      page = I.page;
-      browser = I.browser;
-    });
-  });
+      page = I.page
+      browser = I.browser
+    })
+  })
 
   afterEach(() => {
-    return I._after();
-  });
+    return I._after()
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await I.amOnPage('/');
-      const url = await I.grabCurrentUrl();
-      await url.should.eql(`${siteUrl}/`);
-    });
+      await I.amOnPage('/')
+      const url = await I.grabCurrentUrl()
+      await url.should.eql(`${siteUrl}/`)
+    })
     it('should open any page of configured site', async () => {
-      await I.amOnPage('/info');
-      const url = await I.grabCurrentUrl();
-      return url.should.eql(`${siteUrl}/info`);
-    });
+      await I.amOnPage('/info')
+      const url = await I.grabCurrentUrl()
+      return url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await I.amOnPage(siteUrl);
-      const url = await I.grabCurrentUrl();
-      return url.should.eql(`${siteUrl}/`);
-    });
-  });
+      await I.amOnPage(siteUrl)
+      const url = await I.grabCurrentUrl()
+      return url.should.eql(`${siteUrl}/`)
+    })
+  })
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(() => window.__waitJs, 3));
-    });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction(() => window.__waitJs, 3))
+    })
 
     it('should pass arguments and wait for function returns true', () => {
-      return I.amOnPage('/form/wait_js')
-        .then(() => I.waitForFunction(varName => window[varName], ['__waitJs'], 3));
-    });
-  });
+      return I.amOnPage('/form/wait_js').then(() => I.waitForFunction((varName) => window[varName], ['__waitJs'], 3))
+    })
+  })
 
-  webApiTests.tests();
+  webApiTests.tests()
 
   describe('#useTestCafeTo', () => {
     it('should return title', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       const title = await I.useTestCafeTo('test', async ({ t }) => {
-        return t.eval(() => document.title, { boundTestRun: null });
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
-  });
-});
+        return t.eval(() => document.title, { boundTestRun: null })
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
+  })
+})
diff --git a/test/helper/WebDriver.noSeleniumServer_test.js b/test/helper/WebDriver.noSeleniumServer_test.js
index 2a172a98c..af956c1da 100644
--- a/test/helper/WebDriver.noSeleniumServer_test.js
+++ b/test/helper/WebDriver.noSeleniumServer_test.js
@@ -1,29 +1,29 @@
-const assert = require('assert');
-
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
-const fs = require('fs');
-
-const TestHelper = require('../support/TestHelper');
-const WebDriver = require('../../lib/helper/WebDriver');
-const AssertionFailedError = require('../../lib/assert/error');
-const Secret = require('../../lib/secret');
-global.codeceptjs = require('../../lib');
-
-const siteUrl = TestHelper.siteUrl();
-let wd;
-const browserVersion = 'stable';
+const assert = require('assert')
+
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
+const fs = require('fs')
+
+const TestHelper = require('../support/TestHelper')
+const WebDriver = require('../../lib/helper/WebDriver')
+const AssertionFailedError = require('../../lib/assert/error')
+const Secret = require('../../lib/secret')
+global.codeceptjs = require('../../lib')
+
+const siteUrl = TestHelper.siteUrl()
+let wd
+const browserVersion = 'stable'
 describe('WebDriver - No Selenium server started', function () {
-  this.retries(1);
-  this.timeout(35000);
+  this.retries(1)
+  this.timeout(35000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     try {
-      fs.unlinkSync(dataFile);
+      fs.unlinkSync(dataFile)
     } catch (err) {
       // continue regardless of error
     }
@@ -41,601 +41,611 @@ describe('WebDriver - No Selenium server started', function () {
         },
       },
       customLocatorStrategies: {
-        customSelector: (selector) => (
-          { 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }
-        ),
+        customSelector: (selector) => ({ 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }),
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    this.wdBrowser = await wd._before();
-    return this.wdBrowser;
-  });
+    this.wdBrowser = await wd._before()
+    return this.wdBrowser
+  })
 
-  afterEach(async () => wd._after());
+  afterEach(async () => wd._after())
 
   describe('customLocatorStrategies', () => {
     it('should include the custom strategy', async () => {
-      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined;
-    });
+      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined
+    })
 
     it('should be added to the browser locator strategies', async () => {
-      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined;
-    });
+      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined
+    })
 
     it('throws on invalid custom selector', async () => {
       try {
-        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2);
+        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2)
       } catch (e) {
-        expect(e.message).to.include('Please define "customLocatorStrategies"');
+        expect(e.message).to.include('Please define "customLocatorStrategies"')
       }
-    });
-  });
+    })
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await wd.amOnPage('/');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
+      await wd.amOnPage('/')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
 
     it('should open any page of configured site', async () => {
-      await wd.amOnPage('/info');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/info`);
-    });
+      await wd.amOnPage('/info')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await wd.amOnPage(siteUrl);
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
-  });
+      await wd.amOnPage(siteUrl)
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
+  })
 
   describe('see text : #see', () => {
     it('should fail when text is not on site', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.see('Something incredible!');
+        await wd.see('Something incredible!')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
 
       try {
-        await wd.dontSee('Welcome');
+        await wd.dontSee('Welcome')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
-    });
-  });
+    })
+  })
 
   describe.skip('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
     it('should throw error if field is not empty', async () => {
-      await wd.amOnPage('/form/empty');
+      await wd.amOnPage('/form/empty')
 
       try {
-        await wd.seeInField('#empty_input', 'Ayayay');
+        await wd.seeInField('#empty_input', 'Ayayay')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"')
       }
-    });
+    })
 
     it('should check values in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', 'not seen one');
-      await wd.seeInField('checkbox[]', 'see test one');
-      await wd.dontSeeInField('checkbox[]', 'not seen two');
-      await wd.seeInField('checkbox[]', 'see test two');
-      await wd.dontSeeInField('checkbox[]', 'not seen three');
-      await wd.seeInField('checkbox[]', 'see test three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', 'not seen one')
+      await wd.seeInField('checkbox[]', 'see test one')
+      await wd.dontSeeInField('checkbox[]', 'not seen two')
+      await wd.seeInField('checkbox[]', 'see test two')
+      await wd.dontSeeInField('checkbox[]', 'not seen three')
+      await wd.seeInField('checkbox[]', 'see test three')
+    })
 
     it('should check values are the secret type in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test one'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test two'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test three'));
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test one'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test two'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test three'))
+    })
 
     it('should check values with boolean', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('checkbox1', true);
-      await wd.dontSeeInField('checkbox1', false);
-      await wd.seeInField('checkbox2', false);
-      await wd.dontSeeInField('checkbox2', true);
-      await wd.seeInField('radio2', true);
-      await wd.dontSeeInField('radio2', false);
-      await wd.seeInField('radio3', false);
-      await wd.dontSeeInField('radio3', true);
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('checkbox1', true)
+      await wd.dontSeeInField('checkbox1', false)
+      await wd.seeInField('checkbox2', false)
+      await wd.dontSeeInField('checkbox2', true)
+      await wd.seeInField('radio2', true)
+      await wd.dontSeeInField('radio2', false)
+      await wd.seeInField('radio3', false)
+      await wd.dontSeeInField('radio3', true)
+    })
 
     it('should check values in radio', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('radio1', 'see test one');
-      await wd.dontSeeInField('radio1', 'not seen one');
-      await wd.dontSeeInField('radio1', 'not seen two');
-      await wd.dontSeeInField('radio1', 'not seen three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('radio1', 'see test one')
+      await wd.dontSeeInField('radio1', 'not seen one')
+      await wd.dontSeeInField('radio1', 'not seen two')
+      await wd.dontSeeInField('radio1', 'not seen three')
+    })
 
     it('should check values in select', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('select1', 'see test one');
-      await wd.dontSeeInField('select1', 'not seen one');
-      await wd.dontSeeInField('select1', 'not seen two');
-      await wd.dontSeeInField('select1', 'not seen three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('select1', 'see test one')
+      await wd.dontSeeInField('select1', 'not seen one')
+      await wd.dontSeeInField('select1', 'not seen two')
+      await wd.dontSeeInField('select1', 'not seen three')
+    })
 
     it('should check for empty select field', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('select3', '');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('select3', '')
+    })
 
     it('should check for select multiple field', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('select2', 'not seen one');
-      await wd.seeInField('select2', 'see test one');
-      await wd.dontSeeInField('select2', 'not seen two');
-      await wd.seeInField('select2', 'see test two');
-      await wd.dontSeeInField('select2', 'not seen three');
-      await wd.seeInField('select2', 'see test three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('select2', 'not seen one')
+      await wd.seeInField('select2', 'see test one')
+      await wd.dontSeeInField('select2', 'not seen two')
+      await wd.seeInField('select2', 'see test two')
+      await wd.dontSeeInField('select2', 'not seen three')
+      await wd.seeInField('select2', 'see test three')
+    })
 
     it('should return error when element has no value attribute', async () => {
-      await wd.amOnPage('https://codecept.io/quickstart');
+      await wd.amOnPage('https://codecept.io/quickstart')
 
       try {
-        await wd.seeInField('#search_input_react', 'WebDriver1');
+        await wd.seeInField('#search_input_react', 'WebDriver1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
+        e.should.be.instanceOf(Error)
       }
-    });
-  });
+    })
+  })
 
   describe('Force Right Click: #forceRightClick', () => {
     it('it should forceRightClick', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('.context a');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('.context a')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator and context', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum', '.context');
-      await wd.see('right clicked');
-    });
-  });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum', '.context')
+      await wd.see('right clicked')
+    })
+  })
 
   describe.skip('#pressKey, #pressKeyDown, #pressKeyUp', () => {
     it('should be able to send special keys to element', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.appendField('Name', '-');
+      await wd.amOnPage('/form/field')
+      await wd.appendField('Name', '-')
 
-      await wd.pressKey(['Right Shift', 'Home']);
-      await wd.pressKey('Delete');
+      await wd.pressKey(['Right Shift', 'Home'])
+      await wd.pressKey('Delete')
 
       // Sequence only executes up to first non-modifier key ('Digit1')
-      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4']);
-      await wd.pressKey('1');
-      await wd.pressKey('2');
-      await wd.pressKey('3');
-      await wd.pressKey('ArrowLeft');
-      await wd.pressKey('Left Arrow');
-      await wd.pressKey('arrow_left');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('a');
-      await wd.pressKey('KeyB');
-      await wd.pressKeyUp('ShiftLeft');
-      await wd.pressKey('C');
-      await wd.seeInField('Name', '!ABC123');
-    });
+      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4'])
+      await wd.pressKey('1')
+      await wd.pressKey('2')
+      await wd.pressKey('3')
+      await wd.pressKey('ArrowLeft')
+      await wd.pressKey('Left Arrow')
+      await wd.pressKey('arrow_left')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('a')
+      await wd.pressKey('KeyB')
+      await wd.pressKeyUp('ShiftLeft')
+      await wd.pressKey('C')
+      await wd.seeInField('Name', '!ABC123')
+    })
 
     it('should use modifier key based on operating system', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', 'value that is cleared using select all shortcut');
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', 'value that is cleared using select all shortcut')
 
-      await wd.pressKey(['CommandOrControl', 'A']);
-      await wd.pressKey('Backspace');
-      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut');
-    });
+      await wd.pressKey(['CommandOrControl', 'A'])
+      await wd.pressKey('Backspace')
+      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut')
+    })
 
     it('should show correct numpad or punctuation key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey(';');
-      await wd.pressKey(['Shift', ';']);
-      await wd.pressKey(['Shift', 'Semicolon']);
-      await wd.pressKey('=');
-      await wd.pressKey(['Shift', '=']);
-      await wd.pressKey(['Shift', 'Equal']);
-      await wd.pressKey('*');
-      await wd.pressKey(['Shift', '*']);
-      await wd.pressKey(['Shift', 'Multiply']);
-      await wd.pressKey('+');
-      await wd.pressKey(['Shift', '+']);
-      await wd.pressKey(['Shift', 'Add']);
-      await wd.pressKey(',');
-      await wd.pressKey(['Shift', ',']);
-      await wd.pressKey(['Shift', 'Comma']);
-      await wd.pressKey(['Shift', 'NumpadComma']);
-      await wd.pressKey(['Shift', 'Separator']);
-      await wd.pressKey('-');
-      await wd.pressKey(['Shift', '-']);
-      await wd.pressKey(['Shift', 'Subtract']);
-      await wd.pressKey('.');
-      await wd.pressKey(['Shift', '.']);
-      await wd.pressKey(['Shift', 'Decimal']);
-      await wd.pressKey(['Shift', 'Period']);
-      await wd.pressKey('/');
-      await wd.pressKey(['Shift', '/']);
-      await wd.pressKey(['Shift', 'Divide']);
-      await wd.pressKey(['Shift', 'Slash']);
-
-      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?');
-    });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey(';')
+      await wd.pressKey(['Shift', ';'])
+      await wd.pressKey(['Shift', 'Semicolon'])
+      await wd.pressKey('=')
+      await wd.pressKey(['Shift', '='])
+      await wd.pressKey(['Shift', 'Equal'])
+      await wd.pressKey('*')
+      await wd.pressKey(['Shift', '*'])
+      await wd.pressKey(['Shift', 'Multiply'])
+      await wd.pressKey('+')
+      await wd.pressKey(['Shift', '+'])
+      await wd.pressKey(['Shift', 'Add'])
+      await wd.pressKey(',')
+      await wd.pressKey(['Shift', ','])
+      await wd.pressKey(['Shift', 'Comma'])
+      await wd.pressKey(['Shift', 'NumpadComma'])
+      await wd.pressKey(['Shift', 'Separator'])
+      await wd.pressKey('-')
+      await wd.pressKey(['Shift', '-'])
+      await wd.pressKey(['Shift', 'Subtract'])
+      await wd.pressKey('.')
+      await wd.pressKey(['Shift', '.'])
+      await wd.pressKey(['Shift', 'Decimal'])
+      await wd.pressKey(['Shift', 'Period'])
+      await wd.pressKey('/')
+      await wd.pressKey(['Shift', '/'])
+      await wd.pressKey(['Shift', 'Divide'])
+      await wd.pressKey(['Shift', 'Slash'])
+
+      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?')
+    })
 
     it('should show correct number key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey('0');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('0');
-      await wd.pressKey('Digit0');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('1');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('1');
-      await wd.pressKey('Digit1');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('2');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('2');
-      await wd.pressKey('Digit2');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('3');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('3');
-      await wd.pressKey('Digit3');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('4');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('4');
-      await wd.pressKey('Digit4');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('5');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('5');
-      await wd.pressKey('Digit5');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('6');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('6');
-      await wd.pressKey('Digit6');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('7');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('7');
-      await wd.pressKey('Digit7');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('8');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('8');
-      await wd.pressKey('Digit8');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('9');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('9');
-      await wd.pressKey('Digit9');
-      await wd.pressKeyUp('Shift');
-
-      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((');
-    });
-  });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey('0')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('0')
+      await wd.pressKey('Digit0')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('1')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('1')
+      await wd.pressKey('Digit1')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('2')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('2')
+      await wd.pressKey('Digit2')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('3')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('3')
+      await wd.pressKey('Digit3')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('4')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('4')
+      await wd.pressKey('Digit4')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('5')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('5')
+      await wd.pressKey('Digit5')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('6')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('6')
+      await wd.pressKey('Digit6')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('7')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('7')
+      await wd.pressKey('Digit7')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('8')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('8')
+      await wd.pressKey('Digit8')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('9')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('9')
+      await wd.pressKey('Digit9')
+      await wd.pressKeyUp('Shift')
+
+      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((')
+    })
+  })
 
   describe('#seeInSource, #grabSource', () => {
     it('should check for text to be in HTML source', async () => {
-      await wd.amOnPage('/');
-      await wd.seeInSource('<title>TestEd Beta 2.0</title>');
-      await wd.dontSeeInSource('<meta');
-    });
+      await wd.amOnPage('/')
+      await wd.seeInSource('<title>TestEd Beta 2.0</title>')
+      await wd.dontSeeInSource('<meta')
+    })
 
     it('should grab the source', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabSource();
-      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved');
-    });
+      await wd.amOnPage('/')
+      const source = await wd.grabSource()
+      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved')
+    })
 
     it('should grab the innerHTML for an element', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabHTMLFrom('#area1');
+      await wd.amOnPage('/')
+      const source = await wd.grabHTMLFrom('#area1')
       assert.deepEqual(
         source,
         `
     <a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>
 `,
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('#seeTitleEquals', () => {
     it('should check that title is equal to provided one', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.seeTitleEquals('TestEd Beta 2.0');
-        await wd.seeTitleEquals('TestEd Beta 2.');
+        await wd.seeTitleEquals('TestEd Beta 2.0')
+        await wd.seeTitleEquals('TestEd Beta 2.')
       } catch (e) {
-        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0');
+        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeTextEquals', () => {
     it('should check text is equal to provided one', async () => {
-      await wd.amOnPage('/');
-      await wd.seeTextEquals('Welcome to test app!', 'h1');
+      await wd.amOnPage('/')
+      await wd.seeTextEquals('Welcome to test app!', 'h1')
 
       try {
-        await wd.seeTextEquals('Welcome to test app', 'h1');
-        assert.equal(true, false, 'Throw an error because it should not get this far!');
+        await wd.seeTextEquals('Welcome to test app', 'h1')
+        assert.equal(true, false, 'Throw an error because it should not get this far!')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"')
         // e.should.be.instanceOf(AssertionFailedError);
       }
-    });
+    })
 
     it('should check text is not equal to empty string of element text', async () => {
-      await wd.amOnPage('https://codecept.io');
+      await wd.amOnPage('https://codecept.io')
 
       try {
-        await wd.seeTextEquals('', '.logo');
-        await wd.seeTextEquals('This is not empty', '.logo');
+        await wd.seeTextEquals('', '.logo')
+        await wd.seeTextEquals('This is not empty', '.logo')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""')
       }
-    });
-  });
+    })
+  })
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(() => window.__waitJs, 3);
-    });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction(() => window.__waitJs, 3)
+    })
 
     it('should pass arguments and wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(varName => window[varName], ['__waitJs'], 3);
-    });
-  });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction((varName) => window[varName], ['__waitJs'], 3)
+    })
+  })
 
   describe.skip('#waitForEnabled', () => {
     it('should wait for input text field to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for input text field to be enabled by xpath', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled("//*[@name = 'test']", 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled("//*[@name = 'test']", 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for a button to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.click('#button');
-      await wd.see('button was clicked');
-    });
-  });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.click('#button')
+      await wd.see('button was clicked')
+    })
+  })
 
   describe.skip('#waitForValue', () => {
     it('should wait for expected value for given locator', async () => {
-      await wd.amOnPage('/info');
-      await wd.waitForValue('//input[@name= "rus"]', 'Верно');
+      await wd.amOnPage('/info')
+      await wd.waitForValue('//input[@name= "rus"]', 'Верно')
 
       try {
-        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1);
-        throw Error('It should never get this far');
+        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1)
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec');
+        e.message.should.include(
+          'element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec',
+        )
       }
-    });
+    })
 
     it('should wait for expected value for given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('#text', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('#text', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should wait for expected value for given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should only wait for one of the matching elements to contain the value given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
 
     it('should only wait for one of the matching elements to contain the value given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('.inputbox', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
-  });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('.inputbox', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
+  })
 
   describe('#waitNumberOfVisibleElements', () => {
     it('should wait for a specified number of elements on the page', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3))
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements({ css: '//div[@id = "grab-multiple"]//a' }, 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified number of elements on the page using a css selector', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 3))
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should wait for a specified number of elements which are not yet attached to the DOM', () => {
-      return wd.amOnPage('/form/wait_num_elements')
+      return wd
+        .amOnPage('/form/wait_num_elements')
         .then(() => wd.waitNumberOfVisibleElements('.title', 2, 3))
         .then(() => wd.see('Hello'))
-        .then(() => wd.see('World'));
-    });
-  });
+        .then(() => wd.see('World'))
+    })
+  })
 
   describe('#waitForVisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForVisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
-  });
+          e.message.should.not.include('[object Object]')
+        })
+    })
+  })
 
   describe('#waitForInvisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForInvisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified element to be invisible', () => {
-      return wd.amOnPage('/form/wait_invisible')
+      return wd
+        .amOnPage('/form/wait_invisible')
         .then(() => wd.waitForInvisible('#step1', 3))
-        .then(() => wd.dontSeeElement('#step1'));
-    });
-  });
+        .then(() => wd.dontSeeElement('#step1'))
+    })
+  })
 
   describe('#moveCursorTo', () => {
     it('should trigger hover event', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover');
-      await wd.see('Hovered', '#show');
-    });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover')
+      await wd.see('Hovered', '#show')
+    })
 
     it('should not trigger hover event because of the offset is beyond the element', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover', 100, 100);
-      await wd.dontSee('Hovered', '#show');
-    });
-  });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover', 100, 100)
+      await wd.dontSee('Hovered', '#show')
+    })
+  })
 
   describe('#switchToNextTab, #switchToPreviousTab, #openNewTab, #closeCurrentTab, #closeOtherTabs, #grabNumberOfOpenTabs', () => {
     it('should only have 1 tab open when the browser starts and navigates to the first page', async () => {
-      await wd.amOnPage('/');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
-    });
+      await wd.amOnPage('/')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
+    })
 
     it('should switch to next tab', async () => {
-      wd.amOnPage('/info');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
+      wd.amOnPage('/info')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
 
-      await wd.click('New tab');
-      await wd.switchToNextTab();
-      await wd.waitInUrl('/login');
-      const numPagesAfter = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPagesAfter, 2);
-    });
+      await wd.click('New tab')
+      await wd.switchToNextTab()
+      await wd.waitInUrl('/login')
+      const numPagesAfter = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPagesAfter, 2)
+    })
 
     it('should assert when there is no ability to switch to next tab', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.click('More info'))
         .then(() => wd.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
         .then(() => wd.switchToNextTab(2))
         .then(() => assert.equal(true, false, 'Throw an error if it gets this far (which it should not)!'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2');
-        });
-    });
+          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2')
+        })
+    })
 
     it('should close current tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.click('New tab'))
         .then(() => wd.switchToNextTab())
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2))
+        .then((numPages) => assert.equal(numPages, 2))
         .then(() => wd.closeCurrentTab())
         .then(() => wd.seeInCurrentUrl('/info'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should close other tabs', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.openNewTab())
         .then(() => wd.seeInCurrentUrl('about:blank'))
         .then(() => wd.amOnPage('/info'))
@@ -644,574 +654,615 @@ describe('WebDriver - No Selenium server started', function () {
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.closeOtherTabs())
         .then(() => wd.seeInCurrentUrl('/login'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should open new tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2));
-    });
+        .then((numPages) => assert.equal(numPages, 2))
+    })
 
     it('should switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab())
-        .then(() => wd.waitInUrl('/info'));
-    });
+        .then(() => wd.waitInUrl('/info'))
+    })
 
     it('should assert when there is no ability to switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab(2))
         .then(() => wd.waitInUrl('/info'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2');
-        });
-    });
-  });
+          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2')
+        })
+    })
+  })
 
   describe('popup : #acceptPopup, #seeInPopup, #cancelPopup', () => {
     it('should accept popup window', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.acceptPopup())
-        .then(() => wd.see('Yes', '#result'));
-    });
+        .then(() => wd.see('Yes', '#result'))
+    })
 
     it('should cancel popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.cancelPopup())
-        .then(() => wd.see('No', '#result'));
-    });
+        .then(() => wd.see('No', '#result'))
+    })
 
     it('should check text in popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.seeInPopup('Really?'))
-        .then(() => wd.cancelPopup());
-    });
+        .then(() => wd.cancelPopup())
+    })
 
     it('should grab text from popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, 'Really?'));
-    });
+        .then((text) => assert.equal(text, 'Really?'))
+    })
 
     it('should return null if no popup is visible (do not throw an error)', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, null));
-    });
-  });
+        .then((text) => assert.equal(text, null))
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Nothing here', 1, '#text'))
         .catch((e) => {
-          e.message.should.be.equal('element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec');
-        });
-    });
+          e.message.should.be.equal(
+            'element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec',
+          )
+        })
+    })
 
     it('should return error if waiting is too small', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Dynamic text', 0.1))
         .catch((e) => {
-          e.message.should.be.equal('element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec');
-        });
-    });
-  });
+          e.message.should.be.equal(
+            'element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec',
+          )
+        })
+    })
+  })
 
   describe('#seeNumberOfElements', () => {
     it('should return 1 as count', async () => {
-      await wd.amOnPage('/');
-      await wd.seeNumberOfElements('#area1', 1);
-    });
-  });
+      await wd.amOnPage('/')
+      await wd.seeNumberOfElements('#area1', 1)
+    })
+  })
 
   describe('#switchTo', () => {
     it('should switch reference to iframe content', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+    })
 
     it('should return error if iframe selector is invalid', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('#invalidIframeSelector');
+        await wd.switchTo('#invalidIframeSelector')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
       }
-    });
+    })
 
     it('should return error if iframe selector is not iframe', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('h1');
+        await wd.switchTo('h1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.contain('no such frame');
+        e.should.be.instanceOf(Error)
+        e.message.should.contain('no such frame')
       }
-    });
+    })
 
     it('should return to parent frame given a null locator', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-      await wd.switchTo(null);
-      await wd.see('Iframe test');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+      await wd.switchTo(null)
+      await wd.see('Iframe test')
+    })
+  })
 
   describe('click context', () => {
     it('should click on inner text', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//input[@type = "submit"]');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//input[@type = "submit"]')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click on input in inner element', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//form');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//form')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click by accessibility_id', async () => {
-      await wd.amOnPage('/info');
-      await wd.click('~index via aria-label');
-      await wd.see('Welcome to test app!');
-    });
-  });
+      await wd.amOnPage('/info')
+      await wd.click('~index via aria-label')
+      await wd.see('Welcome to test app!')
+    })
+  })
 
   describe('window size #resizeWindow', () => {
     it('should set initial window size', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.click('Window Size');
-      await wd.see('Height 700', '#height');
-      await wd.see('Width 500', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.click('Window Size')
+      await wd.see('Height 700', '#height')
+      await wd.see('Width 500', '#width')
+    })
 
     it('should set window size on new session', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd._session())
-        .then(session => session.start()
-          .then(browser => ({
+        .then((session) =>
+          session.start().then((browser) => ({
             browser,
             session,
-          })))
+          })),
+        )
         .then(({ session, browser }) => session.loadVars(browser))
         .then(() => wd.amOnPage('/form/resize'))
         .then(() => wd.click('Window Size'))
         .then(() => wd.see('Height 700', '#height'))
-        .then(() => wd.see('Width 500', '#width'));
-    });
+        .then(() => wd.see('Width 500', '#width'))
+    })
 
     it('should resize window to specific dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(950, 600);
-      await wd.click('Window Size');
-      await wd.see('Height 600', '#height');
-      await wd.see('Width 950', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(950, 600)
+      await wd.click('Window Size')
+      await wd.see('Height 600', '#height')
+      await wd.see('Width 950', '#width')
+    })
 
     xit('should resize window to maximum screen dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(500, 400);
-      await wd.click('Window Size');
-      await wd.see('Height 400', '#height');
-      await wd.see('Width 500', '#width');
-      await wd.resizeWindow('maximize');
-      await wd.click('Window Size');
-      await wd.dontSee('Height 400', '#height');
-      await wd.dontSee('Width 500', '#width');
-    });
-  });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(500, 400)
+      await wd.click('Window Size')
+      await wd.see('Height 400', '#height')
+      await wd.see('Width 500', '#width')
+      await wd.resizeWindow('maximize')
+      await wd.click('Window Size')
+      await wd.dontSee('Height 400', '#height')
+      await wd.dontSee('Width 500', '#width')
+    })
+  })
 
   describe('SmartWait', () => {
-    before(() => wd.options.smartWait = 3000);
-    after(() => wd.options.smartWait = 0);
+    before(() => (wd.options.smartWait = 3000))
+    after(() => (wd.options.smartWait = 0))
 
     it('should wait for element to appear', async () => {
-      await wd.amOnPage('/form/wait_element');
-      await wd.dontSeeElement('h1');
-      await wd.seeElement('h1');
-    });
+      await wd.amOnPage('/form/wait_element')
+      await wd.dontSeeElement('h1')
+      await wd.seeElement('h1')
+    })
 
     it('should wait for clickable element appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#click');
-      await wd.click('#click');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#click')
+      await wd.click('#click')
+      await wd.see('Hi!')
+    })
 
     it('should wait for clickable context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#linkContext');
-      await wd.click('Hello world', '#linkContext');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#linkContext')
+      await wd.click('Hello world', '#linkContext')
+      await wd.see('Hi!')
+    })
 
     it('should wait for text context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      await wd.see('Hello world', '#linkContext');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      await wd.see('Hello world', '#linkContext')
+    })
 
     it('should work with grabbers', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      const res = await wd.grabAttributeFrom('#click', 'id');
-      assert.equal(res, 'click');
-    });
-  });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      const res = await wd.grabAttributeFrom('#click', 'id')
+      assert.equal(res, 'click')
+    })
+  })
 
   describe('#_locateClickable', () => {
     it('should locate a button to click', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('Submit');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('Submit')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateCheckable', () => {
     it('should locate a checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I Agree');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I Agree')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateFields', () => {
     it('should locate a field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Name');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Name')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Mother-in-law');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Mother-in-law')
+      res.length.should.be.equal(0)
+    })
+  })
 
   xdescribe('#grabBrowserLogs', () => {
     it('should grab browser logs', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry');
-      });
-      const logs = await wd.grabBrowserLogs();
-      console.log('lololo', logs);
+        console.log('Test log entry')
+      })
+      const logs = await wd.grabBrowserLogs()
+      console.log('lololo', logs)
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 1);
-    });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 1)
+    })
 
     it('should grab browser logs across pages', async () => {
-      wd.amOnPage('/');
+      wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry 1');
-      });
-      await wd.openNewTab();
-      await wd.amOnPage('/info');
+        console.log('Test log entry 1')
+      })
+      await wd.openNewTab()
+      await wd.amOnPage('/info')
       await wd.executeScript(() => {
-        console.log('Test log entry 2');
-      });
+        console.log('Test log entry 2')
+      })
 
-      const logs = await wd.grabBrowserLogs();
+      const logs = await wd.grabBrowserLogs()
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 2);
-    });
-  });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 2)
+    })
+  })
 
   describe('#dragAndDrop', () => {
     it('Drag item from source to target (no iframe) @dragNdrop', async () => {
-      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
+      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
 
     it('Drag and drop from within an iframe', async () => {
-      await wd.amOnPage('http://jqueryui.com/droppable');
-      await wd.resizeWindow(700, 700);
-      await wd.switchTo('//iframe[@class="demo-frame"]');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
-  });
+      await wd.amOnPage('http://jqueryui.com/droppable')
+      await wd.resizeWindow(700, 700)
+      await wd.switchTo('//iframe[@class="demo-frame"]')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
+  })
 
   describe('#switchTo frame', () => {
     it('should switch to frame using name', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
 
     it('should switch to root frame', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-      await wd.switchTo();
-      await wd.see('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+      await wd.switchTo()
+      await wd.see('Iframe test', 'h1')
+    })
 
     it('should switch to frame using frame number', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo(0);
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo(0)
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
+  })
 
   describe.skip('#AttachFile', () => {
     it('should attach to regular input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('Avatar', './app/avatar.jpg');
-      await wd.seeInField('Avatar', 'avatar.jpg');
-    });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('Avatar', './app/avatar.jpg')
+      await wd.seeInField('Avatar', 'avatar.jpg')
+    })
 
     it('should attach to invisible input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('hidden', '/app/avatar.jpg');
-    });
-  });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('hidden', '/app/avatar.jpg')
+    })
+  })
 
   describe('#dragSlider', () => {
     it('should drag scrubber to given position', async () => {
-      await wd.amOnPage('/form/page_slider');
-      await wd.seeElementInDOM('#slidecontainer input');
+      await wd.amOnPage('/form/page_slider')
+      await wd.seeElementInDOM('#slidecontainer input')
 
-      const before = await wd.grabValueFrom('#slidecontainer input');
-      await wd.dragSlider('#slidecontainer input', 20);
-      const after = await wd.grabValueFrom('#slidecontainer input');
+      const before = await wd.grabValueFrom('#slidecontainer input')
+      await wd.dragSlider('#slidecontainer input', 20)
+      const after = await wd.grabValueFrom('#slidecontainer input')
 
-      assert.notEqual(before, after);
-    });
-  });
+      assert.notEqual(before, after)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
 
     it('should NOT uncheck option that is NOT currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
       // Unchecking again should not affect the current 'unchecked' status
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('allow back and forth between handles: #grabAllWindowHandles #grabCurrentWindowHandle #switchToWindow', () => {
     it('should open main page of configured site, open a popup, switch to main page, then switch to popup, close popup, and go back to main page', async () => {
-      await wd.amOnPage('/');
-      const handleBeforePopup = await wd.grabCurrentWindowHandle();
-      const urlBeforePopup = await wd.grabCurrentUrl();
+      await wd.amOnPage('/')
+      const handleBeforePopup = await wd.grabCurrentWindowHandle()
+      const urlBeforePopup = await wd.grabCurrentUrl()
 
-      const allHandlesBeforePopup = await wd.grabAllWindowHandles();
-      allHandlesBeforePopup.length.should.eql(1);
+      const allHandlesBeforePopup = await wd.grabAllWindowHandles()
+      allHandlesBeforePopup.length.should.eql(1)
 
       await wd.executeScript(() => {
-        window.open('https://www.w3schools.com/', 'new window', 'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400');
-      });
-
-      const allHandlesAfterPopup = await wd.grabAllWindowHandles();
-      allHandlesAfterPopup.length.should.eql(2);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterPopup = await wd.grabCurrentUrl();
-      urlAfterPopup.should.eql('https://www.w3schools.com/');
-
-      handleBeforePopup.should.eql(allHandlesAfterPopup[0]);
-      await wd.switchToWindow(handleBeforePopup);
-      const currentURL = await wd.grabCurrentUrl();
-      currentURL.should.eql(urlBeforePopup);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterSwitchBack = await wd.grabCurrentUrl();
-      urlAfterSwitchBack.should.eql('https://www.w3schools.com/');
-      await wd.closeCurrentTab();
-
-      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles();
-      allHandlesAfterPopupClosed.length.should.eql(1);
-      const currentWindowHandle = await wd.grabCurrentWindowHandle();
-      currentWindowHandle.should.eql(handleBeforePopup);
-    });
-  });
+        window.open(
+          'https://www.w3schools.com/',
+          'new window',
+          'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400',
+        )
+      })
+
+      const allHandlesAfterPopup = await wd.grabAllWindowHandles()
+      allHandlesAfterPopup.length.should.eql(2)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterPopup = await wd.grabCurrentUrl()
+      urlAfterPopup.should.eql('https://www.w3schools.com/')
+
+      handleBeforePopup.should.eql(allHandlesAfterPopup[0])
+      await wd.switchToWindow(handleBeforePopup)
+      const currentURL = await wd.grabCurrentUrl()
+      currentURL.should.eql(urlBeforePopup)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterSwitchBack = await wd.grabCurrentUrl()
+      urlAfterSwitchBack.should.eql('https://www.w3schools.com/')
+      await wd.closeCurrentTab()
+
+      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles()
+      allHandlesAfterPopupClosed.length.should.eql(1)
+      const currentWindowHandle = await wd.grabCurrentWindowHandle()
+      currentWindowHandle.should.eql(handleBeforePopup)
+    })
+  })
 
   describe('#waitForClickable', () => {
     it('should wait for clickable', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: 'input#text' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: 'input#text' })
+    })
 
     it('should wait for clickable by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/input[@id="text"]' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ xpath: './/input[@id="text"]' })
+    })
 
     it('should fail for disabled element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #button still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #button still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for disabled element by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/button[@id="button"]' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ xpath: './/button[@id="button"]' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by top', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportTop' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportTop' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by bottom', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportBottom' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportBottom' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by left', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportLeft' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportLeft' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by right', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportRight' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportRight' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for overlapping element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#div2_button' }, 0.1);
-      await wd.waitForClickable({ css: '#div1_button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #div1_button still not clickable after 0.1 sec');
-      });
-    });
-  });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: '#div2_button' }, 0.1)
+      await wd
+        .waitForClickable({ css: '#div1_button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #div1_button still not clickable after 0.1 sec')
+        })
+    })
+  })
 
   describe('GeoLocation', () => {
     // deprecated JSON Wire method commands
     it.skip('should set the geoLocation', async () => {
-      await wd.setGeoLocation(37.4043, -122.0748);
-      const geoLocation = await wd.grabGeoLocation();
-      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set');
-      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set');
-    });
-  });
+      await wd.setGeoLocation(37.4043, -122.0748)
+      const geoLocation = await wd.grabGeoLocation()
+      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set')
+      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set')
+    })
+  })
 
   describe('#grabElementBoundingRect', () => {
     it('should get the element size', async () => {
-      await wd.amOnPage('/form/hidden');
-      const size = await wd.grabElementBoundingRect('input[type=submit]');
-      expect(size.x).is.greaterThan(0);
-      expect(size.y).is.greaterThan(0);
-      expect(size.width).is.greaterThan(0);
-      expect(size.height).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const size = await wd.grabElementBoundingRect('input[type=submit]')
+      expect(size.x).is.greaterThan(0)
+      expect(size.y).is.greaterThan(0)
+      expect(size.width).is.greaterThan(0)
+      expect(size.height).is.greaterThan(0)
+    })
 
     it('should get the element width', async () => {
-      await wd.amOnPage('/form/hidden');
-      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width');
-      expect(width).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width')
+      expect(width).is.greaterThan(0)
+    })
 
     it('should get the element height', async () => {
-      await wd.amOnPage('/form/hidden');
-      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height');
-      expect(height).is.greaterThan(0);
-    });
-  });
+      await wd.amOnPage('/form/hidden')
+      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height')
+      expect(height).is.greaterThan(0)
+    })
+  })
 
   describe('#scrollIntoView', () => {
     it.skip('should scroll element into viewport', async () => {
-      await wd.amOnPage('/form/scroll_into_view');
-      const element = await wd.browser.$('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.false;
-      await wd.scrollIntoView('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.true;
-    });
-  });
+      await wd.amOnPage('/form/scroll_into_view')
+      const element = await wd.browser.$('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.false
+      await wd.scrollIntoView('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.true
+    })
+  })
 
   describe('#useWebDriverTo', () => {
     it('should return title', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       const title = await wd.useWebDriverTo('test', async ({ browser }) => {
-        return browser.getTitle();
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
-  });
-});
+        return browser.getTitle()
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
+  })
+})
 
 describe('WebDriver - Basic Authentication', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     try {
-      fs.unlinkSync(dataFile);
+      fs.unlinkSync(dataFile)
     } catch (err) {
       // continue regardless of error
     }
@@ -1230,19 +1281,19 @@ describe('WebDriver - Basic Authentication', () => {
           args: ['--headless', '--disable-gpu', '--window-size=1280,1024'],
         },
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    await wd._before();
-  });
+    await wd._before()
+  })
 
-  afterEach(() => wd._after());
+  afterEach(() => wd._after())
 
   describe('open page : #amOnPage', () => {
     it('should be authenticated', async () => {
-      await wd.amOnPage('/basic_auth');
-      await wd.see('You entered admin as your password.');
-    });
-  });
-});
+      await wd.amOnPage('/basic_auth')
+      await wd.see('You entered admin as your password.')
+    })
+  })
+})
diff --git a/test/helper/WebDriver_devtools_test.js b/test/helper/WebDriver_devtools_test.js
index 92298f406..84dad90a1 100644
--- a/test/helper/WebDriver_devtools_test.js
+++ b/test/helper/WebDriver_devtools_test.js
@@ -1,35 +1,35 @@
-const assert = require('assert');
+const assert = require('assert')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
-const fs = require('fs');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
+const fs = require('fs')
 
-const TestHelper = require('../support/TestHelper');
-const WebDriver = require('../../lib/helper/WebDriver');
-const AssertionFailedError = require('../../lib/assert/error');
-const webApiTests = require('./webapi');
-const Secret = require('../../lib/secret');
-global.codeceptjs = require('../../lib');
+const TestHelper = require('../support/TestHelper')
+const WebDriver = require('../../lib/helper/WebDriver')
+const AssertionFailedError = require('../../lib/assert/error')
+const webApiTests = require('./webapi')
+const Secret = require('../../lib/secret')
+global.codeceptjs = require('../../lib')
 
-const siteUrl = TestHelper.siteUrl();
-let wd;
+const siteUrl = TestHelper.siteUrl()
+let wd
 
 describe('WebDriver - Devtools Protocol', function () {
-  this.retries(1);
-  this.timeout(35000);
+  this.retries(1)
+  this.timeout(35000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     try {
-      fs.unlinkSync(dataFile);
+      fs.unlinkSync(dataFile)
     } catch (err) {
       // continue regardless of error
     }
 
-    process.env.DevTools = 'true';
+    process.env.DevTools = 'true'
 
     wd = new WebDriver({
       url: siteUrl,
@@ -43,592 +43,602 @@ describe('WebDriver - Devtools Protocol', function () {
         },
       },
       customLocatorStrategies: {
-        customSelector: (selector) => (
-          { 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }
-        ),
+        customSelector: (selector) => ({ 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }),
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    webApiTests.init({ I: wd, siteUrl });
-    this.wdBrowser = await wd._before();
-    return this.wdBrowser;
-  });
+    webApiTests.init({ I: wd, siteUrl })
+    this.wdBrowser = await wd._before()
+    return this.wdBrowser
+  })
 
-  afterEach(async () => wd._after());
+  afterEach(async () => wd._after())
 
   // load common test suite
-  webApiTests.tests();
+  webApiTests.tests()
 
   describe('customLocatorStrategies', () => {
     it('should locate through custom selector', async () => {
-      const el = await this.wdBrowser.custom$('customSelector', '.test');
-      expect(el.elementId).to.equal('.test-foobar');
-    });
+      const el = await this.wdBrowser.custom$('customSelector', '.test')
+      expect(el.elementId).to.equal('.test-foobar')
+    })
 
     it('should include the custom strategy', async () => {
-      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined;
-    });
+      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined
+    })
 
     it('should be added to the browser locator strategies', async () => {
-      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined;
-    });
+      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined
+    })
 
     it('throws on invalid custom selector', async () => {
       try {
-        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2);
+        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2)
       } catch (e) {
-        expect(e.message).to.include('Please define "customLocatorStrategies"');
+        expect(e.message).to.include('Please define "customLocatorStrategies"')
       }
-    });
-  });
+    })
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await wd.amOnPage('/');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
+      await wd.amOnPage('/')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
 
     it('should open any page of configured site', async () => {
-      await wd.amOnPage('/info');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/info`);
-    });
+      await wd.amOnPage('/info')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await wd.amOnPage(siteUrl);
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
-  });
+      await wd.amOnPage(siteUrl)
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
+  })
 
   describe('see text : #see', () => {
     it('should fail when text is not on site', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.see('Something incredible!');
+        await wd.see('Something incredible!')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
 
       try {
-        await wd.dontSee('Welcome');
+        await wd.dontSee('Welcome')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
-    });
-  });
+    })
+  })
 
   describe('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
     it('should throw error if field is not empty', async () => {
-      await wd.amOnPage('/form/empty');
+      await wd.amOnPage('/form/empty')
 
       try {
-        await wd.seeInField('#empty_input', 'Ayayay');
+        await wd.seeInField('#empty_input', 'Ayayay')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"')
       }
-    });
+    })
 
     it('should check values in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', 'not seen one');
-      await wd.seeInField('checkbox[]', 'see test one');
-      await wd.dontSeeInField('checkbox[]', 'not seen two');
-      await wd.seeInField('checkbox[]', 'see test two');
-      await wd.dontSeeInField('checkbox[]', 'not seen three');
-      await wd.seeInField('checkbox[]', 'see test three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', 'not seen one')
+      await wd.seeInField('checkbox[]', 'see test one')
+      await wd.dontSeeInField('checkbox[]', 'not seen two')
+      await wd.seeInField('checkbox[]', 'see test two')
+      await wd.dontSeeInField('checkbox[]', 'not seen three')
+      await wd.seeInField('checkbox[]', 'see test three')
+    })
 
     it('should check values are the secret type in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test one'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test two'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test three'));
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test one'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test two'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test three'))
+    })
 
     it('should check values with boolean', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('checkbox1', true);
-      await wd.dontSeeInField('checkbox1', false);
-      await wd.seeInField('checkbox2', false);
-      await wd.dontSeeInField('checkbox2', true);
-      await wd.seeInField('radio2', true);
-      await wd.dontSeeInField('radio2', false);
-      await wd.seeInField('radio3', false);
-      await wd.dontSeeInField('radio3', true);
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('checkbox1', true)
+      await wd.dontSeeInField('checkbox1', false)
+      await wd.seeInField('checkbox2', false)
+      await wd.dontSeeInField('checkbox2', true)
+      await wd.seeInField('radio2', true)
+      await wd.dontSeeInField('radio2', false)
+      await wd.seeInField('radio3', false)
+      await wd.dontSeeInField('radio3', true)
+    })
 
     it('should check values in radio', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('radio1', 'see test one');
-      await wd.dontSeeInField('radio1', 'not seen one');
-      await wd.dontSeeInField('radio1', 'not seen two');
-      await wd.dontSeeInField('radio1', 'not seen three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('radio1', 'see test one')
+      await wd.dontSeeInField('radio1', 'not seen one')
+      await wd.dontSeeInField('radio1', 'not seen two')
+      await wd.dontSeeInField('radio1', 'not seen three')
+    })
 
     it('should return error when element has no value attribute', async () => {
-      await wd.amOnPage('https://codecept.io/quickstart');
+      await wd.amOnPage('https://codecept.io/quickstart')
 
       try {
-        await wd.seeInField('#search_input_react', 'WebDriver1');
+        await wd.seeInField('#search_input_react', 'WebDriver1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
+        e.should.be.instanceOf(Error)
       }
-    });
-  });
+    })
+  })
 
   describe('Force Right Click: #forceRightClick', () => {
     it('it should forceRightClick', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('.context a');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('.context a')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator and context', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum', '.context');
-      await wd.see('right clicked');
-    });
-  });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum', '.context')
+      await wd.see('right clicked')
+    })
+  })
 
   describe.skip('#pressKey, #pressKeyDown, #pressKeyUp', () => {
     it('should be able to send special keys to element', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.appendField('Name', '-');
+      await wd.amOnPage('/form/field')
+      await wd.appendField('Name', '-')
 
-      await wd.pressKey(['Right Shift', 'Home']);
-      await wd.pressKey('Delete');
+      await wd.pressKey(['Right Shift', 'Home'])
+      await wd.pressKey('Delete')
 
       // Sequence only executes up to first non-modifier key ('Digit1')
-      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4']);
-      await wd.pressKey('1');
-      await wd.pressKey('2');
-      await wd.pressKey('3');
-      await wd.pressKey('ArrowLeft');
-      await wd.pressKey('Left Arrow');
-      await wd.pressKey('arrow_left');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('a');
-      await wd.pressKey('KeyB');
-      await wd.pressKeyUp('ShiftLeft');
-      await wd.pressKey('C');
-      await wd.seeInField('Name', '!ABC123');
-    });
+      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4'])
+      await wd.pressKey('1')
+      await wd.pressKey('2')
+      await wd.pressKey('3')
+      await wd.pressKey('ArrowLeft')
+      await wd.pressKey('Left Arrow')
+      await wd.pressKey('arrow_left')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('a')
+      await wd.pressKey('KeyB')
+      await wd.pressKeyUp('ShiftLeft')
+      await wd.pressKey('C')
+      await wd.seeInField('Name', '!ABC123')
+    })
 
     it('should use modifier key based on operating system', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', 'value that is cleared using select all shortcut');
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', 'value that is cleared using select all shortcut')
 
-      await wd.pressKey(['CommandOrControl', 'A']);
-      await wd.pressKey('Backspace');
-      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut');
-    });
+      await wd.pressKey(['CommandOrControl', 'A'])
+      await wd.pressKey('Backspace')
+      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut')
+    })
 
     it('should show correct numpad or punctuation key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey(';');
-      await wd.pressKey(['Shift', ';']);
-      await wd.pressKey(['Shift', 'Semicolon']);
-      await wd.pressKey('=');
-      await wd.pressKey(['Shift', '=']);
-      await wd.pressKey(['Shift', 'Equal']);
-      await wd.pressKey('*');
-      await wd.pressKey(['Shift', '*']);
-      await wd.pressKey(['Shift', 'Multiply']);
-      await wd.pressKey('+');
-      await wd.pressKey(['Shift', '+']);
-      await wd.pressKey(['Shift', 'Add']);
-      await wd.pressKey(',');
-      await wd.pressKey(['Shift', ',']);
-      await wd.pressKey(['Shift', 'Comma']);
-      await wd.pressKey(['Shift', 'NumpadComma']);
-      await wd.pressKey(['Shift', 'Separator']);
-      await wd.pressKey('-');
-      await wd.pressKey(['Shift', '-']);
-      await wd.pressKey(['Shift', 'Subtract']);
-      await wd.pressKey('.');
-      await wd.pressKey(['Shift', '.']);
-      await wd.pressKey(['Shift', 'Decimal']);
-      await wd.pressKey(['Shift', 'Period']);
-      await wd.pressKey('/');
-      await wd.pressKey(['Shift', '/']);
-      await wd.pressKey(['Shift', 'Divide']);
-      await wd.pressKey(['Shift', 'Slash']);
-
-      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?');
-    });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey(';')
+      await wd.pressKey(['Shift', ';'])
+      await wd.pressKey(['Shift', 'Semicolon'])
+      await wd.pressKey('=')
+      await wd.pressKey(['Shift', '='])
+      await wd.pressKey(['Shift', 'Equal'])
+      await wd.pressKey('*')
+      await wd.pressKey(['Shift', '*'])
+      await wd.pressKey(['Shift', 'Multiply'])
+      await wd.pressKey('+')
+      await wd.pressKey(['Shift', '+'])
+      await wd.pressKey(['Shift', 'Add'])
+      await wd.pressKey(',')
+      await wd.pressKey(['Shift', ','])
+      await wd.pressKey(['Shift', 'Comma'])
+      await wd.pressKey(['Shift', 'NumpadComma'])
+      await wd.pressKey(['Shift', 'Separator'])
+      await wd.pressKey('-')
+      await wd.pressKey(['Shift', '-'])
+      await wd.pressKey(['Shift', 'Subtract'])
+      await wd.pressKey('.')
+      await wd.pressKey(['Shift', '.'])
+      await wd.pressKey(['Shift', 'Decimal'])
+      await wd.pressKey(['Shift', 'Period'])
+      await wd.pressKey('/')
+      await wd.pressKey(['Shift', '/'])
+      await wd.pressKey(['Shift', 'Divide'])
+      await wd.pressKey(['Shift', 'Slash'])
+
+      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?')
+    })
 
     it('should show correct number key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey('0');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('0');
-      await wd.pressKey('Digit0');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('1');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('1');
-      await wd.pressKey('Digit1');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('2');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('2');
-      await wd.pressKey('Digit2');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('3');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('3');
-      await wd.pressKey('Digit3');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('4');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('4');
-      await wd.pressKey('Digit4');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('5');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('5');
-      await wd.pressKey('Digit5');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('6');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('6');
-      await wd.pressKey('Digit6');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('7');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('7');
-      await wd.pressKey('Digit7');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('8');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('8');
-      await wd.pressKey('Digit8');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('9');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('9');
-      await wd.pressKey('Digit9');
-      await wd.pressKeyUp('Shift');
-
-      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((');
-    });
-  });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey('0')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('0')
+      await wd.pressKey('Digit0')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('1')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('1')
+      await wd.pressKey('Digit1')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('2')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('2')
+      await wd.pressKey('Digit2')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('3')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('3')
+      await wd.pressKey('Digit3')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('4')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('4')
+      await wd.pressKey('Digit4')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('5')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('5')
+      await wd.pressKey('Digit5')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('6')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('6')
+      await wd.pressKey('Digit6')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('7')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('7')
+      await wd.pressKey('Digit7')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('8')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('8')
+      await wd.pressKey('Digit8')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('9')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('9')
+      await wd.pressKey('Digit9')
+      await wd.pressKeyUp('Shift')
+
+      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((')
+    })
+  })
 
   describe('#seeInSource, #grabSource', () => {
     it('should check for text to be in HTML source', async () => {
-      await wd.amOnPage('/');
-      await wd.seeInSource('<title>TestEd Beta 2.0</title>');
-      await wd.dontSeeInSource('<meta');
-    });
+      await wd.amOnPage('/')
+      await wd.seeInSource('<title>TestEd Beta 2.0</title>')
+      await wd.dontSeeInSource('<meta')
+    })
 
     it('should grab the source', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabSource();
-      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved');
-    });
+      await wd.amOnPage('/')
+      const source = await wd.grabSource()
+      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved')
+    })
 
     it('should grab the innerHTML for an element', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabHTMLFrom('#area1');
+      await wd.amOnPage('/')
+      const source = await wd.grabHTMLFrom('#area1')
       assert.deepEqual(
         source,
         `
     <a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>
 `,
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('#seeTitleEquals', () => {
     it('should check that title is equal to provided one', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.seeTitleEquals('TestEd Beta 2.0');
-        await wd.seeTitleEquals('TestEd Beta 2.');
+        await wd.seeTitleEquals('TestEd Beta 2.0')
+        await wd.seeTitleEquals('TestEd Beta 2.')
       } catch (e) {
-        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0');
+        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeTextEquals', () => {
     it('should check text is equal to provided one', async () => {
-      await wd.amOnPage('/');
-      await wd.seeTextEquals('Welcome to test app!', 'h1');
+      await wd.amOnPage('/')
+      await wd.seeTextEquals('Welcome to test app!', 'h1')
 
       try {
-        await wd.seeTextEquals('Welcome to test app', 'h1');
-        assert.equal(true, false, 'Throw an error because it should not get this far!');
+        await wd.seeTextEquals('Welcome to test app', 'h1')
+        assert.equal(true, false, 'Throw an error because it should not get this far!')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"')
         // e.should.be.instanceOf(AssertionFailedError);
       }
-    });
+    })
 
     it('should check text is not equal to empty string of element text', async () => {
-      await wd.amOnPage('https://codecept.io');
+      await wd.amOnPage('https://codecept.io')
 
       try {
-        await wd.seeTextEquals('', '.logo');
-        await wd.seeTextEquals('This is not empty', '.logo');
+        await wd.seeTextEquals('', '.logo')
+        await wd.seeTextEquals('This is not empty', '.logo')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""')
       }
-    });
-  });
+    })
+  })
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(() => window.__waitJs, 3);
-    });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction(() => window.__waitJs, 3)
+    })
 
     it('should pass arguments and wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(varName => window[varName], ['__waitJs'], 3);
-    });
-  });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction((varName) => window[varName], ['__waitJs'], 3)
+    })
+  })
 
   describe('#waitForEnabled', () => {
     it('should wait for input text field to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for input text field to be enabled by xpath', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled("//*[@name = 'test']", 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled("//*[@name = 'test']", 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for a button to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.click('#button');
-      await wd.see('button was clicked');
-    });
-  });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.click('#button')
+      await wd.see('button was clicked')
+    })
+  })
 
   describe('#waitForValue', () => {
     it('should wait for expected value for given locator', async () => {
-      await wd.amOnPage('/info');
-      await wd.waitForValue('//input[@name= "rus"]', 'Верно');
+      await wd.amOnPage('/info')
+      await wd.waitForValue('//input[@name= "rus"]', 'Верно')
 
       try {
-        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1);
-        throw Error('It should never get this far');
+        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1)
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec');
+        e.message.should.include(
+          'element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec',
+        )
       }
-    });
+    })
 
     it('should wait for expected value for given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('#text', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('#text', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should wait for expected value for given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should only wait for one of the matching elements to contain the value given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
 
     it('should only wait for one of the matching elements to contain the value given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('.inputbox', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
-  });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('.inputbox', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
+  })
 
   describe('#waitNumberOfVisibleElements', () => {
     it('should wait for a specified number of elements on the page', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3))
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements({ css: '//div[@id = "grab-multiple"]//a' }, 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified number of elements on the page using a css selector', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 3))
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should wait for a specified number of elements which are not yet attached to the DOM', () => {
-      return wd.amOnPage('/form/wait_num_elements')
+      return wd
+        .amOnPage('/form/wait_num_elements')
         .then(() => wd.waitNumberOfVisibleElements('.title', 2, 3))
         .then(() => wd.see('Hello'))
-        .then(() => wd.see('World'));
-    });
+        .then(() => wd.see('World'))
+    })
 
     it('should wait for 0 number of visible elements', async () => {
-      await wd.amOnPage('/form/wait_invisible');
-      await wd.waitNumberOfVisibleElements('#step_1', 0);
-    });
-  });
+      await wd.amOnPage('/form/wait_invisible')
+      await wd.waitNumberOfVisibleElements('#step_1', 0)
+    })
+  })
 
   describe('#waitForVisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForVisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
-  });
+          e.message.should.not.include('[object Object]')
+        })
+    })
+  })
 
   describe('#waitForInvisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForInvisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified element to be invisible', () => {
-      return wd.amOnPage('/form/wait_invisible')
+      return wd
+        .amOnPage('/form/wait_invisible')
         .then(() => wd.waitForInvisible('#step1', 3))
-        .then(() => wd.dontSeeElement('#step1'));
-    });
-  });
+        .then(() => wd.dontSeeElement('#step1'))
+    })
+  })
 
   describe('#moveCursorTo', () => {
     it('should trigger hover event', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover');
-      await wd.see('Hovered', '#show');
-    });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover')
+      await wd.see('Hovered', '#show')
+    })
 
     it('should not trigger hover event because of the offset is beyond the element', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover', 120, 120);
-      await wd.dontSee('Hovered!', '#show');
-    });
-  });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover', 120, 120)
+      await wd.dontSee('Hovered!', '#show')
+    })
+  })
 
   describe('#switchToNextTab, #switchToPreviousTab, #openNewTab, #closeCurrentTab, #closeOtherTabs, #grabNumberOfOpenTabs', () => {
     it('should only have 1 tab open when the browser starts and navigates to the first page', async () => {
-      await wd.amOnPage('/');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
-    });
+      await wd.amOnPage('/')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
+    })
 
     it('should switch to next tab', async () => {
-      wd.amOnPage('/info');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
+      wd.amOnPage('/info')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
 
-      await wd.click('New tab');
-      await wd.switchToNextTab();
-      await wd.waitInUrl('/login');
-      const numPagesAfter = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPagesAfter, 2);
-    });
+      await wd.click('New tab')
+      await wd.switchToNextTab()
+      await wd.waitInUrl('/login')
+      const numPagesAfter = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPagesAfter, 2)
+    })
 
     it('should assert when there is no ability to switch to next tab', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.click('More info'))
         .then(() => wd.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
         .then(() => wd.switchToNextTab(2))
         .then(() => assert.equal(true, false, 'Throw an error if it gets this far (which it should not)!'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2');
-        });
-    });
+          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2')
+        })
+    })
 
     it('should close current tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.click('New tab'))
         .then(() => wd.switchToNextTab())
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2))
+        .then((numPages) => assert.equal(numPages, 2))
         .then(() => wd.closeCurrentTab())
         .then(() => wd.seeInCurrentUrl('/info'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should close other tabs', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.openNewTab())
         .then(() => wd.seeInCurrentUrl('about:blank'))
         .then(() => wd.amOnPage('/info'))
@@ -637,564 +647,605 @@ describe('WebDriver - Devtools Protocol', function () {
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.closeOtherTabs())
         .then(() => wd.seeInCurrentUrl('/login'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should open new tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2));
-    });
+        .then((numPages) => assert.equal(numPages, 2))
+    })
 
     it('should switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab())
-        .then(() => wd.waitInUrl('/info'));
-    });
+        .then(() => wd.waitInUrl('/info'))
+    })
 
     it('should assert when there is no ability to switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab(2))
         .then(() => wd.waitInUrl('/info'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2');
-        });
-    });
-  });
+          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2')
+        })
+    })
+  })
 
   describe('popup : #acceptPopup, #seeInPopup, #cancelPopup', () => {
     it('should accept popup window', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.acceptPopup())
-        .then(() => wd.see('Yes', '#result'));
-    });
+        .then(() => wd.see('Yes', '#result'))
+    })
 
     it('should cancel popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.cancelPopup())
-        .then(() => wd.see('No', '#result'));
-    });
+        .then(() => wd.see('No', '#result'))
+    })
 
     it('should check text in popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.seeInPopup('Really?'))
-        .then(() => wd.cancelPopup());
-    });
+        .then(() => wd.cancelPopup())
+    })
 
     it('should grab text from popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, 'Really?'));
-    });
+        .then((text) => assert.equal(text, 'Really?'))
+    })
 
     it('should return null if no popup is visible (do not throw an error)', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, null));
-    });
-  });
+        .then((text) => assert.equal(text, null))
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Nothing here', 1, '#text'))
         .catch((e) => {
-          e.message.should.be.equal('element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec');
-        });
-    });
+          e.message.should.be.equal(
+            'element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec',
+          )
+        })
+    })
 
     it('should return error if waiting is too small', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Dynamic text', 0.1))
         .catch((e) => {
-          e.message.should.be.equal('element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec');
-        });
-    });
-  });
+          e.message.should.be.equal(
+            'element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec',
+          )
+        })
+    })
+  })
 
   describe('#seeNumberOfElements', () => {
     it('should return 1 as count', async () => {
-      await wd.amOnPage('/');
-      await wd.seeNumberOfElements('#area1', 1);
-    });
-  });
+      await wd.amOnPage('/')
+      await wd.seeNumberOfElements('#area1', 1)
+    })
+  })
 
   describe.skip('#switchTo', () => {
     it('should switch reference to iframe content', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+    })
 
     it('should return error if iframe selector is invalid', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('#invalidIframeSelector');
+        await wd.switchTo('#invalidIframeSelector')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
       }
-    });
+    })
 
     it('should return error if iframe selector is not iframe', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('h1');
+        await wd.switchTo('h1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.contain('no such frame');
+        e.should.be.instanceOf(Error)
+        e.message.should.contain('no such frame')
       }
-    });
+    })
 
     it('should return to parent frame given a null locator', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-      await wd.switchTo(null);
-      await wd.see('Iframe test');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+      await wd.switchTo(null)
+      await wd.see('Iframe test')
+    })
+  })
 
   describe('click context', () => {
     it('should click on inner text', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//input[@type = "submit"]');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//input[@type = "submit"]')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click on input in inner element', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//form');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//form')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click by accessibility_id', async () => {
-      await wd.amOnPage('/info');
-      await wd.click('~index via aria-label');
-      await wd.see('Welcome to test app!');
-    });
-  });
+      await wd.amOnPage('/info')
+      await wd.click('~index via aria-label')
+      await wd.see('Welcome to test app!')
+    })
+  })
 
   describe('window size #resizeWindow', () => {
     it('should set initial window size', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.click('Window Size');
-      await wd.see('Height 700', '#height');
-      await wd.see('Width 500', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.click('Window Size')
+      await wd.see('Height 700', '#height')
+      await wd.see('Width 500', '#width')
+    })
 
     it('should set window size on new session', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd._session())
-        .then(session => session.start()
-          .then(browser => ({
+        .then((session) =>
+          session.start().then((browser) => ({
             browser,
             session,
-          })))
+          })),
+        )
         .then(({ session, browser }) => session.loadVars(browser))
         .then(() => wd.amOnPage('/form/resize'))
         .then(() => wd.click('Window Size'))
         .then(() => wd.see('Height 700', '#height'))
-        .then(() => wd.see('Width 500', '#width'));
-    });
+        .then(() => wd.see('Width 500', '#width'))
+    })
 
     it.skip('should resize window to specific dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(950, 600);
-      await wd.click('Window Size');
-      await wd.see('Height 600', '#height');
-      await wd.see('Width 950', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(950, 600)
+      await wd.click('Window Size')
+      await wd.see('Height 600', '#height')
+      await wd.see('Width 950', '#width')
+    })
 
     xit('should resize window to maximum screen dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(500, 400);
-      await wd.click('Window Size');
-      await wd.see('Height 400', '#height');
-      await wd.see('Width 500', '#width');
-      await wd.resizeWindow('maximize');
-      await wd.click('Window Size');
-      await wd.dontSee('Height 400', '#height');
-      await wd.dontSee('Width 500', '#width');
-    });
-  });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(500, 400)
+      await wd.click('Window Size')
+      await wd.see('Height 400', '#height')
+      await wd.see('Width 500', '#width')
+      await wd.resizeWindow('maximize')
+      await wd.click('Window Size')
+      await wd.dontSee('Height 400', '#height')
+      await wd.dontSee('Width 500', '#width')
+    })
+  })
 
   describe('SmartWait', () => {
-    before(() => wd.options.smartWait = 3000);
-    after(() => wd.options.smartWait = 0);
+    before(() => (wd.options.smartWait = 3000))
+    after(() => (wd.options.smartWait = 0))
 
     it('should wait for element to appear', async () => {
-      await wd.amOnPage('/form/wait_element');
-      await wd.dontSeeElement('h1');
-      await wd.seeElement('h1');
-    });
+      await wd.amOnPage('/form/wait_element')
+      await wd.dontSeeElement('h1')
+      await wd.seeElement('h1')
+    })
 
     it('should wait for clickable element appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#click');
-      await wd.click('#click');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#click')
+      await wd.click('#click')
+      await wd.see('Hi!')
+    })
 
     it('should wait for clickable context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#linkContext');
-      await wd.click('Hello world', '#linkContext');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#linkContext')
+      await wd.click('Hello world', '#linkContext')
+      await wd.see('Hi!')
+    })
 
     it('should wait for text context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      await wd.see('Hello world', '#linkContext');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      await wd.see('Hello world', '#linkContext')
+    })
 
     it('should work with grabbers', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      const res = await wd.grabAttributeFrom('#click', 'id');
-      assert.equal(res, 'click');
-    });
-  });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      const res = await wd.grabAttributeFrom('#click', 'id')
+      assert.equal(res, 'click')
+    })
+  })
 
   describe('#_locateClickable', () => {
     it('should locate a button to click', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('Submit');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('Submit')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateCheckable', () => {
     it('should locate a checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I Agree');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I Agree')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateFields', () => {
     it('should locate a field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Name');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Name')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Mother-in-law');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Mother-in-law')
+      res.length.should.be.equal(0)
+    })
+  })
 
   xdescribe('#grabBrowserLogs', () => {
     it('should grab browser logs', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry');
-      });
-      const logs = await wd.grabBrowserLogs();
-      console.log('lololo', logs);
+        console.log('Test log entry')
+      })
+      const logs = await wd.grabBrowserLogs()
+      console.log('lololo', logs)
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 1);
-    });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 1)
+    })
 
     it('should grab browser logs across pages', async () => {
-      wd.amOnPage('/');
+      wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry 1');
-      });
-      await wd.openNewTab();
-      await wd.amOnPage('/info');
+        console.log('Test log entry 1')
+      })
+      await wd.openNewTab()
+      await wd.amOnPage('/info')
       await wd.executeScript(() => {
-        console.log('Test log entry 2');
-      });
+        console.log('Test log entry 2')
+      })
 
-      const logs = await wd.grabBrowserLogs();
+      const logs = await wd.grabBrowserLogs()
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 2);
-    });
-  });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 2)
+    })
+  })
 
   describe('#dragAndDrop', () => {
     it('Drag item from source to target (no iframe) @dragNdrop', async () => {
-      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
+      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
 
     it.skip('Drag and drop from within an iframe', async () => {
-      await wd.amOnPage('http://jqueryui.com/droppable');
-      await wd.resizeWindow(700, 700);
-      await wd.switchTo('//iframe[@class="demo-frame"]');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
-  });
+      await wd.amOnPage('http://jqueryui.com/droppable')
+      await wd.resizeWindow(700, 700)
+      await wd.switchTo('//iframe[@class="demo-frame"]')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
+  })
 
   describe('#switchTo frame', () => {
     it('should switch to frame using name', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
 
     it('should switch to root frame', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-      await wd.switchTo();
-      await wd.see('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+      await wd.switchTo()
+      await wd.see('Iframe test', 'h1')
+    })
 
     it('should switch to frame using frame number', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo(0);
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo(0)
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
+  })
 
   describe('#AttachFile', () => {
     it('should attach to regular input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('Avatar', './app/avatar.jpg');
-      await wd.seeInField('Avatar', 'avatar.jpg');
-    });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('Avatar', './app/avatar.jpg')
+      await wd.seeInField('Avatar', 'avatar.jpg')
+    })
 
     it('should attach to invisible input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('hidden', '/app/avatar.jpg');
-    });
-  });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('hidden', '/app/avatar.jpg')
+    })
+  })
 
   describe('#dragSlider', () => {
     it('should drag scrubber to given position', async () => {
-      await wd.amOnPage('/form/page_slider');
-      await wd.seeElementInDOM('#slidecontainer input');
+      await wd.amOnPage('/form/page_slider')
+      await wd.seeElementInDOM('#slidecontainer input')
 
-      const before = await wd.grabValueFrom('#slidecontainer input');
-      await wd.dragSlider('#slidecontainer input', 20);
-      const after = await wd.grabValueFrom('#slidecontainer input');
+      const before = await wd.grabValueFrom('#slidecontainer input')
+      await wd.dragSlider('#slidecontainer input', 20)
+      const after = await wd.grabValueFrom('#slidecontainer input')
 
-      assert.notEqual(before, after);
-    });
-  });
+      assert.notEqual(before, after)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
 
     it('should NOT uncheck option that is NOT currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
       // Unchecking again should not affect the current 'unchecked' status
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('allow back and forth between handles: #grabAllWindowHandles #grabCurrentWindowHandle #switchToWindow', () => {
     it.skip('should open main page of configured site, open a popup, switch to main page, then switch to popup, close popup, and go back to main page', async () => {
-      await wd.amOnPage('/');
-      const handleBeforePopup = await wd.grabCurrentWindowHandle();
-      const urlBeforePopup = await wd.grabCurrentUrl();
+      await wd.amOnPage('/')
+      const handleBeforePopup = await wd.grabCurrentWindowHandle()
+      const urlBeforePopup = await wd.grabCurrentUrl()
 
-      const allHandlesBeforePopup = await wd.grabAllWindowHandles();
-      allHandlesBeforePopup.length.should.eql(1);
+      const allHandlesBeforePopup = await wd.grabAllWindowHandles()
+      allHandlesBeforePopup.length.should.eql(1)
 
       await wd.executeScript(() => {
-        window.open('https://www.w3schools.com/', 'new window', 'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400');
-      });
-
-      const allHandlesAfterPopup = await wd.grabAllWindowHandles();
-      allHandlesAfterPopup.length.should.eql(1);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterPopup = await wd.grabCurrentUrl();
-      urlAfterPopup.should.eql('https://www.w3schools.com/');
-
-      handleBeforePopup.should.eql(allHandlesAfterPopup[0]);
-      await wd.switchToWindow(handleBeforePopup);
-      const currentURL = await wd.grabCurrentUrl();
-      currentURL.should.eql(urlBeforePopup);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterSwitchBack = await wd.grabCurrentUrl();
-      urlAfterSwitchBack.should.eql('https://www.w3schools.com/');
-      await wd.closeCurrentTab();
-
-      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles();
-      allHandlesAfterPopupClosed.length.should.eql(1);
-      const currentWindowHandle = await wd.grabCurrentWindowHandle();
-      currentWindowHandle.should.eql(handleBeforePopup);
-    });
-  });
+        window.open(
+          'https://www.w3schools.com/',
+          'new window',
+          'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400',
+        )
+      })
+
+      const allHandlesAfterPopup = await wd.grabAllWindowHandles()
+      allHandlesAfterPopup.length.should.eql(1)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterPopup = await wd.grabCurrentUrl()
+      urlAfterPopup.should.eql('https://www.w3schools.com/')
+
+      handleBeforePopup.should.eql(allHandlesAfterPopup[0])
+      await wd.switchToWindow(handleBeforePopup)
+      const currentURL = await wd.grabCurrentUrl()
+      currentURL.should.eql(urlBeforePopup)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterSwitchBack = await wd.grabCurrentUrl()
+      urlAfterSwitchBack.should.eql('https://www.w3schools.com/')
+      await wd.closeCurrentTab()
+
+      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles()
+      allHandlesAfterPopupClosed.length.should.eql(1)
+      const currentWindowHandle = await wd.grabCurrentWindowHandle()
+      currentWindowHandle.should.eql(handleBeforePopup)
+    })
+  })
 
   describe('#waitForClickable', () => {
     it('should wait for clickable', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: 'input#text' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: 'input#text' })
+    })
 
     it('should wait for clickable by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/input[@id="text"]' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ xpath: './/input[@id="text"]' })
+    })
 
     it('should fail for disabled element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #button still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #button still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for disabled element by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/button[@id="button"]' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ xpath: './/button[@id="button"]' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by top', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportTop' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportTop' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by bottom', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportBottom' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportBottom' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by left', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportLeft' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportLeft' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by right', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportRight' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportRight' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for overlapping element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#div2_button' }, 0.1);
-      await wd.waitForClickable({ css: '#div1_button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #div1_button still not clickable after 0.1 sec');
-      });
-    });
-  });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: '#div2_button' }, 0.1)
+      await wd
+        .waitForClickable({ css: '#div1_button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #div1_button still not clickable after 0.1 sec')
+        })
+    })
+  })
 
   describe('GeoLocation', () => {
     it('should set the geoLocation', async () => {
-      await wd.setGeoLocation(37.4043, -122.0748);
-      const geoLocation = await wd.grabGeoLocation();
-      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set');
-      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set');
-    });
-  });
+      await wd.setGeoLocation(37.4043, -122.0748)
+      const geoLocation = await wd.grabGeoLocation()
+      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set')
+      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set')
+    })
+  })
 
   describe('#grabElementBoundingRect', () => {
     it('should get the element size', async () => {
-      await wd.amOnPage('/form/hidden');
-      const size = await wd.grabElementBoundingRect('input[type=submit]');
-      expect(size.x).is.greaterThan(0);
-      expect(size.y).is.greaterThan(0);
-      expect(size.width).is.greaterThan(0);
-      expect(size.height).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const size = await wd.grabElementBoundingRect('input[type=submit]')
+      expect(size.x).is.greaterThan(0)
+      expect(size.y).is.greaterThan(0)
+      expect(size.width).is.greaterThan(0)
+      expect(size.height).is.greaterThan(0)
+    })
 
     it('should get the element width', async () => {
-      await wd.amOnPage('/form/hidden');
-      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width');
-      expect(width).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width')
+      expect(width).is.greaterThan(0)
+    })
 
     it('should get the element height', async () => {
-      await wd.amOnPage('/form/hidden');
-      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height');
-      expect(height).is.greaterThan(0);
-    });
-  });
+      await wd.amOnPage('/form/hidden')
+      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height')
+      expect(height).is.greaterThan(0)
+    })
+  })
 
   describe('#scrollIntoView', () => {
     it.skip('should scroll element into viewport', async () => {
-      await wd.amOnPage('/form/scroll_into_view');
-      const element = await wd.browser.$('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.false;
-      await wd.scrollIntoView('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.true;
-    });
-  });
+      await wd.amOnPage('/form/scroll_into_view')
+      const element = await wd.browser.$('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.false
+      await wd.scrollIntoView('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.true
+    })
+  })
 
   describe('#useWebDriverTo', () => {
     it('should return title', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       const title = await wd.useWebDriverTo('test', async ({ browser }) => {
-        return browser.getTitle();
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
-  });
-});
+        return browser.getTitle()
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
+  })
+})
diff --git a/test/helper/WebDriver_test.js b/test/helper/WebDriver_test.js
index c8581938b..830b6c4fb 100644
--- a/test/helper/WebDriver_test.js
+++ b/test/helper/WebDriver_test.js
@@ -1,33 +1,33 @@
-const assert = require('assert');
+const assert = require('assert')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
-const fs = require('fs');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
+const fs = require('fs')
 
-const TestHelper = require('../support/TestHelper');
-const WebDriver = require('../../lib/helper/WebDriver');
-const AssertionFailedError = require('../../lib/assert/error');
-const webApiTests = require('./webapi');
-const Secret = require('../../lib/secret');
-global.codeceptjs = require('../../lib');
+const TestHelper = require('../support/TestHelper')
+const WebDriver = require('../../lib/helper/WebDriver')
+const AssertionFailedError = require('../../lib/assert/error')
+const webApiTests = require('./webapi')
+const Secret = require('../../lib/secret')
+global.codeceptjs = require('../../lib')
 
-const siteUrl = TestHelper.siteUrl();
-let wd;
+const siteUrl = TestHelper.siteUrl()
+let wd
 
-console.log('Connecting to Selenium Server', TestHelper.seleniumAddress());
-process.env.isSelenium = 'true';
+console.log('Connecting to Selenium Server', TestHelper.seleniumAddress())
+process.env.isSelenium = 'true'
 
 describe('WebDriver', function () {
-  this.retries(1);
-  this.timeout(35000);
+  this.retries(1)
+  this.timeout(35000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     try {
-      fs.unlinkSync(dataFile);
+      fs.unlinkSync(dataFile)
     } catch (err) {
       // continue regardless of error
     }
@@ -46,611 +46,621 @@ describe('WebDriver', function () {
         },
       },
       customLocatorStrategies: {
-        customSelector: (selector) => (
-          { 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }
-        ),
+        customSelector: (selector) => ({ 'element-6066-11e4-a52e-4f735466cecf': `${selector}-foobar` }),
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    webApiTests.init({ I: wd, siteUrl });
-    this.wdBrowser = await wd._before();
-    return this.wdBrowser;
-  });
+    webApiTests.init({ I: wd, siteUrl })
+    this.wdBrowser = await wd._before()
+    return this.wdBrowser
+  })
 
-  afterEach(async () => wd._after());
+  afterEach(async () => wd._after())
 
   // load common test suite
-  webApiTests.tests();
+  webApiTests.tests()
 
   describe('customLocatorStrategies', () => {
     it('should locate through custom selector', async () => {
-      const el = await this.wdBrowser.custom$('customSelector', '.test');
-      expect(el.elementId).to.equal('.test-foobar');
-    });
+      const el = await this.wdBrowser.custom$('customSelector', '.test')
+      expect(el.elementId).to.equal('.test-foobar')
+    })
 
     it('should include the custom strategy', async () => {
-      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined;
-    });
+      expect(wd.customLocatorStrategies.customSelector).to.not.be.undefined
+    })
 
     it('should be added to the browser locator strategies', async () => {
-      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined;
-    });
+      expect(this.wdBrowser.addLocatorStrategy).to.not.be.undefined
+    })
 
     it('throws on invalid custom selector', async () => {
       try {
-        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2);
+        await wd.waitForEnabled({ madeUpSelector: '#text' }, 2)
       } catch (e) {
-        expect(e.message).to.include('Please define "customLocatorStrategies"');
+        expect(e.message).to.include('Please define "customLocatorStrategies"')
       }
-    });
-  });
+    })
+  })
 
   describe('open page : #amOnPage', () => {
     it('should open main page of configured site', async () => {
-      await wd.amOnPage('/');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
+      await wd.amOnPage('/')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
 
     it('should open any page of configured site', async () => {
-      await wd.amOnPage('/info');
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/info`);
-    });
+      await wd.amOnPage('/info')
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/info`)
+    })
 
     it('should open absolute url', async () => {
-      await wd.amOnPage(siteUrl);
-      const url = await wd.grabCurrentUrl();
-      url.should.eql(`${siteUrl}/`);
-    });
-  });
+      await wd.amOnPage(siteUrl)
+      const url = await wd.grabCurrentUrl()
+      url.should.eql(`${siteUrl}/`)
+    })
+  })
 
   describe('see text : #see', () => {
     it('should fail when text is not on site', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.see('Something incredible!');
+        await wd.see('Something incredible!')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
 
       try {
-        await wd.dontSee('Welcome');
+        await wd.dontSee('Welcome')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.include('web page');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.include('web page')
       }
-    });
-  });
+    })
+  })
 
   describe('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
     it('should throw error if field is not empty', async () => {
-      await wd.amOnPage('/form/empty');
+      await wd.amOnPage('/form/empty')
 
       try {
-        await wd.seeInField('#empty_input', 'Ayayay');
+        await wd.seeInField('#empty_input', 'Ayayay')
       } catch (e) {
-        e.should.be.instanceOf(AssertionFailedError);
-        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"');
+        e.should.be.instanceOf(AssertionFailedError)
+        e.inspect().should.be.equal('expected fields by #empty_input to include "Ayayay"')
       }
-    });
+    })
 
     it('should check values in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', 'not seen one');
-      await wd.seeInField('checkbox[]', 'see test one');
-      await wd.dontSeeInField('checkbox[]', 'not seen two');
-      await wd.seeInField('checkbox[]', 'see test two');
-      await wd.dontSeeInField('checkbox[]', 'not seen three');
-      await wd.seeInField('checkbox[]', 'see test three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', 'not seen one')
+      await wd.seeInField('checkbox[]', 'see test one')
+      await wd.dontSeeInField('checkbox[]', 'not seen two')
+      await wd.seeInField('checkbox[]', 'see test two')
+      await wd.dontSeeInField('checkbox[]', 'not seen three')
+      await wd.seeInField('checkbox[]', 'see test three')
+    })
 
     it('should check values are the secret type in checkboxes', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test one'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test two'));
-      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'));
-      await wd.seeInField('checkbox[]', Secret.secret('see test three'));
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen one'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test one'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen two'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test two'))
+      await wd.dontSeeInField('checkbox[]', Secret.secret('not seen three'))
+      await wd.seeInField('checkbox[]', Secret.secret('see test three'))
+    })
 
     it('should check values with boolean', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('checkbox1', true);
-      await wd.dontSeeInField('checkbox1', false);
-      await wd.seeInField('checkbox2', false);
-      await wd.dontSeeInField('checkbox2', true);
-      await wd.seeInField('radio2', true);
-      await wd.dontSeeInField('radio2', false);
-      await wd.seeInField('radio3', false);
-      await wd.dontSeeInField('radio3', true);
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('checkbox1', true)
+      await wd.dontSeeInField('checkbox1', false)
+      await wd.seeInField('checkbox2', false)
+      await wd.dontSeeInField('checkbox2', true)
+      await wd.seeInField('radio2', true)
+      await wd.dontSeeInField('radio2', false)
+      await wd.seeInField('radio3', false)
+      await wd.dontSeeInField('radio3', true)
+    })
 
     it('should check values in radio', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('radio1', 'see test one');
-      await wd.dontSeeInField('radio1', 'not seen one');
-      await wd.dontSeeInField('radio1', 'not seen two');
-      await wd.dontSeeInField('radio1', 'not seen three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('radio1', 'see test one')
+      await wd.dontSeeInField('radio1', 'not seen one')
+      await wd.dontSeeInField('radio1', 'not seen two')
+      await wd.dontSeeInField('radio1', 'not seen three')
+    })
 
     it('should check values in select', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('select1', 'see test one');
-      await wd.dontSeeInField('select1', 'not seen one');
-      await wd.dontSeeInField('select1', 'not seen two');
-      await wd.dontSeeInField('select1', 'not seen three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('select1', 'see test one')
+      await wd.dontSeeInField('select1', 'not seen one')
+      await wd.dontSeeInField('select1', 'not seen two')
+      await wd.dontSeeInField('select1', 'not seen three')
+    })
 
     it('should check for empty select field', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.seeInField('select3', '');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.seeInField('select3', '')
+    })
 
     it('should check for select multiple field', async () => {
-      await wd.amOnPage('/form/field_values');
-      await wd.dontSeeInField('select2', 'not seen one');
-      await wd.seeInField('select2', 'see test one');
-      await wd.dontSeeInField('select2', 'not seen two');
-      await wd.seeInField('select2', 'see test two');
-      await wd.dontSeeInField('select2', 'not seen three');
-      await wd.seeInField('select2', 'see test three');
-    });
+      await wd.amOnPage('/form/field_values')
+      await wd.dontSeeInField('select2', 'not seen one')
+      await wd.seeInField('select2', 'see test one')
+      await wd.dontSeeInField('select2', 'not seen two')
+      await wd.seeInField('select2', 'see test two')
+      await wd.dontSeeInField('select2', 'not seen three')
+      await wd.seeInField('select2', 'see test three')
+    })
 
     it('should return error when element has no value attribute', async () => {
-      await wd.amOnPage('https://codecept.io/quickstart');
+      await wd.amOnPage('https://codecept.io/quickstart')
 
       try {
-        await wd.seeInField('#search_input_react', 'WebDriver1');
+        await wd.seeInField('#search_input_react', 'WebDriver1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
+        e.should.be.instanceOf(Error)
       }
-    });
-  });
+    })
+  })
 
   describe('Force Right Click: #forceRightClick', () => {
     it('it should forceRightClick', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('.context a');
-      await wd.see('right clicked');
-    });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('.context a')
+      await wd.see('right clicked')
+    })
 
     it('it should forceRightClick by locator and context', async () => {
-      await wd.amOnPage('/form/rightclick');
-      await wd.dontSee('right clicked');
-      await wd.forceRightClick('Lorem Ipsum', '.context');
-      await wd.see('right clicked');
-    });
-  });
+      await wd.amOnPage('/form/rightclick')
+      await wd.dontSee('right clicked')
+      await wd.forceRightClick('Lorem Ipsum', '.context')
+      await wd.see('right clicked')
+    })
+  })
 
   describe('#pressKey, #pressKeyDown, #pressKeyUp', () => {
     it('should be able to send special keys to element', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.appendField('Name', '-');
+      await wd.amOnPage('/form/field')
+      await wd.appendField('Name', '-')
 
-      await wd.pressKey(['Right Shift', 'Home']);
-      await wd.pressKey('Delete');
+      await wd.pressKey(['Right Shift', 'Home'])
+      await wd.pressKey('Delete')
 
       // Sequence only executes up to first non-modifier key ('Digit1')
-      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4']);
-      await wd.pressKey('1');
-      await wd.pressKey('2');
-      await wd.pressKey('3');
-      await wd.pressKey('ArrowLeft');
-      await wd.pressKey('Left Arrow');
-      await wd.pressKey('arrow_left');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('a');
-      await wd.pressKey('KeyB');
-      await wd.pressKeyUp('ShiftLeft');
-      await wd.pressKey('C');
-      await wd.seeInField('Name', '!ABC123');
-    });
+      await wd.pressKey(['SHIFT_RIGHT', 'Digit1', 'Digit4'])
+      await wd.pressKey('1')
+      await wd.pressKey('2')
+      await wd.pressKey('3')
+      await wd.pressKey('ArrowLeft')
+      await wd.pressKey('Left Arrow')
+      await wd.pressKey('arrow_left')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('a')
+      await wd.pressKey('KeyB')
+      await wd.pressKeyUp('ShiftLeft')
+      await wd.pressKey('C')
+      await wd.seeInField('Name', '!ABC123')
+    })
 
     it('should use modifier key based on operating system', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', 'value that is cleared using select all shortcut');
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', 'value that is cleared using select all shortcut')
 
-      await wd.pressKey(['CommandOrControl', 'A']);
-      await wd.pressKey('Backspace');
-      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut');
-    });
+      await wd.pressKey(['CommandOrControl', 'A'])
+      await wd.pressKey('Backspace')
+      await wd.dontSeeInField('Name', 'value that is cleared using select all shortcut')
+    })
 
     it('should show correct numpad or punctuation key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey(';');
-      await wd.pressKey(['Shift', ';']);
-      await wd.pressKey(['Shift', 'Semicolon']);
-      await wd.pressKey('=');
-      await wd.pressKey(['Shift', '=']);
-      await wd.pressKey(['Shift', 'Equal']);
-      await wd.pressKey('*');
-      await wd.pressKey(['Shift', '*']);
-      await wd.pressKey(['Shift', 'Multiply']);
-      await wd.pressKey('+');
-      await wd.pressKey(['Shift', '+']);
-      await wd.pressKey(['Shift', 'Add']);
-      await wd.pressKey(',');
-      await wd.pressKey(['Shift', ',']);
-      await wd.pressKey(['Shift', 'Comma']);
-      await wd.pressKey(['Shift', 'NumpadComma']);
-      await wd.pressKey(['Shift', 'Separator']);
-      await wd.pressKey('-');
-      await wd.pressKey(['Shift', '-']);
-      await wd.pressKey(['Shift', 'Subtract']);
-      await wd.pressKey('.');
-      await wd.pressKey(['Shift', '.']);
-      await wd.pressKey(['Shift', 'Decimal']);
-      await wd.pressKey(['Shift', 'Period']);
-      await wd.pressKey('/');
-      await wd.pressKey(['Shift', '/']);
-      await wd.pressKey(['Shift', 'Divide']);
-      await wd.pressKey(['Shift', 'Slash']);
-
-      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?');
-    });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey(';')
+      await wd.pressKey(['Shift', ';'])
+      await wd.pressKey(['Shift', 'Semicolon'])
+      await wd.pressKey('=')
+      await wd.pressKey(['Shift', '='])
+      await wd.pressKey(['Shift', 'Equal'])
+      await wd.pressKey('*')
+      await wd.pressKey(['Shift', '*'])
+      await wd.pressKey(['Shift', 'Multiply'])
+      await wd.pressKey('+')
+      await wd.pressKey(['Shift', '+'])
+      await wd.pressKey(['Shift', 'Add'])
+      await wd.pressKey(',')
+      await wd.pressKey(['Shift', ','])
+      await wd.pressKey(['Shift', 'Comma'])
+      await wd.pressKey(['Shift', 'NumpadComma'])
+      await wd.pressKey(['Shift', 'Separator'])
+      await wd.pressKey('-')
+      await wd.pressKey(['Shift', '-'])
+      await wd.pressKey(['Shift', 'Subtract'])
+      await wd.pressKey('.')
+      await wd.pressKey(['Shift', '.'])
+      await wd.pressKey(['Shift', 'Decimal'])
+      await wd.pressKey(['Shift', 'Period'])
+      await wd.pressKey('/')
+      await wd.pressKey(['Shift', '/'])
+      await wd.pressKey(['Shift', 'Divide'])
+      await wd.pressKey(['Shift', 'Slash'])
+
+      await wd.seeInField('Name', ';::=++***+++,<<<<-_-.>.>/?/?')
+    })
 
     it('should show correct number key when Shift modifier is active', async () => {
-      await wd.amOnPage('/form/field');
-      await wd.fillField('Name', '');
-
-      await wd.pressKey('0');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('0');
-      await wd.pressKey('Digit0');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('1');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('1');
-      await wd.pressKey('Digit1');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('2');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('2');
-      await wd.pressKey('Digit2');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('3');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('3');
-      await wd.pressKey('Digit3');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('4');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('4');
-      await wd.pressKey('Digit4');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('5');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('5');
-      await wd.pressKey('Digit5');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('6');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('6');
-      await wd.pressKey('Digit6');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('7');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('7');
-      await wd.pressKey('Digit7');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('8');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('8');
-      await wd.pressKey('Digit8');
-      await wd.pressKeyUp('Shift');
-
-      await wd.pressKey('9');
-      await wd.pressKeyDown('Shift');
-      await wd.pressKey('9');
-      await wd.pressKey('Digit9');
-      await wd.pressKeyUp('Shift');
-
-      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((');
-    });
-  });
+      await wd.amOnPage('/form/field')
+      await wd.fillField('Name', '')
+
+      await wd.pressKey('0')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('0')
+      await wd.pressKey('Digit0')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('1')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('1')
+      await wd.pressKey('Digit1')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('2')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('2')
+      await wd.pressKey('Digit2')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('3')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('3')
+      await wd.pressKey('Digit3')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('4')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('4')
+      await wd.pressKey('Digit4')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('5')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('5')
+      await wd.pressKey('Digit5')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('6')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('6')
+      await wd.pressKey('Digit6')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('7')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('7')
+      await wd.pressKey('Digit7')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('8')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('8')
+      await wd.pressKey('Digit8')
+      await wd.pressKeyUp('Shift')
+
+      await wd.pressKey('9')
+      await wd.pressKeyDown('Shift')
+      await wd.pressKey('9')
+      await wd.pressKey('Digit9')
+      await wd.pressKeyUp('Shift')
+
+      await wd.seeInField('Name', '0))1!!2@@3##4$$5%%6^^7&&8**9((')
+    })
+  })
 
   describe('#seeInSource, #grabSource', () => {
     it('should check for text to be in HTML source', async () => {
-      await wd.amOnPage('/');
-      await wd.seeInSource('<title>TestEd Beta 2.0</title>');
-      await wd.dontSeeInSource('<meta');
-    });
+      await wd.amOnPage('/')
+      await wd.seeInSource('<title>TestEd Beta 2.0</title>')
+      await wd.dontSeeInSource('<meta')
+    })
 
     it('should grab the source', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabSource();
-      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved');
-    });
+      await wd.amOnPage('/')
+      const source = await wd.grabSource()
+      assert.notEqual(source.indexOf('<title>TestEd Beta 2.0</title>'), -1, 'Source html should be retrieved')
+    })
 
     it('should grab the innerHTML for an element', async () => {
-      await wd.amOnPage('/');
-      const source = await wd.grabHTMLFrom('#area1');
+      await wd.amOnPage('/')
+      const source = await wd.grabHTMLFrom('#area1')
       assert.deepEqual(
         source,
         `
     <a href="/form/file" qa-id="test" qa-link="test"> Test Link </a>
 `,
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('#seeTitleEquals', () => {
     it('should check that title is equal to provided one', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
 
       try {
-        await wd.seeTitleEquals('TestEd Beta 2.0');
-        await wd.seeTitleEquals('TestEd Beta 2.');
+        await wd.seeTitleEquals('TestEd Beta 2.0')
+        await wd.seeTitleEquals('TestEd Beta 2.')
       } catch (e) {
-        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0');
+        assert.equal(e.message, 'expected web page title to be TestEd Beta 2., but found TestEd Beta 2.0')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeTextEquals', () => {
     it('should check text is equal to provided one', async () => {
-      await wd.amOnPage('/');
-      await wd.seeTextEquals('Welcome to test app!', 'h1');
+      await wd.amOnPage('/')
+      await wd.seeTextEquals('Welcome to test app!', 'h1')
 
       try {
-        await wd.seeTextEquals('Welcome to test app', 'h1');
-        assert.equal(true, false, 'Throw an error because it should not get this far!');
+        await wd.seeTextEquals('Welcome to test app', 'h1')
+        assert.equal(true, false, 'Throw an error because it should not get this far!')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element h1 "Welcome to test app" to equal "Welcome to test app!"')
         // e.should.be.instanceOf(AssertionFailedError);
       }
-    });
+    })
 
     it('should check text is not equal to empty string of element text', async () => {
-      await wd.amOnPage('https://codecept.io');
+      await wd.amOnPage('https://codecept.io')
 
       try {
-        await wd.seeTextEquals('', '.logo');
-        await wd.seeTextEquals('This is not empty', '.logo');
+        await wd.seeTextEquals('', '.logo')
+        await wd.seeTextEquals('This is not empty', '.logo')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('expected element .logo "This is not empty" to equal ""')
       }
-    });
-  });
+    })
+  })
 
   describe('#waitForFunction', () => {
     it('should wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(() => window.__waitJs, 3);
-    });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction(() => window.__waitJs, 3)
+    })
 
     it('should pass arguments and wait for function returns true', async () => {
-      await wd.amOnPage('/form/wait_js');
-      await wd.waitForFunction(varName => window[varName], ['__waitJs'], 3);
-    });
-  });
+      await wd.amOnPage('/form/wait_js')
+      await wd.waitForFunction((varName) => window[varName], ['__waitJs'], 3)
+    })
+  })
 
   describe('#waitForEnabled', () => {
     it('should wait for input text field to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for input text field to be enabled by xpath', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled("//*[@name = 'test']", 2);
-      await wd.fillField('#text', 'hello world');
-      await wd.seeInField('#text', 'hello world');
-    });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled("//*[@name = 'test']", 2)
+      await wd.fillField('#text', 'hello world')
+      await wd.seeInField('#text', 'hello world')
+    })
 
     it('should wait for a button to be enabled', async () => {
-      await wd.amOnPage('/form/wait_enabled');
-      await wd.waitForEnabled('#text', 2);
-      await wd.click('#button');
-      await wd.see('button was clicked');
-    });
-  });
+      await wd.amOnPage('/form/wait_enabled')
+      await wd.waitForEnabled('#text', 2)
+      await wd.click('#button')
+      await wd.see('button was clicked')
+    })
+  })
 
   describe('#waitForValue', () => {
     it('should wait for expected value for given locator', async () => {
-      await wd.amOnPage('/info');
-      await wd.waitForValue('//input[@name= "rus"]', 'Верно');
+      await wd.amOnPage('/info')
+      await wd.waitForValue('//input[@name= "rus"]', 'Верно')
 
       try {
-        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1);
-        throw Error('It should never get this far');
+        await wd.waitForValue('//input[@name= "rus"]', 'Верно3', 0.1)
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec');
+        e.message.should.include(
+          'element (//input[@name= "rus"]) is not in DOM or there is no element(//input[@name= "rus"]) with value "Верно3" after 0.1 sec',
+        )
       }
-    });
+    })
 
     it('should wait for expected value for given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('#text', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('#text', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should wait for expected value for given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.seeInField('#text', 'Hamburg');
-      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5);
-      await wd.seeInField('#text', 'Brisbane');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.seeInField('#text', 'Hamburg')
+      await wd.waitForValue('//input[@value = "Grüße aus Hamburg"]', 'Brisbane', 2.5)
+      await wd.seeInField('#text', 'Brisbane')
+    })
 
     it('should only wait for one of the matching elements to contain the value given xpath locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('//input[@type = "text"]', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
 
     it('should only wait for one of the matching elements to contain the value given css locator', async () => {
-      await wd.amOnPage('/form/wait_value');
-      await wd.waitForValue('.inputbox', 'Brisbane', 4);
-      await wd.seeInField('#text', 'Brisbane');
-      await wd.seeInField('#text2', 'London');
-    });
-  });
+      await wd.amOnPage('/form/wait_value')
+      await wd.waitForValue('.inputbox', 'Brisbane', 4)
+      await wd.seeInField('#text', 'Brisbane')
+      await wd.seeInField('#text2', 'London')
+    })
+  })
 
   describe('#waitNumberOfVisibleElements', () => {
     it('should wait for a specified number of elements on the page', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3))
         .then(() => wd.waitNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (//div[@id = "grab-multiple"]//a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements({ css: '//div[@id = "grab-multiple"]//a' }, 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified number of elements on the page using a css selector', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 3))
         .then(() => wd.waitNumberOfVisibleElements('#grab-multiple > a', 2, 0.1))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec');
-        });
-    });
+          e.message.should.include('The number of elements (#grab-multiple > a) is not 2 after 0.1 sec')
+        })
+    })
 
     it('should wait for a specified number of elements which are not yet attached to the DOM', () => {
-      return wd.amOnPage('/form/wait_num_elements')
+      return wd
+        .amOnPage('/form/wait_num_elements')
         .then(() => wd.waitNumberOfVisibleElements('.title', 2, 3))
         .then(() => wd.see('Hello'))
-        .then(() => wd.see('World'));
-    });
-  });
+        .then(() => wd.see('World'))
+    })
+  })
 
   describe('#waitForVisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForVisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
-  });
+          e.message.should.not.include('[object Object]')
+        })
+    })
+  })
 
   describe('#waitForInvisible', () => {
     it('should be no [object Object] in the error message', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.waitForInvisible('//div[@id = "grab-multiple"]//a', 3))
         .then(() => {
-          throw Error('It should never get this far');
+          throw Error('It should never get this far')
         })
         .catch((e) => {
-          e.message.should.not.include('[object Object]');
-        });
-    });
+          e.message.should.not.include('[object Object]')
+        })
+    })
 
     it('should wait for a specified element to be invisible', () => {
-      return wd.amOnPage('/form/wait_invisible')
+      return wd
+        .amOnPage('/form/wait_invisible')
         .then(() => wd.waitForInvisible('#step1', 3))
-        .then(() => wd.dontSeeElement('#step1'));
-    });
-  });
+        .then(() => wd.dontSeeElement('#step1'))
+    })
+  })
 
   describe('#moveCursorTo', () => {
     it('should trigger hover event', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover');
-      await wd.see('Hovered', '#show');
-    });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover')
+      await wd.see('Hovered', '#show')
+    })
 
     it('should not trigger hover event because of the offset is beyond the element', async () => {
-      await wd.amOnPage('/form/hover');
-      await wd.moveCursorTo('#hover', 100, 100);
-      await wd.dontSee('Hovered', '#show');
-    });
-  });
+      await wd.amOnPage('/form/hover')
+      await wd.moveCursorTo('#hover', 100, 100)
+      await wd.dontSee('Hovered', '#show')
+    })
+  })
 
   describe('#switchToNextTab, #switchToPreviousTab, #openNewTab, #closeCurrentTab, #closeOtherTabs, #grabNumberOfOpenTabs, #waitForNumberOfTabs', () => {
     it('should only have 1 tab open when the browser starts and navigates to the first page', async () => {
-      await wd.amOnPage('/');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
-    });
+      await wd.amOnPage('/')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
+    })
 
     it('should switch to next tab', async () => {
-      wd.amOnPage('/info');
-      const numPages = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPages, 1);
-
-      await wd.click('New tab');
-      await wd.waitForNumberOfTabs(2);
-      await wd.switchToNextTab();
-      await wd.waitInUrl('/login');
-      const numPagesAfter = await wd.grabNumberOfOpenTabs();
-      assert.equal(numPagesAfter, 2);
-    });
+      wd.amOnPage('/info')
+      const numPages = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPages, 1)
+
+      await wd.click('New tab')
+      await wd.waitForNumberOfTabs(2)
+      await wd.switchToNextTab()
+      await wd.waitInUrl('/login')
+      const numPagesAfter = await wd.grabNumberOfOpenTabs()
+      assert.equal(numPagesAfter, 2)
+    })
 
     it('should assert when there is no ability to switch to next tab', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.click('More info'))
         .then(() => wd.wait(1)) // Wait is required because the url is change by previous statement (maybe related to #914)
         .then(() => wd.switchToNextTab(2))
         .then(() => assert.equal(true, false, 'Throw an error if it gets this far (which it should not)!'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2');
-        });
-    });
+          assert.equal(e.message, 'There is no ability to switch to next tab with offset 2')
+        })
+    })
 
     it('should close current tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.click('New tab'))
         .then(() => wd.switchToNextTab())
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2))
+        .then((numPages) => assert.equal(numPages, 2))
         .then(() => wd.closeCurrentTab())
         .then(() => wd.seeInCurrentUrl('/info'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should close other tabs', () => {
-      return wd.amOnPage('/')
+      return wd
+        .amOnPage('/')
         .then(() => wd.openNewTab())
         .then(() => wd.seeInCurrentUrl('about:blank'))
         .then(() => wd.amOnPage('/info'))
@@ -659,574 +669,615 @@ describe('WebDriver', function () {
         .then(() => wd.seeInCurrentUrl('/login'))
         .then(() => wd.closeOtherTabs())
         .then(() => wd.seeInCurrentUrl('/login'))
-        .then(() => wd.grabNumberOfOpenTabs());
-    });
+        .then(() => wd.grabNumberOfOpenTabs())
+    })
 
     it('should open new tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.grabNumberOfOpenTabs())
-        .then(numPages => assert.equal(numPages, 2));
-    });
+        .then((numPages) => assert.equal(numPages, 2))
+    })
 
     it('should switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab())
-        .then(() => wd.waitInUrl('/info'));
-    });
+        .then(() => wd.waitInUrl('/info'))
+    })
 
     it('should assert when there is no ability to switch to previous tab', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd.openNewTab())
         .then(() => wd.waitInUrl('about:blank'))
         .then(() => wd.switchToPreviousTab(2))
         .then(() => wd.waitInUrl('/info'))
         .catch((e) => {
-          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2');
-        });
-    });
-  });
+          assert.equal(e.message, 'There is no ability to switch to previous tab with offset 2')
+        })
+    })
+  })
 
   describe('popup : #acceptPopup, #seeInPopup, #cancelPopup', () => {
     it('should accept popup window', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.acceptPopup())
-        .then(() => wd.see('Yes', '#result'));
-    });
+        .then(() => wd.see('Yes', '#result'))
+    })
 
     it('should cancel popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Confirm'))
         .then(() => wd.cancelPopup())
-        .then(() => wd.see('No', '#result'));
-    });
+        .then(() => wd.see('No', '#result'))
+    })
 
     it('should check text in popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.seeInPopup('Really?'))
-        .then(() => wd.cancelPopup());
-    });
+        .then(() => wd.cancelPopup())
+    })
 
     it('should grab text from popup', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.click('Alert'))
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, 'Really?'));
-    });
+        .then((text) => assert.equal(text, 'Really?'))
+    })
 
     it('should return null if no popup is visible (do not throw an error)', () => {
-      return wd.amOnPage('/form/popup')
+      return wd
+        .amOnPage('/form/popup')
         .then(() => wd.grabPopupText())
-        .then(text => assert.equal(text, null));
-    });
-  });
+        .then((text) => assert.equal(text, null))
+    })
+  })
 
   describe('#waitForText', () => {
     it('should return error if not present', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Nothing here', 1, '#text'))
         .catch((e) => {
-          e.message.should.be.equal('element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec');
-        });
-    });
+          e.message.should.be.equal(
+            'element (#text) is not in DOM or there is no element(#text) with text "Nothing here" after 1 sec',
+          )
+        })
+    })
 
     it('should return error if waiting is too small', () => {
-      return wd.amOnPage('/dynamic')
+      return wd
+        .amOnPage('/dynamic')
         .then(() => wd.waitForText('Dynamic text', 0.1))
         .catch((e) => {
-          e.message.should.be.equal('element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec');
-        });
-    });
-  });
+          e.message.should.be.equal(
+            'element (body) is not in DOM or there is no element(body) with text "Dynamic text" after 0.1 sec',
+          )
+        })
+    })
+  })
 
   describe('#seeNumberOfElements', () => {
     it('should return 1 as count', async () => {
-      await wd.amOnPage('/');
-      await wd.seeNumberOfElements('#area1', 1);
-    });
-  });
+      await wd.amOnPage('/')
+      await wd.seeNumberOfElements('#area1', 1)
+    })
+  })
 
   describe('#switchTo', () => {
     it('should switch reference to iframe content', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+    })
 
     it('should return error if iframe selector is invalid', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('#invalidIframeSelector');
+        await wd.switchTo('#invalidIframeSelector')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath');
+        e.should.be.instanceOf(Error)
+        e.message.should.be.equal('Element "#invalidIframeSelector" was not found by text|CSS|XPath')
       }
-    });
+    })
 
     it('should return error if iframe selector is not iframe', async () => {
-      await wd.amOnPage('/iframe');
+      await wd.amOnPage('/iframe')
 
       try {
-        await wd.switchTo('h1');
+        await wd.switchTo('h1')
       } catch (e) {
-        e.should.be.instanceOf(Error);
-        e.message.should.contain('no such frame');
+        e.should.be.instanceOf(Error)
+        e.message.should.contain('no such frame')
       }
-    });
+    })
 
     it('should return to parent frame given a null locator', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.switchTo('[name="content"]');
-      await wd.see('Information\nLots of valuable data here');
-      await wd.switchTo(null);
-      await wd.see('Iframe test');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.switchTo('[name="content"]')
+      await wd.see('Information\nLots of valuable data here')
+      await wd.switchTo(null)
+      await wd.see('Iframe test')
+    })
+  })
 
   describe('click context', () => {
     it('should click on inner text', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//input[@type = "submit"]');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//input[@type = "submit"]')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click on input in inner element', async () => {
-      await wd.amOnPage('/form/checkbox');
-      await wd.click('Submit', '//form');
-      await wd.waitInUrl('/form/complex');
-    });
+      await wd.amOnPage('/form/checkbox')
+      await wd.click('Submit', '//form')
+      await wd.waitInUrl('/form/complex')
+    })
 
     it('should click by accessibility_id', async () => {
-      await wd.amOnPage('/info');
-      await wd.click('~index via aria-label');
-      await wd.see('Welcome to test app!');
-    });
-  });
+      await wd.amOnPage('/info')
+      await wd.click('~index via aria-label')
+      await wd.see('Welcome to test app!')
+    })
+  })
 
   describe('window size #resizeWindow', () => {
     it('should set initial window size', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.click('Window Size');
-      await wd.see('Height 700', '#height');
-      await wd.see('Width 500', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.click('Window Size')
+      await wd.see('Height 700', '#height')
+      await wd.see('Width 500', '#width')
+    })
 
     it('should set window size on new session', () => {
-      return wd.amOnPage('/info')
+      return wd
+        .amOnPage('/info')
         .then(() => wd._session())
-        .then(session => session.start()
-          .then(browser => ({
+        .then((session) =>
+          session.start().then((browser) => ({
             browser,
             session,
-          })))
+          })),
+        )
         .then(({ session, browser }) => session.loadVars(browser))
         .then(() => wd.amOnPage('/form/resize'))
         .then(() => wd.click('Window Size'))
         .then(() => wd.see('Height 700', '#height'))
-        .then(() => wd.see('Width 500', '#width'));
-    });
+        .then(() => wd.see('Width 500', '#width'))
+    })
 
     it('should resize window to specific dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(950, 600);
-      await wd.click('Window Size');
-      await wd.see('Height 600', '#height');
-      await wd.see('Width 950', '#width');
-    });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(950, 600)
+      await wd.click('Window Size')
+      await wd.see('Height 600', '#height')
+      await wd.see('Width 950', '#width')
+    })
 
     xit('should resize window to maximum screen dimensions', async () => {
-      await wd.amOnPage('/form/resize');
-      await wd.resizeWindow(500, 400);
-      await wd.click('Window Size');
-      await wd.see('Height 400', '#height');
-      await wd.see('Width 500', '#width');
-      await wd.resizeWindow('maximize');
-      await wd.click('Window Size');
-      await wd.dontSee('Height 400', '#height');
-      await wd.dontSee('Width 500', '#width');
-    });
-  });
+      await wd.amOnPage('/form/resize')
+      await wd.resizeWindow(500, 400)
+      await wd.click('Window Size')
+      await wd.see('Height 400', '#height')
+      await wd.see('Width 500', '#width')
+      await wd.resizeWindow('maximize')
+      await wd.click('Window Size')
+      await wd.dontSee('Height 400', '#height')
+      await wd.dontSee('Width 500', '#width')
+    })
+  })
 
   describe('SmartWait', () => {
-    before(() => wd.options.smartWait = 3000);
-    after(() => wd.options.smartWait = 0);
+    before(() => (wd.options.smartWait = 3000))
+    after(() => (wd.options.smartWait = 0))
 
     it('should wait for element to appear', async () => {
-      await wd.amOnPage('/form/wait_element');
-      await wd.dontSeeElement('h1');
-      await wd.seeElement('h1');
-    });
+      await wd.amOnPage('/form/wait_element')
+      await wd.dontSeeElement('h1')
+      await wd.seeElement('h1')
+    })
 
     it('should wait for clickable element appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#click');
-      await wd.click('#click');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#click')
+      await wd.click('#click')
+      await wd.see('Hi!')
+    })
 
     it('should wait for clickable context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSeeElement('#linkContext');
-      await wd.click('Hello world', '#linkContext');
-      await wd.see('Hi!');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSeeElement('#linkContext')
+      await wd.click('Hello world', '#linkContext')
+      await wd.see('Hi!')
+    })
 
     it('should wait for text context to appear', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      await wd.see('Hello world', '#linkContext');
-    });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      await wd.see('Hello world', '#linkContext')
+    })
 
     it('should work with grabbers', async () => {
-      await wd.amOnPage('/form/wait_clickable');
-      await wd.dontSee('Hello world');
-      const res = await wd.grabAttributeFrom('#click', 'id');
-      assert.equal(res, 'click');
-    });
-  });
+      await wd.amOnPage('/form/wait_clickable')
+      await wd.dontSee('Hello world')
+      const res = await wd.grabAttributeFrom('#click', 'id')
+      assert.equal(res, 'click')
+    })
+  })
 
   describe('#_locateClickable', () => {
     it('should locate a button to click', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('Submit');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('Submit')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateClickable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateClickable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateCheckable', () => {
     it('should locate a checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I Agree');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I Agree')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing checkbox', async () => {
-      await wd.amOnPage('/form/checkbox');
-      const res = await wd._locateCheckable('I disagree');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/checkbox')
+      const res = await wd._locateCheckable('I disagree')
+      res.length.should.be.equal(0)
+    })
+  })
 
   describe('#_locateFields', () => {
     it('should locate a field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Name');
-      res.length.should.be.equal(1);
-    });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Name')
+      res.length.should.be.equal(1)
+    })
 
     it('should not locate a non-existing field', async () => {
-      await wd.amOnPage('/form/field');
-      const res = await wd._locateFields('Mother-in-law');
-      res.length.should.be.equal(0);
-    });
-  });
+      await wd.amOnPage('/form/field')
+      const res = await wd._locateFields('Mother-in-law')
+      res.length.should.be.equal(0)
+    })
+  })
 
   xdescribe('#grabBrowserLogs', () => {
     it('should grab browser logs', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry');
-      });
-      const logs = await wd.grabBrowserLogs();
-      console.log('lololo', logs);
+        console.log('Test log entry')
+      })
+      const logs = await wd.grabBrowserLogs()
+      console.log('lololo', logs)
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 1);
-    });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 1)
+    })
 
     it('should grab browser logs across pages', async () => {
-      wd.amOnPage('/');
+      wd.amOnPage('/')
       await wd.executeScript(() => {
-        console.log('Test log entry 1');
-      });
-      await wd.openNewTab();
-      await wd.amOnPage('/info');
+        console.log('Test log entry 1')
+      })
+      await wd.openNewTab()
+      await wd.amOnPage('/info')
       await wd.executeScript(() => {
-        console.log('Test log entry 2');
-      });
+        console.log('Test log entry 2')
+      })
 
-      const logs = await wd.grabBrowserLogs();
+      const logs = await wd.grabBrowserLogs()
 
-      const matchingLogs = logs.filter(log => log.message.indexOf('Test log entry') > -1);
-      assert.equal(matchingLogs.length, 2);
-    });
-  });
+      const matchingLogs = logs.filter((log) => log.message.indexOf('Test log entry') > -1)
+      assert.equal(matchingLogs.length, 2)
+    })
+  })
 
   describe('#dragAndDrop', () => {
     it('Drag item from source to target (no iframe) @dragNdrop', async () => {
-      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
+      await wd.amOnPage('http://jqueryui.com/resources/demos/droppable/default.html')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
 
     it('Drag and drop from within an iframe', async () => {
-      await wd.amOnPage('http://jqueryui.com/droppable');
-      await wd.resizeWindow(700, 700);
-      await wd.switchTo('//iframe[@class="demo-frame"]');
-      await wd.seeElementInDOM('#draggable');
-      await wd.dragAndDrop('#draggable', '#droppable');
-      await wd.see('Dropped');
-    });
-  });
+      await wd.amOnPage('http://jqueryui.com/droppable')
+      await wd.resizeWindow(700, 700)
+      await wd.switchTo('//iframe[@class="demo-frame"]')
+      await wd.seeElementInDOM('#draggable')
+      await wd.dragAndDrop('#draggable', '#droppable')
+      await wd.see('Dropped')
+    })
+  })
 
   describe('#switchTo frame', () => {
     it('should switch to frame using name', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
 
     it('should switch to root frame', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo('iframe');
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-      await wd.switchTo();
-      await wd.see('Iframe test', 'h1');
-    });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo('iframe')
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+      await wd.switchTo()
+      await wd.see('Iframe test', 'h1')
+    })
 
     it('should switch to frame using frame number', async () => {
-      await wd.amOnPage('/iframe');
-      await wd.see('Iframe test', 'h1');
-      await wd.dontSee('Information', 'h1');
-      await wd.switchTo(0);
-      await wd.see('Information', 'h1');
-      await wd.dontSee('Iframe test', 'h1');
-    });
-  });
+      await wd.amOnPage('/iframe')
+      await wd.see('Iframe test', 'h1')
+      await wd.dontSee('Information', 'h1')
+      await wd.switchTo(0)
+      await wd.see('Information', 'h1')
+      await wd.dontSee('Iframe test', 'h1')
+    })
+  })
 
   describe('#AttachFile', () => {
     it('should attach to regular input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('Avatar', './app/avatar.jpg');
-      await wd.seeInField('Avatar', 'avatar.jpg');
-    });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('Avatar', './app/avatar.jpg')
+      await wd.seeInField('Avatar', 'avatar.jpg')
+    })
 
     it('should attach to invisible input element', async () => {
-      await wd.amOnPage('/form/file');
-      await wd.attachFile('hidden', '/app/avatar.jpg');
-    });
-  });
+      await wd.amOnPage('/form/file')
+      await wd.attachFile('hidden', '/app/avatar.jpg')
+    })
+  })
 
   describe('#dragSlider', () => {
     it('should drag scrubber to given position', async () => {
-      await wd.amOnPage('/form/page_slider');
-      await wd.seeElementInDOM('#slidecontainer input');
+      await wd.amOnPage('/form/page_slider')
+      await wd.seeElementInDOM('#slidecontainer input')
 
-      const before = await wd.grabValueFrom('#slidecontainer input');
-      await wd.dragSlider('#slidecontainer input', 20);
-      const after = await wd.grabValueFrom('#slidecontainer input');
+      const before = await wd.grabValueFrom('#slidecontainer input')
+      await wd.dragSlider('#slidecontainer input', 20)
+      const after = await wd.grabValueFrom('#slidecontainer input')
 
-      assert.notEqual(before, after);
-    });
-  });
+      assert.notEqual(before, after)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
 
     it('should NOT uncheck option that is NOT currently checked', async () => {
-      await wd.amOnPage('/info');
-      await wd.uncheckOption('interesting');
+      await wd.amOnPage('/info')
+      await wd.uncheckOption('interesting')
       // Unchecking again should not affect the current 'unchecked' status
-      await wd.uncheckOption('interesting');
-      await wd.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await wd.uncheckOption('interesting')
+      await wd.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('allow back and forth between handles: #grabAllWindowHandles #grabCurrentWindowHandle #switchToWindow', () => {
     it('should open main page of configured site, open a popup, switch to main page, then switch to popup, close popup, and go back to main page', async () => {
-      await wd.amOnPage('/');
-      const handleBeforePopup = await wd.grabCurrentWindowHandle();
-      const urlBeforePopup = await wd.grabCurrentUrl();
+      await wd.amOnPage('/')
+      const handleBeforePopup = await wd.grabCurrentWindowHandle()
+      const urlBeforePopup = await wd.grabCurrentUrl()
 
-      const allHandlesBeforePopup = await wd.grabAllWindowHandles();
-      allHandlesBeforePopup.length.should.eql(1);
+      const allHandlesBeforePopup = await wd.grabAllWindowHandles()
+      allHandlesBeforePopup.length.should.eql(1)
 
       await wd.executeScript(() => {
-        window.open('https://www.w3schools.com/', 'new window', 'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400');
-      });
-
-      const allHandlesAfterPopup = await wd.grabAllWindowHandles();
-      allHandlesAfterPopup.length.should.eql(2);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterPopup = await wd.grabCurrentUrl();
-      urlAfterPopup.should.eql('https://www.w3schools.com/');
-
-      handleBeforePopup.should.eql(allHandlesAfterPopup[0]);
-      await wd.switchToWindow(handleBeforePopup);
-      const currentURL = await wd.grabCurrentUrl();
-      currentURL.should.eql(urlBeforePopup);
-
-      await wd.switchToWindow(allHandlesAfterPopup[1]);
-      const urlAfterSwitchBack = await wd.grabCurrentUrl();
-      urlAfterSwitchBack.should.eql('https://www.w3schools.com/');
-      await wd.closeCurrentTab();
-
-      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles();
-      allHandlesAfterPopupClosed.length.should.eql(1);
-      const currentWindowHandle = await wd.grabCurrentWindowHandle();
-      currentWindowHandle.should.eql(handleBeforePopup);
-    });
-  });
+        window.open(
+          'https://www.w3schools.com/',
+          'new window',
+          'toolbar=yes,scrollbars=yes,resizable=yes,width=400,height=400',
+        )
+      })
+
+      const allHandlesAfterPopup = await wd.grabAllWindowHandles()
+      allHandlesAfterPopup.length.should.eql(2)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterPopup = await wd.grabCurrentUrl()
+      urlAfterPopup.should.eql('https://www.w3schools.com/')
+
+      handleBeforePopup.should.eql(allHandlesAfterPopup[0])
+      await wd.switchToWindow(handleBeforePopup)
+      const currentURL = await wd.grabCurrentUrl()
+      currentURL.should.eql(urlBeforePopup)
+
+      await wd.switchToWindow(allHandlesAfterPopup[1])
+      const urlAfterSwitchBack = await wd.grabCurrentUrl()
+      urlAfterSwitchBack.should.eql('https://www.w3schools.com/')
+      await wd.closeCurrentTab()
+
+      const allHandlesAfterPopupClosed = await wd.grabAllWindowHandles()
+      allHandlesAfterPopupClosed.length.should.eql(1)
+      const currentWindowHandle = await wd.grabCurrentWindowHandle()
+      currentWindowHandle.should.eql(handleBeforePopup)
+    })
+  })
 
   describe('#waitForClickable', () => {
     it('should wait for clickable', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: 'input#text' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: 'input#text' })
+    })
 
     it('should wait for clickable by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/input[@id="text"]' });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ xpath: './/input[@id="text"]' })
+    })
 
     it('should fail for disabled element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #button still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #button still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for disabled element by XPath', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ xpath: './/button[@id="button"]' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ xpath: './/button[@id="button"]' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element .//button[@id="button"] still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by top', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportTop' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportTop' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportTop still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by bottom', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportBottom' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportBottom' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportBottom still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by left', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportLeft' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportLeft' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportLeft still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for element not in viewport by right', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#notInViewportRight' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec');
-      });
-    });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd
+        .waitForClickable({ css: '#notInViewportRight' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #notInViewportRight still not clickable after 0.1 sec')
+        })
+    })
 
     it('should fail for overlapping element', async () => {
-      await wd.amOnPage('/form/wait_for_clickable');
-      await wd.waitForClickable({ css: '#div2_button' }, 0.1);
-      await wd.waitForClickable({ css: '#div1_button' }, 0.1).then((isClickable) => {
-        if (isClickable) throw new Error('Element is clickable, but must be unclickable');
-      }).catch((e) => {
-        e.message.should.include('element #div1_button still not clickable after 0.1 sec');
-      });
-    });
-  });
+      await wd.amOnPage('/form/wait_for_clickable')
+      await wd.waitForClickable({ css: '#div2_button' }, 0.1)
+      await wd
+        .waitForClickable({ css: '#div1_button' }, 0.1)
+        .then((isClickable) => {
+          if (isClickable) throw new Error('Element is clickable, but must be unclickable')
+        })
+        .catch((e) => {
+          e.message.should.include('element #div1_button still not clickable after 0.1 sec')
+        })
+    })
+  })
 
   describe('GeoLocation', () => {
     // deprecated JSON Wire method commands
     it.skip('should set the geoLocation', async () => {
-      await wd.setGeoLocation(37.4043, -122.0748);
-      const geoLocation = await wd.grabGeoLocation();
-      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set');
-      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set');
-    });
-  });
+      await wd.setGeoLocation(37.4043, -122.0748)
+      const geoLocation = await wd.grabGeoLocation()
+      assert.equal(geoLocation.latitude, 37.4043, 'The latitude is not properly set')
+      assert.equal(geoLocation.longitude, -122.0748, 'The longitude is not properly set')
+    })
+  })
 
   describe('#grabElementBoundingRect', () => {
     it('should get the element size', async () => {
-      await wd.amOnPage('/form/hidden');
-      const size = await wd.grabElementBoundingRect('input[type=submit]');
-      expect(size.x).is.greaterThan(0);
-      expect(size.y).is.greaterThan(0);
-      expect(size.width).is.greaterThan(0);
-      expect(size.height).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const size = await wd.grabElementBoundingRect('input[type=submit]')
+      expect(size.x).is.greaterThan(0)
+      expect(size.y).is.greaterThan(0)
+      expect(size.width).is.greaterThan(0)
+      expect(size.height).is.greaterThan(0)
+    })
 
     it('should get the element width', async () => {
-      await wd.amOnPage('/form/hidden');
-      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width');
-      expect(width).is.greaterThan(0);
-    });
+      await wd.amOnPage('/form/hidden')
+      const width = await wd.grabElementBoundingRect('input[type=submit]', 'width')
+      expect(width).is.greaterThan(0)
+    })
 
     it('should get the element height', async () => {
-      await wd.amOnPage('/form/hidden');
-      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height');
-      expect(height).is.greaterThan(0);
-    });
-  });
+      await wd.amOnPage('/form/hidden')
+      const height = await wd.grabElementBoundingRect('input[type=submit]', 'height')
+      expect(height).is.greaterThan(0)
+    })
+  })
 
   describe('#scrollIntoView', () => {
     it.skip('should scroll element into viewport', async () => {
-      await wd.amOnPage('/form/scroll_into_view');
-      const element = await wd.browser.$('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.false;
-      await wd.scrollIntoView('#notInViewportByDefault');
-      expect(await element.isDisplayedInViewport()).to.be.true;
-    });
-  });
+      await wd.amOnPage('/form/scroll_into_view')
+      const element = await wd.browser.$('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.false
+      await wd.scrollIntoView('#notInViewportByDefault')
+      expect(await element.isDisplayedInViewport()).to.be.true
+    })
+  })
 
   describe('#useWebDriverTo', () => {
     it('should return title', async () => {
-      await wd.amOnPage('/');
+      await wd.amOnPage('/')
       const title = await wd.useWebDriverTo('test', async ({ browser }) => {
-        return browser.getTitle();
-      });
-      assert.equal('TestEd Beta 2.0', title);
-    });
-  });
-});
+        return browser.getTitle()
+      })
+      assert.equal('TestEd Beta 2.0', title)
+    })
+  })
+})
 
 describe('WebDriver - Basic Authentication', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data');
+    global.codecept_dir = path.join(__dirname, '/../data')
     try {
-      fs.unlinkSync(dataFile);
+      fs.unlinkSync(dataFile)
     } catch (err) {
       // continue regardless of error
     }
@@ -1246,20 +1297,20 @@ describe('WebDriver - Basic Authentication', () => {
           args: ['--headless', '--disable-gpu', '--window-size=1280,1024'],
         },
       },
-    });
-  });
+    })
+  })
 
   beforeEach(async () => {
-    webApiTests.init({ I: wd, siteUrl });
-    await wd._before();
-  });
+    webApiTests.init({ I: wd, siteUrl })
+    await wd._before()
+  })
 
-  afterEach(() => wd._after());
+  afterEach(() => wd._after())
 
   describe('open page : #amOnPage', () => {
     it('should be authenticated', async () => {
-      await wd.amOnPage('/basic_auth');
-      await wd.see('You entered admin as your password.');
-    });
-  });
-});
+      await wd.amOnPage('/basic_auth')
+      await wd.see('You entered admin as your password.')
+    })
+  })
+})
diff --git a/test/helper/webapi.js b/test/helper/webapi.js
index 413e95037..7d01fb482 100644
--- a/test/helper/webapi.js
+++ b/test/helper/webapi.js
@@ -1,1779 +1,1813 @@
-let expect;
-let assert;
-import('chai').then(chai => {
-  expect = chai.expect;
-  assert = chai.assert;
-});
-const path = require('path');
-
-const dataFile = path.join(__dirname, '/../data/app/db');
-const formContents = require('../../lib/utils').test.submittedData(dataFile);
-const fileExists = require('../../lib/utils').fileExists;
-const secret = require('../../lib/secret').secret;
-
-const Locator = require('../../lib/locator');
-const customLocators = require('../../lib/plugin/customLocator');
-
-let originalLocators;
-let I;
-let data;
-let siteUrl;
+let expect
+let assert
+import('chai').then((chai) => {
+  expect = chai.expect
+  assert = chai.assert
+})
+const path = require('path')
+
+const dataFile = path.join(__dirname, '/../data/app/db')
+const formContents = require('../../lib/utils').test.submittedData(dataFile)
+const fileExists = require('../../lib/utils').fileExists
+const secret = require('../../lib/secret').secret
+
+const Locator = require('../../lib/locator')
+const customLocators = require('../../lib/plugin/customLocator')
+
+let originalLocators
+let I
+let data
+let siteUrl
 
 module.exports.init = function (testData) {
-  data = testData;
-};
+  data = testData
+}
 
 module.exports.tests = function () {
-  const isHelper = helperName => I.constructor.name === helperName;
+  const isHelper = (helperName) => I.constructor.name === helperName
 
   beforeEach(() => {
-    I = data.I;
-    siteUrl = data.siteUrl;
-    if (fileExists(dataFile)) require('fs').unlinkSync(dataFile);
-  });
+    I = data.I
+    siteUrl = data.siteUrl
+    if (fileExists(dataFile)) require('fs').unlinkSync(dataFile)
+  })
 
   describe('#saveElementScreenshot', () => {
     beforeEach(() => {
-      global.output_dir = path.join(global.codecept_dir, 'output');
-    });
+      global.output_dir = path.join(global.codecept_dir, 'output')
+    })
 
     it('should create a screenshot file in output dir of element', async () => {
-      await I.amOnPage('/form/field');
-      await I.seeElement('input[name=\'name\']');
-      const sec = (new Date()).getUTCMilliseconds();
-      await I.saveElementScreenshot('input[name=\'name\']', `element_screenshot_${sec}.png`);
-      assert.ok(fileExists(path.join(global.output_dir, `element_screenshot_${sec}.png`)), null, 'file does not exists');
-    });
-  });
+      await I.amOnPage('/form/field')
+      await I.seeElement("input[name='name']")
+      const sec = new Date().getUTCMilliseconds()
+      await I.saveElementScreenshot("input[name='name']", `element_screenshot_${sec}.png`)
+      assert.ok(fileExists(path.join(global.output_dir, `element_screenshot_${sec}.png`)), null, 'file does not exists')
+    })
+  })
 
   describe('current url : #seeInCurrentUrl, #seeCurrentUrlEquals, #grabCurrentUrl, ...', () => {
     it('should check for url fragment', async () => {
-      await I.amOnPage('/form/checkbox');
-      await I.seeInCurrentUrl('/form');
-      await I.dontSeeInCurrentUrl('/user');
-    });
+      await I.amOnPage('/form/checkbox')
+      await I.seeInCurrentUrl('/form')
+      await I.dontSeeInCurrentUrl('/user')
+    })
 
     it('should check for equality', async () => {
-      await I.amOnPage('/info');
-      await I.seeCurrentUrlEquals('/info');
-      await I.dontSeeCurrentUrlEquals('form');
-    });
+      await I.amOnPage('/info')
+      await I.seeCurrentUrlEquals('/info')
+      await I.dontSeeCurrentUrlEquals('form')
+    })
 
     it('should check for equality in absolute urls', async () => {
-      await I.amOnPage('/info');
-      await I.seeCurrentUrlEquals(`${siteUrl}/info`);
-      await I.dontSeeCurrentUrlEquals(`${siteUrl}/form`);
-    });
+      await I.amOnPage('/info')
+      await I.seeCurrentUrlEquals(`${siteUrl}/info`)
+      await I.dontSeeCurrentUrlEquals(`${siteUrl}/form`)
+    })
 
     it('should grab browser url', async () => {
-      await I.amOnPage('/info');
-      const url = await I.grabCurrentUrl();
-      assert.equal(url, `${siteUrl}/info`);
-    });
-  });
+      await I.amOnPage('/info')
+      const url = await I.grabCurrentUrl()
+      assert.equal(url, `${siteUrl}/info`)
+    })
+  })
 
   describe('#waitInUrl, #waitUrlEquals', () => {
     it('should wait part of the URL to match the expected', async () => {
       try {
-        await I.amOnPage('/info');
-        await I.waitInUrl('/info');
-        await I.waitInUrl('/info2', 0.1);
+        await I.amOnPage('/info')
+        await I.waitInUrl('/info')
+        await I.waitInUrl('/info2', 0.1)
       } catch (e) {
-        assert.include(e.message, `expected url to include /info2, but found ${siteUrl}/info`);
+        assert.include(e.message, `expected url to include /info2, but found ${siteUrl}/info`)
       }
-    });
+    })
 
     it('should wait for the entire URL to match the expected', async () => {
       try {
-        await I.amOnPage('/info');
-        await I.waitUrlEquals('/info');
-        await I.waitUrlEquals(`${siteUrl}/info`);
-        await I.waitUrlEquals('/info2', 0.1);
+        await I.amOnPage('/info')
+        await I.waitUrlEquals('/info')
+        await I.waitUrlEquals(`${siteUrl}/info`)
+        await I.waitUrlEquals('/info2', 0.1)
       } catch (e) {
-        assert.include(e.message, `expected url to be ${siteUrl}/info2, but found ${siteUrl}/info`);
+        assert.include(e.message, `expected url to be ${siteUrl}/info2, but found ${siteUrl}/info`)
       }
-    });
-  });
+    })
+  })
 
   describe('see text : #see', () => {
     it('should check text on site', async () => {
-      await I.amOnPage('/');
-      await I.see('Welcome to test app!');
-      await I.see('A wise man said: "debug!"');
-      await I.dontSee('Info');
-    });
+      await I.amOnPage('/')
+      await I.see('Welcome to test app!')
+      await I.see('A wise man said: "debug!"')
+      await I.dontSee('Info')
+    })
 
     it('should check text inside element', async () => {
-      await I.amOnPage('/');
-      await I.see('Welcome to test app!', 'h1');
-      await I.amOnPage('/info');
-      await I.see('valuable', { css: 'p' });
-      await I.see('valuable', '//p');
-      await I.dontSee('valuable', 'h1');
-    });
+      await I.amOnPage('/')
+      await I.see('Welcome to test app!', 'h1')
+      await I.amOnPage('/info')
+      await I.see('valuable', { css: 'p' })
+      await I.see('valuable', '//p')
+      await I.dontSee('valuable', 'h1')
+    })
 
     it('should verify non-latin chars', async () => {
-      await I.amOnPage('/info');
-      await I.see('на');
-      await I.see("Don't do that at home!", 'h3');
-      await I.see('Текст', 'p');
-    });
+      await I.amOnPage('/info')
+      await I.see('на')
+      await I.see("Don't do that at home!", 'h3')
+      await I.see('Текст', 'p')
+    })
 
     it('should verify text with &nbsp', async () => {
-      if (isHelper('TestCafe') || isHelper('WebDriver')) return;
-      await I.amOnPage('/');
-      await I.see('With special space chars');
-    });
-  });
+      if (isHelper('TestCafe') || isHelper('WebDriver')) return
+      await I.amOnPage('/')
+      await I.see('With special space chars')
+    })
+  })
 
   describe('see element : #seeElement, #seeElementInDOM, #dontSeeElement', () => {
     it('should check visible elements on page', async () => {
-      await I.amOnPage('/form/field');
-      await I.seeElement('input[name=name]');
-      await I.seeElement({ name: 'name' });
-      await I.seeElement('//input[@id="name"]');
-      await I.dontSeeElement('#something-beyond');
-      await I.dontSeeElement('//input[@id="something-beyond"]');
-      await I.dontSeeElement({ name: 'noname' });
-      await I.dontSeeElement('#noid');
-    });
+      await I.amOnPage('/form/field')
+      await I.seeElement('input[name=name]')
+      await I.seeElement({ name: 'name' })
+      await I.seeElement('//input[@id="name"]')
+      await I.dontSeeElement('#something-beyond')
+      await I.dontSeeElement('//input[@id="something-beyond"]')
+      await I.dontSeeElement({ name: 'noname' })
+      await I.dontSeeElement('#noid')
+    })
 
     it('should check elements are in the DOM', async () => {
-      await I.amOnPage('/form/field');
-      await I.seeElementInDOM('input[name=name]');
-      await I.seeElementInDOM('//input[@id="name"]');
-      await I.seeElementInDOM({ name: 'noname' });
-      await I.seeElementInDOM('#noid');
-      await I.dontSeeElementInDOM('#something-beyond');
-      await I.dontSeeElementInDOM('//input[@id="something-beyond"]');
-    });
+      await I.amOnPage('/form/field')
+      await I.seeElementInDOM('input[name=name]')
+      await I.seeElementInDOM('//input[@id="name"]')
+      await I.seeElementInDOM({ name: 'noname' })
+      await I.seeElementInDOM('#noid')
+      await I.dontSeeElementInDOM('#something-beyond')
+      await I.dontSeeElementInDOM('//input[@id="something-beyond"]')
+    })
 
     it('should check elements are visible on the page', async () => {
-      await I.amOnPage('/form/field');
-      await I.seeElementInDOM('input[name=email]');
-      await I.dontSeeElement('input[name=email]');
-      await I.dontSeeElement('#something-beyond');
-    });
-  });
+      await I.amOnPage('/form/field')
+      await I.seeElementInDOM('input[name=email]')
+      await I.dontSeeElement('input[name=email]')
+      await I.dontSeeElement('#something-beyond')
+    })
+  })
 
   describe('#seeNumberOfVisibleElements', () => {
     it('should check number of visible elements for given locator', async () => {
-      await I.amOnPage('/info');
-      await I.seeNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3);
-    });
-  });
+      await I.amOnPage('/info')
+      await I.seeNumberOfVisibleElements('//div[@id = "grab-multiple"]//a', 3)
+    })
+  })
 
   describe('#grabNumberOfVisibleElements', () => {
     it('should grab number of visible elements for given locator', async () => {
-      await I.amOnPage('/info');
-      const num = await I.grabNumberOfVisibleElements('//div[@id = "grab-multiple"]//a');
-      assert.equal(num, 3);
-    });
+      await I.amOnPage('/info')
+      const num = await I.grabNumberOfVisibleElements('//div[@id = "grab-multiple"]//a')
+      assert.equal(num, 3)
+    })
 
     it('should support locators like {xpath:"//div"}', async () => {
-      await I.amOnPage('/info');
+      await I.amOnPage('/info')
       const num = await I.grabNumberOfVisibleElements({
         xpath: '//div[@id = "grab-multiple"]//a',
-      });
-      assert.equal(num, 3);
-    });
+      })
+      assert.equal(num, 3)
+    })
 
     it('should grab number of visible elements for given css locator', async () => {
-      await I.amOnPage('/info');
-      const num = await I.grabNumberOfVisibleElements('[id=grab-multiple] a');
-      assert.equal(num, 3);
-    });
+      await I.amOnPage('/info')
+      const num = await I.grabNumberOfVisibleElements('[id=grab-multiple] a')
+      assert.equal(num, 3)
+    })
 
     it('should return 0 for non-existing elements', async () => {
-      await I.amOnPage('/info');
-      const num = await I.grabNumberOfVisibleElements('button[type=submit]');
-      assert.equal(num, 0);
-    });
+      await I.amOnPage('/info')
+      const num = await I.grabNumberOfVisibleElements('button[type=submit]')
+      assert.equal(num, 0)
+    })
 
     it('should honor visibility hidden style', async () => {
-      await I.amOnPage('/info');
-      const num = await I.grabNumberOfVisibleElements('.issue2928');
-      assert.equal(num, 1);
-    });
-  });
+      await I.amOnPage('/info')
+      const num = await I.grabNumberOfVisibleElements('.issue2928')
+      assert.equal(num, 1)
+    })
+  })
 
   describe('#seeInSource, #dontSeeInSource', () => {
     it('should check meta of a page', async () => {
-      await I.amOnPage('/info');
-      await I.seeInSource('<body>');
-      await I.dontSeeInSource('<meta>');
-      await I.seeInSource('Invisible text');
-      await I.seeInSource('content="text/html; charset=utf-8"');
-    });
-  });
+      await I.amOnPage('/info')
+      await I.seeInSource('<body>')
+      await I.dontSeeInSource('<meta>')
+      await I.seeInSource('Invisible text')
+      await I.seeInSource('content="text/html; charset=utf-8"')
+    })
+  })
 
   describe('#click', () => {
     it('should click by inner text', async () => {
-      await I.amOnPage('/');
-      await I.click('More info');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.click('More info')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click by css', async () => {
-      await I.amOnPage('/');
-      await I.click('#link');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.click('#link')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click by xpath', async () => {
-      await I.amOnPage('/');
-      await I.click('//a[@id="link"]');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.click('//a[@id="link"]')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click by name', async () => {
-      await I.amOnPage('/form/button');
-      await I.click('btn0');
-      assert.equal(formContents('text'), 'val');
-    });
+      await I.amOnPage('/form/button')
+      await I.click('btn0')
+      assert.equal(formContents('text'), 'val')
+    })
 
     it('should click on context', async () => {
-      await I.amOnPage('/');
-      await I.click('More info', 'body>p');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.click('More info', 'body>p')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should not click wrong context', async () => {
-      let err = false;
-      await I.amOnPage('/');
+      let err = false
+      await I.amOnPage('/')
       try {
-        await I.click('More info', '#area1');
+        await I.click('More info', '#area1')
       } catch (e) {
-        err = true;
+        err = true
       }
 
-      assert.ok(err);
-    });
+      assert.ok(err)
+    })
 
     it('should should click by aria-label', async () => {
-      await I.amOnPage('/form/aria');
-      await I.click('get info');
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/form/aria')
+      await I.click('get info')
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should click link with inner span', async () => {
-      await I.amOnPage('/form/example7');
-      await I.click('Buy Chocolate Bar');
-      await I.seeCurrentUrlEquals('/');
-    });
+      await I.amOnPage('/form/example7')
+      await I.click('Buy Chocolate Bar')
+      await I.seeCurrentUrlEquals('/')
+    })
 
     it('should click link with xpath locator', async () => {
-      await I.amOnPage('/form/example7');
+      await I.amOnPage('/form/example7')
       await I.click({
         xpath: '(//*[@title = "Chocolate Bar"])[1]',
-      });
-      await I.seeCurrentUrlEquals('/');
-    });
-  });
+      })
+      await I.seeCurrentUrlEquals('/')
+    })
+  })
 
   describe('#forceClick', () => {
     beforeEach(function () {
-      if (isHelper('TestCafe')) this.skip();
-    });
+      if (isHelper('TestCafe')) this.skip()
+    })
 
     it('should forceClick by inner text', async () => {
-      await I.amOnPage('/');
-      await I.forceClick('More info');
-      if (isHelper('Puppeteer')) await I.waitForNavigation();
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.forceClick('More info')
+      if (isHelper('Puppeteer')) await I.waitForNavigation()
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should forceClick by css', async () => {
-      await I.amOnPage('/');
-      await I.forceClick('#link');
-      if (isHelper('Puppeteer')) await I.waitForNavigation();
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.forceClick('#link')
+      if (isHelper('Puppeteer')) await I.waitForNavigation()
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should forceClick by xpath', async () => {
-      await I.amOnPage('/');
-      await I.forceClick('//a[@id="link"]');
-      if (isHelper('Puppeteer')) await I.waitForNavigation();
-      await I.seeInCurrentUrl('/info');
-    });
+      await I.amOnPage('/')
+      await I.forceClick('//a[@id="link"]')
+      if (isHelper('Puppeteer')) await I.waitForNavigation()
+      await I.seeInCurrentUrl('/info')
+    })
 
     it('should forceClick on context', async () => {
-      await I.amOnPage('/');
-      await I.forceClick('More info', 'body>p');
-      if (isHelper('Puppeteer')) await I.waitForNavigation();
-      await I.seeInCurrentUrl('/info');
-    });
-  });
+      await I.amOnPage('/')
+      await I.forceClick('More info', 'body>p')
+      if (isHelper('Puppeteer')) await I.waitForNavigation()
+      await I.seeInCurrentUrl('/info')
+    })
+  })
 
   // Could not get double click to work
   describe('#doubleClick', () => {
     it('it should doubleClick', async () => {
-      await I.amOnPage('/form/doubleclick');
-      await I.dontSee('Done');
-      await I.doubleClick('#block');
-      await I.see('Done');
-    });
-  });
+      await I.amOnPage('/form/doubleclick')
+      await I.dontSee('Done')
+      await I.doubleClick('#block')
+      await I.see('Done')
+    })
+  })
 
   // rightClick does not seem to work either
   describe('#rightClick', () => {
     it('it should rightClick', async () => {
-      await I.amOnPage('/form/rightclick');
-      await I.dontSee('right clicked');
-      await I.rightClick('Lorem Ipsum');
-      await I.see('right clicked');
-    });
+      await I.amOnPage('/form/rightclick')
+      await I.dontSee('right clicked')
+      await I.rightClick('Lorem Ipsum')
+      await I.see('right clicked')
+    })
 
     it('it should rightClick by locator', async () => {
-      await I.amOnPage('/form/rightclick');
-      await I.dontSee('right clicked');
-      await I.rightClick('.context a');
-      await I.see('right clicked');
-    });
+      await I.amOnPage('/form/rightclick')
+      await I.dontSee('right clicked')
+      await I.rightClick('.context a')
+      await I.see('right clicked')
+    })
 
     it('it should rightClick by locator and context', async () => {
-      await I.amOnPage('/form/rightclick');
-      await I.dontSee('right clicked');
-      await I.rightClick('Lorem Ipsum', '.context');
-      await I.see('right clicked');
-    });
-  });
+      await I.amOnPage('/form/rightclick')
+      await I.dontSee('right clicked')
+      await I.rightClick('Lorem Ipsum', '.context')
+      await I.see('right clicked')
+    })
+  })
 
   describe('#checkOption', () => {
     it('should check option by css', async () => {
-      await I.amOnPage('/form/checkbox');
-      await I.checkOption('#checkin');
-      await I.click('Submit');
-      await I.wait(1);
-      assert.equal(formContents('terms'), 'agree');
-    });
+      await I.amOnPage('/form/checkbox')
+      await I.checkOption('#checkin')
+      await I.click('Submit')
+      await I.wait(1)
+      assert.equal(formContents('terms'), 'agree')
+    })
 
     it('should check option by strict locator', async () => {
-      await I.amOnPage('/form/checkbox');
+      await I.amOnPage('/form/checkbox')
       await I.checkOption({
         id: 'checkin',
-      });
-      await I.click('Submit');
-      assert.equal(formContents('terms'), 'agree');
-    });
+      })
+      await I.click('Submit')
+      assert.equal(formContents('terms'), 'agree')
+    })
 
     it('should check option by name', async () => {
-      await I.amOnPage('/form/checkbox');
-      await I.checkOption('terms');
-      await I.click('Submit');
-      assert.equal(formContents('terms'), 'agree');
-    });
+      await I.amOnPage('/form/checkbox')
+      await I.checkOption('terms')
+      await I.click('Submit')
+      assert.equal(formContents('terms'), 'agree')
+    })
 
     it('should check option by label', async () => {
-      await I.amOnPage('/form/checkbox');
-      await I.checkOption('I Agree');
-      await I.click('Submit');
-      assert.equal(formContents('terms'), 'agree');
-    });
+      await I.amOnPage('/form/checkbox')
+      await I.checkOption('I Agree')
+      await I.click('Submit')
+      assert.equal(formContents('terms'), 'agree')
+    })
 
     // TODO Having problems with functional style selectors in testcafe
     // cannot do Selector(css).find(elementByXPath(xpath))
     // testcafe always says "xpath is not defined"
     // const el = Selector(context).find(elementByXPath(Locator.checkable.byText(xpathLocator.literal(field))).with({ boundTestRun: this.t })).with({ boundTestRun: this.t });
     it.skip('should check option by context', async () => {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/example1');
-      await I.checkOption('Remember me next time', '.rememberMe');
-      await I.click('Login');
-      assert.equal(formContents('LoginForm').rememberMe, 1);
-    });
-  });
+      await I.amOnPage('/form/example1')
+      await I.checkOption('Remember me next time', '.rememberMe')
+      await I.click('Login')
+      assert.equal(formContents('LoginForm').rememberMe, 1)
+    })
+  })
 
   describe('#uncheckOption', () => {
     it('should uncheck option that is currently checked', async () => {
-      await I.amOnPage('/info');
-      await I.uncheckOption('interesting');
-      await I.dontSeeCheckboxIsChecked('interesting');
-    });
-  });
+      await I.amOnPage('/info')
+      await I.uncheckOption('interesting')
+      await I.dontSeeCheckboxIsChecked('interesting')
+    })
+  })
 
   describe('#selectOption', () => {
     it('should select option by css', async () => {
-      await I.amOnPage('/form/select');
-      await I.selectOption('form select[name=age]', 'adult');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'adult');
-    });
+      await I.amOnPage('/form/select')
+      await I.selectOption('form select[name=age]', 'adult')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'adult')
+    })
 
     it('should select option by name', async () => {
-      await I.amOnPage('/form/select');
-      await I.selectOption('age', 'adult');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'adult');
-    });
+      await I.amOnPage('/form/select')
+      await I.selectOption('age', 'adult')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'adult')
+    })
 
     it('should select option by label', async () => {
-      await I.amOnPage('/form/select');
-      await I.selectOption('Select your age', 'dead');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'dead');
-    });
+      await I.amOnPage('/form/select')
+      await I.selectOption('Select your age', 'dead')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'dead')
+    })
 
     it('should select option by label and option text', async () => {
-      await I.amOnPage('/form/select');
-      await I.selectOption('Select your age', '21-60');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'adult');
-    });
+      await I.amOnPage('/form/select')
+      await I.selectOption('Select your age', '21-60')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'adult')
+    })
 
     it('should select option by label and option text - with an onchange callback', async () => {
-      await I.amOnPage('/form/select_onchange');
-      await I.selectOption('Select a value', 'Option 2');
-      await I.click('Submit');
-      assert.equal(formContents('select'), 'option2');
-    });
+      await I.amOnPage('/form/select_onchange')
+      await I.selectOption('Select a value', 'Option 2')
+      await I.click('Submit')
+      assert.equal(formContents('select'), 'option2')
+    })
 
     // Could not get multiselect to work with testcafe
     it('should select multiple options', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/select_multiple');
-      await I.selectOption('What do you like the most?', ['Play Video Games', 'Have Sex']);
-      await I.click('Submit');
-      assert.deepEqual(formContents('like'), ['play', 'adult']);
-    });
+      await I.amOnPage('/form/select_multiple')
+      await I.selectOption('What do you like the most?', ['Play Video Games', 'Have Sex'])
+      await I.click('Submit')
+      assert.deepEqual(formContents('like'), ['play', 'adult'])
+    })
 
     it('should select option by label and option text with additional spaces', async () => {
-      await I.amOnPage('/form/select_additional_spaces');
-      await I.selectOption('Select your age', '21-60');
-      await I.click('Submit');
-      assert.equal(formContents('age'), 'adult');
-    });
-  });
+      await I.amOnPage('/form/select_additional_spaces')
+      await I.selectOption('Select your age', '21-60')
+      await I.click('Submit')
+      assert.equal(formContents('age'), 'adult')
+    })
+  })
 
   describe('#executeScript', () => {
     it('should execute synchronous script', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       await I.executeScript(() => {
-        document.getElementById('link').innerHTML = 'Appended';
-      });
-      await I.see('Appended', 'a');
-    });
+        document.getElementById('link').innerHTML = 'Appended'
+      })
+      await I.see('Appended', 'a')
+    })
 
     it('should return value from sync script', async () => {
-      await I.amOnPage('/');
-      const val = await I.executeScript(a => a + 5, 5);
-      assert.equal(val, 10);
-    });
+      await I.amOnPage('/')
+      const val = await I.executeScript((a) => a + 5, 5)
+      assert.equal(val, 10)
+    })
 
     it('should return value from sync script in iframe', async function () {
       // TODO Not yet implemented
-      if (isHelper('TestCafe')) this.skip(); // TODO Not yet implemented
+      if (isHelper('TestCafe')) this.skip() // TODO Not yet implemented
 
-      await I.amOnPage('/iframe');
-      await I.switchTo({ css: 'iframe' });
-      const val = await I.executeScript(() => document.getElementsByTagName('h1')[0].innerText);
-      assert.equal(val, 'Information');
-    });
+      await I.amOnPage('/iframe')
+      await I.switchTo({ css: 'iframe' })
+      const val = await I.executeScript(() => document.getElementsByTagName('h1')[0].innerText)
+      assert.equal(val, 'Information')
+    })
 
     it('should execute async script', async function () {
-      if (isHelper('TestCafe')) this.skip(); // TODO Not yet implemented
-      if (isHelper('Playwright')) return; // It won't be implemented
+      if (isHelper('TestCafe')) this.skip() // TODO Not yet implemented
+      if (isHelper('Playwright')) return // It won't be implemented
 
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       const val = await I.executeAsyncScript((val, done) => {
         setTimeout(() => {
-          document.getElementById('link').innerHTML = val;
-          done(5);
-        }, 100);
-      }, 'Timeout');
-      assert.equal(val, 5);
-      await I.see('Timeout', 'a');
-    });
-  });
+          document.getElementById('link').innerHTML = val
+          done(5)
+        }, 100)
+      }, 'Timeout')
+      assert.equal(val, 5)
+      await I.see('Timeout', 'a')
+    })
+  })
 
   describe('#fillField, #appendField', () => {
     it('should fill input fields', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', 'Nothing special');
-      await I.click('Submit');
-      assert.equal(formContents('name'), 'Nothing special');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', 'Nothing special')
+      await I.click('Submit')
+      assert.equal(formContents('name'), 'Nothing special')
+    })
 
     it('should fill input fields with secrets', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', secret('Something special'));
-      await I.click('Submit');
-      assert.equal(formContents('name'), 'Something special');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', secret('Something special'))
+      await I.click('Submit')
+      assert.equal(formContents('name'), 'Something special')
+    })
 
     it('should fill field by css', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('#name', 'Nothing special');
-      await I.click('Submit');
-      assert.equal(formContents('name'), 'Nothing special');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('#name', 'Nothing special')
+      await I.click('Submit')
+      assert.equal(formContents('name'), 'Nothing special')
+    })
 
     it('should fill field by strict locator', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField({
-        id: 'name',
-      }, 'Nothing special');
-      await I.click('Submit');
-      assert.equal(formContents('name'), 'Nothing special');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField(
+        {
+          id: 'name',
+        },
+        'Nothing special',
+      )
+      await I.click('Submit')
+      assert.equal(formContents('name'), 'Nothing special')
+    })
 
     it('should fill field by name', async () => {
-      await I.amOnPage('/form/example1');
-      await I.fillField('LoginForm[username]', 'davert');
-      await I.fillField('LoginForm[password]', '123456');
-      await I.click('Login');
-      assert.equal(formContents('LoginForm').username, 'davert');
-      assert.equal(formContents('LoginForm').password, '123456');
-    });
+      await I.amOnPage('/form/example1')
+      await I.fillField('LoginForm[username]', 'davert')
+      await I.fillField('LoginForm[password]', '123456')
+      await I.click('Login')
+      assert.equal(formContents('LoginForm').username, 'davert')
+      assert.equal(formContents('LoginForm').password, '123456')
+    })
 
     it('should fill textarea by css', async () => {
-      await I.amOnPage('/form/textarea');
-      await I.fillField('textarea', 'Nothing special');
-      await I.click('Submit');
-      assert.equal(formContents('description'), 'Nothing special');
-    });
+      await I.amOnPage('/form/textarea')
+      await I.fillField('textarea', 'Nothing special')
+      await I.click('Submit')
+      assert.equal(formContents('description'), 'Nothing special')
+    })
 
     it('should fill textarea by label', async () => {
-      await I.amOnPage('/form/textarea');
-      await I.fillField('Description', 'Nothing special');
-      await I.click('Submit');
-      assert.equal(formContents('description'), 'Nothing special');
-    });
+      await I.amOnPage('/form/textarea')
+      await I.fillField('Description', 'Nothing special')
+      await I.click('Submit')
+      assert.equal(formContents('description'), 'Nothing special')
+    })
 
     it('should fill input by aria-label and aria-labelledby', async () => {
-      await I.amOnPage('/form/aria');
-      await I.fillField('My Address', 'Home Sweet Home');
-      await I.fillField('Phone', '123456');
-      await I.click('Submit');
-      assert.equal(formContents('my-form-phone'), '123456');
-      assert.equal(formContents('my-form-address'), 'Home Sweet Home');
-    });
+      await I.amOnPage('/form/aria')
+      await I.fillField('My Address', 'Home Sweet Home')
+      await I.fillField('Phone', '123456')
+      await I.click('Submit')
+      assert.equal(formContents('my-form-phone'), '123456')
+      assert.equal(formContents('my-form-address'), 'Home Sweet Home')
+    })
 
     it('should fill textarea by overwritting the existing value', async () => {
-      await I.amOnPage('/form/textarea');
-      await I.fillField('Description', 'Nothing special');
-      await I.fillField('Description', 'Some other text');
-      await I.click('Submit');
-      assert.equal(formContents('description'), 'Some other text');
-    });
+      await I.amOnPage('/form/textarea')
+      await I.fillField('Description', 'Nothing special')
+      await I.fillField('Description', 'Some other text')
+      await I.click('Submit')
+      assert.equal(formContents('description'), 'Some other text')
+    })
 
     it('should append field value', async () => {
-      await I.amOnPage('/form/field');
-      await I.appendField('Name', '_AND_NEW');
-      await I.click('Submit');
-      assert.equal(formContents('name'), 'OLD_VALUE_AND_NEW');
-    });
+      await I.amOnPage('/form/field')
+      await I.appendField('Name', '_AND_NEW')
+      await I.click('Submit')
+      assert.equal(formContents('name'), 'OLD_VALUE_AND_NEW')
+    })
 
     it.skip('should not fill invisible fields', async () => {
-      if (isHelper('Playwright')) return; // It won't be implemented
-      await I.amOnPage('/form/field');
+      if (isHelper('Playwright')) return // It won't be implemented
+      await I.amOnPage('/form/field')
       try {
-        I.fillField('email', 'test@1234');
+        I.fillField('email', 'test@1234')
       } catch (e) {
-        await assert.equal(e.message, 'Error: Field "email" was not found by text|CSS|XPath');
+        await assert.equal(e.message, 'Error: Field "email" was not found by text|CSS|XPath')
       }
-    });
-  });
+    })
+  })
 
   describe('#clearField', () => {
     it('should clear a given element', async () => {
-      await I.amOnPage('/form/field');
-      await I.fillField('#name', 'Nothing special');
-      await I.seeInField('#name', 'Nothing special');
-      await I.clearField('#name');
-      await I.dontSeeInField('#name', 'Nothing special');
-    });
+      await I.amOnPage('/form/field')
+      await I.fillField('#name', 'Nothing special')
+      await I.seeInField('#name', 'Nothing special')
+      await I.clearField('#name')
+      await I.dontSeeInField('#name', 'Nothing special')
+    })
 
     it('should clear field by name', async () => {
-      await I.amOnPage('/form/example1');
-      await I.clearField('LoginForm[username]');
-      await I.click('Login');
-      assert.equal(formContents('LoginForm').username, '');
-    });
+      await I.amOnPage('/form/example1')
+      await I.clearField('LoginForm[username]')
+      await I.click('Login')
+      assert.equal(formContents('LoginForm').username, '')
+    })
 
     it('should clear field by locator', async () => {
-      await I.amOnPage('/form/example1');
-      await I.clearField('#LoginForm_username');
-      await I.click('Login');
-      assert.equal(formContents('LoginForm').username, '');
-    });
-  });
+      await I.amOnPage('/form/example1')
+      await I.clearField('#LoginForm_username')
+      await I.click('Login')
+      assert.equal(formContents('LoginForm').username, '')
+    })
+  })
 
   describe('#type', () => {
     it('should type into a field', async function () {
-      if (isHelper('TestCafe')) this.skip();
-      await I.amOnPage('/form/field');
-      await I.click('Name');
+      if (isHelper('TestCafe')) this.skip()
+      await I.amOnPage('/form/field')
+      await I.click('Name')
 
-      await I.type('Type Test');
-      await I.seeInField('Name', 'Type Test');
+      await I.type('Type Test')
+      await I.seeInField('Name', 'Type Test')
 
-      await I.fillField('Name', '');
+      await I.fillField('Name', '')
 
-      await I.type(['T', 'y', 'p', 'e', '2']);
-      await I.seeInField('Name', 'Type2');
-    });
+      await I.type(['T', 'y', 'p', 'e', '2'])
+      await I.seeInField('Name', 'Type2')
+    })
 
     it('should use delay to slow down typing', async function () {
-      if (isHelper('TestCafe')) this.skip();
-      await I.amOnPage('/form/field');
-      await I.fillField('Name', '');
-      const time = Date.now();
-      await I.type('12345', 100);
-      await I.seeInField('Name', '12345');
-      assert(Date.now() - time > 500);
-    });
-  });
+      if (isHelper('TestCafe')) this.skip()
+      await I.amOnPage('/form/field')
+      await I.fillField('Name', '')
+      const time = Date.now()
+      await I.type('12345', 100)
+      await I.seeInField('Name', '12345')
+      assert(Date.now() - time > 500)
+    })
+  })
 
   describe('check fields: #seeInField, #seeCheckboxIsChecked, ...', () => {
     it('should check for empty field', async () => {
-      await I.amOnPage('/form/empty');
-      await I.seeInField('#empty_input', '');
-    });
+      await I.amOnPage('/form/empty')
+      await I.seeInField('#empty_input', '')
+    })
 
     it('should check for empty textarea', async () => {
-      await I.amOnPage('/form/empty');
-      await I.seeInField('#empty_textarea', '');
-    });
+      await I.amOnPage('/form/empty')
+      await I.seeInField('#empty_textarea', '')
+    })
 
     it('should check field equals', async () => {
-      await I.amOnPage('/form/field');
-      await I.seeInField('Name', 'OLD_VALUE');
-      await I.seeInField('name', 'OLD_VALUE');
-      await I.seeInField('//input[@id="name"]', 'OLD_VALUE');
-      await I.dontSeeInField('//input[@id="name"]', 'NOtVALUE');
-    });
+      await I.amOnPage('/form/field')
+      await I.seeInField('Name', 'OLD_VALUE')
+      await I.seeInField('name', 'OLD_VALUE')
+      await I.seeInField('//input[@id="name"]', 'OLD_VALUE')
+      await I.dontSeeInField('//input[@id="name"]', 'NOtVALUE')
+    })
 
     it('should check textarea equals', async () => {
-      await I.amOnPage('/form/textarea');
-      await I.seeInField('Description', 'sunrise');
-      await I.seeInField('textarea', 'sunrise');
-      await I.seeInField('//textarea[@id="description"]', 'sunrise');
-      await I.dontSeeInField('//textarea[@id="description"]', 'sunset');
-    });
+      await I.amOnPage('/form/textarea')
+      await I.seeInField('Description', 'sunrise')
+      await I.seeInField('textarea', 'sunrise')
+      await I.seeInField('//textarea[@id="description"]', 'sunrise')
+      await I.dontSeeInField('//textarea[@id="description"]', 'sunset')
+    })
 
     it('should check checkbox is checked :)', async () => {
-      await I.amOnPage('/info');
-      await I.seeCheckboxIsChecked('input[type=checkbox]');
-    });
+      await I.amOnPage('/info')
+      await I.seeCheckboxIsChecked('input[type=checkbox]')
+    })
 
     it('should check checkbox is not checked', async () => {
-      await I.amOnPage('/form/checkbox');
-      await I.dontSeeCheckboxIsChecked('#checkin');
-    });
+      await I.amOnPage('/form/checkbox')
+      await I.dontSeeCheckboxIsChecked('#checkin')
+    })
 
     it('should match fields with the same name', async () => {
-      await I.amOnPage('/form/example20');
-      await I.seeInField("//input[@name='txtName'][2]", 'emma');
-      await I.seeInField("input[name='txtName']:nth-child(2)", 'emma');
-    });
-  });
+      await I.amOnPage('/form/example20')
+      await I.seeInField("//input[@name='txtName'][2]", 'emma')
+      await I.seeInField("input[name='txtName']:nth-child(2)", 'emma')
+    })
+  })
 
   describe('#grabTextFromAll, #grabHTMLFromAll, #grabValueFromAll, #grabAttributeFromAll', () => {
     it('should grab multiple texts from page', async () => {
-      await I.amOnPage('/info');
-      let vals = await I.grabTextFromAll('#grab-multiple a');
-      assert.equal(vals[0], 'First');
-      assert.equal(vals[1], 'Second');
-      assert.equal(vals[2], 'Third');
+      await I.amOnPage('/info')
+      let vals = await I.grabTextFromAll('#grab-multiple a')
+      assert.equal(vals[0], 'First')
+      assert.equal(vals[1], 'Second')
+      assert.equal(vals[2], 'Third')
 
-      await I.amOnPage('/info');
-      vals = await I.grabTextFromAll('#invalid-id a');
-      assert.equal(vals.length, 0);
-    });
+      await I.amOnPage('/info')
+      vals = await I.grabTextFromAll('#invalid-id a')
+      assert.equal(vals.length, 0)
+    })
 
     it('should grab multiple html from page', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/info');
-      let vals = await I.grabHTMLFromAll('#grab-multiple a');
-      assert.equal(vals[0], 'First');
-      assert.equal(vals[1], 'Second');
-      assert.equal(vals[2], 'Third');
+      await I.amOnPage('/info')
+      let vals = await I.grabHTMLFromAll('#grab-multiple a')
+      assert.equal(vals[0], 'First')
+      assert.equal(vals[1], 'Second')
+      assert.equal(vals[2], 'Third')
 
-      await I.amOnPage('/info');
-      vals = await I.grabHTMLFromAll('#invalid-id a');
-      assert.equal(vals.length, 0);
-    });
+      await I.amOnPage('/info')
+      vals = await I.grabHTMLFromAll('#invalid-id a')
+      assert.equal(vals.length, 0)
+    })
 
     it('should grab multiple attribute from element', async () => {
-      await I.amOnPage('/form/empty');
-      const vals = await I.grabAttributeFromAll({
-        css: 'input',
-      }, 'name');
-      assert.equal(vals[0], 'text');
-      assert.equal(vals[1], 'empty_input');
-    });
+      await I.amOnPage('/form/empty')
+      const vals = await I.grabAttributeFromAll(
+        {
+          css: 'input',
+        },
+        'name',
+      )
+      assert.equal(vals[0], 'text')
+      assert.equal(vals[1], 'empty_input')
+    })
 
     it('Should return empty array if no attribute found', async () => {
-      await I.amOnPage('/form/empty');
-      const vals = await I.grabAttributeFromAll({
-        css: 'div',
-      }, 'test');
-      assert.equal(vals.length, 0);
-    });
+      await I.amOnPage('/form/empty')
+      const vals = await I.grabAttributeFromAll(
+        {
+          css: 'div',
+        },
+        'test',
+      )
+      assert.equal(vals.length, 0)
+    })
 
     it('should grab values if multiple field matches', async () => {
-      await I.amOnPage('/form/hidden');
-      let vals = await I.grabValueFromAll('//form/input');
-      assert.equal(vals[0], 'kill_people');
-      assert.equal(vals[1], 'Submit');
+      await I.amOnPage('/form/hidden')
+      let vals = await I.grabValueFromAll('//form/input')
+      assert.equal(vals[0], 'kill_people')
+      assert.equal(vals[1], 'Submit')
 
-      vals = await I.grabValueFromAll("//form/input[@name='action']");
-      assert.equal(vals[0], 'kill_people');
-    });
+      vals = await I.grabValueFromAll("//form/input[@name='action']")
+      assert.equal(vals[0], 'kill_people')
+    })
 
     it('Should return empty array if no value found', async () => {
-      await I.amOnPage('/');
-      const vals = await I.grabValueFromAll('//form/input');
-      assert.equal(vals.length, 0);
-    });
-  });
+      await I.amOnPage('/')
+      const vals = await I.grabValueFromAll('//form/input')
+      assert.equal(vals.length, 0)
+    })
+  })
 
   describe('#grabTextFrom, #grabHTMLFrom, #grabValueFrom, #grabAttributeFrom', () => {
     it('should grab text from page', async () => {
-      await I.amOnPage('/');
-      let val = await I.grabTextFrom('h1');
-      assert.equal(val, 'Welcome to test app!');
+      await I.amOnPage('/')
+      let val = await I.grabTextFrom('h1')
+      assert.equal(val, 'Welcome to test app!')
 
-      val = await I.grabTextFrom('//h1');
-      assert.equal(val, 'Welcome to test app!');
-    });
+      val = await I.grabTextFrom('//h1')
+      assert.equal(val, 'Welcome to test app!')
+    })
 
     it('should grab html from page', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/info');
-      const val = await I.grabHTMLFrom('#grab-multiple');
-      assert.equal(`
+      await I.amOnPage('/info')
+      const val = await I.grabHTMLFrom('#grab-multiple')
+      assert.equal(
+        `
     <a id="first-link">First</a>
     <a id="second-link">Second</a>
     <a id="third-link">Third</a>
-`, val);
-    });
+`,
+        val,
+      )
+    })
 
     it('should grab value from field', async () => {
-      await I.amOnPage('/form/hidden');
-      let val = await I.grabValueFrom('#action');
-      assert.equal(val, 'kill_people');
-      val = await I.grabValueFrom("//form/input[@name='action']");
-      assert.equal(val, 'kill_people');
-      await I.amOnPage('/form/textarea');
-      val = await I.grabValueFrom('#description');
-      assert.equal(val, 'sunrise');
-      await I.amOnPage('/form/select');
-      val = await I.grabValueFrom('#age');
-      assert.equal(val, 'oldfag');
-    });
+      await I.amOnPage('/form/hidden')
+      let val = await I.grabValueFrom('#action')
+      assert.equal(val, 'kill_people')
+      val = await I.grabValueFrom("//form/input[@name='action']")
+      assert.equal(val, 'kill_people')
+      await I.amOnPage('/form/textarea')
+      val = await I.grabValueFrom('#description')
+      assert.equal(val, 'sunrise')
+      await I.amOnPage('/form/select')
+      val = await I.grabValueFrom('#age')
+      assert.equal(val, 'oldfag')
+    })
 
     it('should grab attribute from element', async () => {
-      await I.amOnPage('/search');
-      const val = await I.grabAttributeFrom({
-        css: 'form',
-      }, 'method');
-      assert.equal(val, 'get');
-    });
+      await I.amOnPage('/search')
+      const val = await I.grabAttributeFrom(
+        {
+          css: 'form',
+        },
+        'method',
+      )
+      assert.equal(val, 'get')
+    })
 
     it('should grab custom attribute from element', async () => {
-      await I.amOnPage('/form/example4');
-      const val = await I.grabAttributeFrom({
-        css: '.navbar-toggle',
-      }, 'data-toggle');
-      assert.equal(val, 'collapse');
-    });
-  });
+      await I.amOnPage('/form/example4')
+      const val = await I.grabAttributeFrom(
+        {
+          css: '.navbar-toggle',
+        },
+        'data-toggle',
+      )
+      assert.equal(val, 'collapse')
+    })
+  })
 
   describe('page title : #seeTitle, #dontSeeTitle, #grabTitle', () => {
     it('should check page title', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/');
-      await I.seeInTitle('TestEd Beta 2.0');
-      await I.dontSeeInTitle('Welcome to test app');
-      await I.amOnPage('/info');
-      await I.dontSeeInTitle('TestEd Beta 2.0');
-    });
+      await I.amOnPage('/')
+      await I.seeInTitle('TestEd Beta 2.0')
+      await I.dontSeeInTitle('Welcome to test app')
+      await I.amOnPage('/info')
+      await I.dontSeeInTitle('TestEd Beta 2.0')
+    })
 
     it('should grab page title', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/');
-      const val = await I.grabTitle();
-      assert.equal(val, 'TestEd Beta 2.0');
-    });
-  });
+      await I.amOnPage('/')
+      const val = await I.grabTitle()
+      assert.equal(val, 'TestEd Beta 2.0')
+    })
+  })
 
   describe('#attachFile', () => {
     it('should upload file located by CSS', async () => {
-      await I.amOnPage('/form/file');
-      await I.attachFile('#avatar', 'app/avatar.jpg');
-      await I.click('Submit');
-      await I.see('Thank you');
-      formContents().files.should.have.key('avatar');
-      formContents().files.avatar.name.should.eql('avatar.jpg');
-      formContents().files.avatar.type.should.eql('image/jpeg');
-    });
+      await I.amOnPage('/form/file')
+      await I.attachFile('#avatar', 'app/avatar.jpg')
+      await I.click('Submit')
+      await I.see('Thank you')
+      formContents().files.should.have.key('avatar')
+      formContents().files.avatar.name.should.eql('avatar.jpg')
+      formContents().files.avatar.type.should.eql('image/jpeg')
+    })
 
     it('should upload file located by label', async () => {
-      await I.amOnPage('/form/file');
-      await I.attachFile('Avatar', 'app/avatar.jpg');
-      await I.click('Submit');
-      await I.see('Thank you');
-      formContents().files.should.have.key('avatar');
-      formContents().files.avatar.name.should.eql('avatar.jpg');
-      formContents().files.avatar.type.should.eql('image/jpeg');
-    });
-  });
+      await I.amOnPage('/form/file')
+      await I.attachFile('Avatar', 'app/avatar.jpg')
+      await I.click('Submit')
+      await I.see('Thank you')
+      formContents().files.should.have.key('avatar')
+      formContents().files.avatar.name.should.eql('avatar.jpg')
+      formContents().files.avatar.type.should.eql('image/jpeg')
+    })
+  })
 
   describe('#saveScreenshot', () => {
     beforeEach(() => {
-      global.output_dir = path.join(global.codecept_dir, 'output');
-    });
+      global.output_dir = path.join(global.codecept_dir, 'output')
+    })
 
     it('should create a screenshot file in output dir', async () => {
-      const sec = (new Date()).getUTCMilliseconds();
-      await I.amOnPage('/');
-      await I.saveScreenshot(`screenshot_${sec}.png`);
-      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists');
-    });
+      const sec = new Date().getUTCMilliseconds()
+      await I.amOnPage('/')
+      await I.saveScreenshot(`screenshot_${sec}.png`)
+      assert.ok(fileExists(path.join(global.output_dir, `screenshot_${sec}.png`)), null, 'file does not exists')
+    })
 
     it('should create a full page screenshot file in output dir', async () => {
-      const sec = (new Date()).getUTCMilliseconds();
-      await I.amOnPage('/');
-      await I.saveScreenshot(`screenshot_full_${+sec}.png`, true);
-      assert.ok(fileExists(path.join(global.output_dir, `screenshot_full_${+sec}.png`)), null, 'file does not exists');
-    });
-  });
+      const sec = new Date().getUTCMilliseconds()
+      await I.amOnPage('/')
+      await I.saveScreenshot(`screenshot_full_${+sec}.png`, true)
+      assert.ok(fileExists(path.join(global.output_dir, `screenshot_full_${+sec}.png`)), null, 'file does not exists')
+    })
+  })
 
   describe('cookies : #setCookie, #clearCookies, #seeCookie, #waitForCookie', () => {
     it('should do all cookie stuff', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       await I.setCookie({
         name: 'auth',
         value: '123456',
         url: 'http://localhost',
-      });
-      await I.seeCookie('auth');
-      await I.dontSeeCookie('auuth');
+      })
+      await I.seeCookie('auth')
+      await I.dontSeeCookie('auuth')
 
-      const cookie = await I.grabCookie('auth');
-      assert.equal(cookie.value, '123456');
+      const cookie = await I.grabCookie('auth')
+      assert.equal(cookie.value, '123456')
 
-      await I.clearCookie('auth');
-      await I.dontSeeCookie('auth');
-    });
+      await I.clearCookie('auth')
+      await I.dontSeeCookie('auth')
+    })
 
     it('should grab all cookies', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       await I.setCookie({
         name: 'auth',
         value: '123456',
         url: 'http://localhost',
-      });
+      })
       await I.setCookie({
         name: 'user',
         value: 'davert',
         url: 'http://localhost',
-      });
+      })
 
-      const cookies = await I.grabCookie();
-      assert.equal(cookies.length, 2);
-      assert(cookies[0].name);
-      assert(cookies[0].value);
-    });
+      const cookies = await I.grabCookie()
+      assert.equal(cookies.length, 2)
+      assert(cookies[0].name)
+      assert(cookies[0].value)
+    })
 
     it('should clear all cookies', async () => {
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       await I.setCookie({
         name: 'auth',
         value: '123456',
         url: 'http://localhost',
-      });
-      await I.clearCookie();
-      await I.dontSeeCookie('auth');
-    });
+      })
+      await I.clearCookie()
+      await I.dontSeeCookie('auth')
+    })
 
     it('should wait for cookie and throw error when cookie not found', async () => {
-      if (isHelper('TestCafe')) return;
-      if (process.env.DevTools) return;
+      if (isHelper('TestCafe')) return
+      if (process.env.DevTools) return
 
-      await I.amOnPage('https://google.com');
+      await I.amOnPage('https://google.com')
       try {
-        await I.waitForCookie('auth', 2);
+        await I.waitForCookie('auth', 2)
       } catch (e) {
-        assert.equal(e.message, 'Cookie auth is not found after 2s');
+        assert.equal(e.message, 'Cookie auth is not found after 2s')
       }
-    });
+    })
 
     it('should wait for cookie', async () => {
-      if (isHelper('TestCafe')) return;
-      if (process.env.DevTools) return;
+      if (isHelper('TestCafe')) return
+      if (process.env.DevTools) return
 
-      await I.amOnPage('/');
+      await I.amOnPage('/')
       await I.setCookie({
         name: 'auth',
         value: '123456',
         url: 'http://localhost',
-      });
-      await I.waitForCookie('auth');
-    });
-  });
+      })
+      await I.waitForCookie('auth')
+    })
+  })
 
   describe('#waitForText', () => {
     it('should wait for text', async () => {
-      await I.amOnPage('/dynamic');
-      await I.dontSee('Dynamic text');
-      await I.waitForText('Dynamic text', 2);
-      await I.see('Dynamic text');
-    });
+      await I.amOnPage('/dynamic')
+      await I.dontSee('Dynamic text')
+      await I.waitForText('Dynamic text', 2)
+      await I.see('Dynamic text')
+    })
 
     it('should wait for text in context', async () => {
-      await I.amOnPage('/dynamic');
-      await I.dontSee('Dynamic text');
-      await I.waitForText('Dynamic text', 2, '#text');
-      await I.see('Dynamic text');
-    });
+      await I.amOnPage('/dynamic')
+      await I.dontSee('Dynamic text')
+      await I.waitForText('Dynamic text', 2, '#text')
+      await I.see('Dynamic text')
+    })
 
     it('should fail if no context', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      let failed = false;
-      await I.amOnPage('/dynamic');
-      await I.dontSee('Dynamic text');
+      let failed = false
+      await I.amOnPage('/dynamic')
+      await I.dontSee('Dynamic text')
       try {
-        await I.waitForText('Dynamic text', 1, '#fext');
+        await I.waitForText('Dynamic text', 1, '#fext')
       } catch (e) {
-        failed = true;
+        failed = true
       }
-      assert.ok(failed);
-    });
+      assert.ok(failed)
+    })
 
-    it('should fail if text doesn\'t contain', async function () {
-      if (isHelper('TestCafe')) this.skip();
+    it("should fail if text doesn't contain", async function () {
+      if (isHelper('TestCafe')) this.skip()
 
-      let failed = false;
-      await I.amOnPage('/dynamic');
+      let failed = false
+      await I.amOnPage('/dynamic')
       try {
-        await I.waitForText('Other text', 1);
+        await I.waitForText('Other text', 1)
       } catch (e) {
-        failed = true;
+        failed = true
       }
-      assert.ok(failed);
-    });
+      assert.ok(failed)
+    })
 
     it('should fail if text is not in element', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      let failed = false;
-      await I.amOnPage('/dynamic');
+      let failed = false
+      await I.amOnPage('/dynamic')
       try {
-        await I.waitForText('Other text', 1, '#text');
+        await I.waitForText('Other text', 1, '#text')
       } catch (e) {
-        failed = true;
+        failed = true
       }
-      assert.ok(failed);
-    });
+      assert.ok(failed)
+    })
 
     it('should wait for text after timeout', async () => {
-      await I.amOnPage('/timeout');
-      await I.dontSee('Timeout text');
-      await I.waitForText('Timeout text', 31, '#text');
-      await I.see('Timeout text');
-    });
+      await I.amOnPage('/timeout')
+      await I.dontSee('Timeout text')
+      await I.waitForText('Timeout text', 31, '#text')
+      await I.see('Timeout text')
+    })
 
     it('should wait for text located by XPath', async () => {
-      await I.amOnPage('/dynamic');
-      await I.dontSee('Dynamic text');
-      await I.waitForText('Dynamic text', 5, '//div[@id="text"]');
-    });
+      await I.amOnPage('/dynamic')
+      await I.dontSee('Dynamic text')
+      await I.waitForText('Dynamic text', 5, '//div[@id="text"]')
+    })
 
     it('should throw error when text not found', async () => {
-      await I.amOnPage('/dynamic');
-      await I.dontSee('Dynamic text');
-      let failed = false;
+      await I.amOnPage('/dynamic')
+      await I.dontSee('Dynamic text')
+      let failed = false
       try {
-        await I.waitForText('Some text', 1, '//div[@id="text"]');
+        await I.waitForText('Some text', 1, '//div[@id="text"]')
       } catch (e) {
-        failed = true;
+        failed = true
       }
-      assert.ok(failed);
-    });
-  });
+      assert.ok(failed)
+    })
+  })
 
   describe('#waitForElement', () => {
     it('should wait for visible element', async () => {
-      await I.amOnPage('/form/wait_visible');
-      await I.dontSee('Step One Button');
-      await I.dontSeeElement('#step_1');
-      await I.waitForVisible('#step_1', 2);
-      await I.seeElement('#step_1');
-      await I.click('#step_1');
-      await I.waitForVisible('#step_2', 2);
-      await I.see('Step Two Button');
-    });
+      await I.amOnPage('/form/wait_visible')
+      await I.dontSee('Step One Button')
+      await I.dontSeeElement('#step_1')
+      await I.waitForVisible('#step_1', 2)
+      await I.seeElement('#step_1')
+      await I.click('#step_1')
+      await I.waitForVisible('#step_2', 2)
+      await I.see('Step Two Button')
+    })
 
     it('should wait for element in DOM', async () => {
-      await I.amOnPage('/form/wait_visible');
-      await I.waitForElement('#step_2');
-      await I.dontSeeElement('#step_2');
-      await I.seeElementInDOM('#step_2');
-    });
+      await I.amOnPage('/form/wait_visible')
+      await I.waitForElement('#step_2')
+      await I.dontSeeElement('#step_2')
+      await I.seeElementInDOM('#step_2')
+    })
 
     it('should wait for element by XPath', async () => {
-      await I.amOnPage('/form/wait_visible');
-      await I.waitForElement('//div[@id="step_2"]');
-      await I.dontSeeElement('//div[@id="step_2"]');
-      await I.seeElementInDOM('//div[@id="step_2"]');
-    });
+      await I.amOnPage('/form/wait_visible')
+      await I.waitForElement('//div[@id="step_2"]')
+      await I.dontSeeElement('//div[@id="step_2"]')
+      await I.seeElementInDOM('//div[@id="step_2"]')
+    })
 
     it('should wait for element to appear', async () => {
-      await I.amOnPage('/form/wait_element');
-      await I.dontSee('Hello');
-      await I.dontSeeElement('h1');
-      await I.waitForElement('h1', 2);
-      await I.see('Hello');
-    });
-  });
+      await I.amOnPage('/form/wait_element')
+      await I.dontSee('Hello')
+      await I.dontSeeElement('h1')
+      await I.waitForElement('h1', 2)
+      await I.see('Hello')
+    })
+  })
 
   describe('#waitForInvisible', () => {
     it('should wait for element to be invisible', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step One Button');
-      await I.seeElement('#step_1');
-      await I.waitForInvisible('#step_1', 2);
-      await I.dontSeeElement('#step_1');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step One Button')
+      await I.seeElement('#step_1')
+      await I.waitForInvisible('#step_1', 2)
+      await I.dontSeeElement('#step_1')
+    })
 
     it('should wait for element to be invisible by XPath', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.seeElement('//div[@id="step_1"]');
-      await I.waitForInvisible('//div[@id="step_1"]');
-      await I.dontSeeElement('//div[@id="step_1"]');
-      await I.seeElementInDOM('//div[@id="step_1"]');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.seeElement('//div[@id="step_1"]')
+      await I.waitForInvisible('//div[@id="step_1"]')
+      await I.dontSeeElement('//div[@id="step_1"]')
+      await I.seeElementInDOM('//div[@id="step_1"]')
+    })
 
     it('should wait for element to be removed', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step Two Button');
-      await I.seeElement('#step_2');
-      await I.waitForInvisible('#step_2', 2);
-      await I.dontSeeElement('#step_2');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step Two Button')
+      await I.seeElement('#step_2')
+      await I.waitForInvisible('#step_2', 2)
+      await I.dontSeeElement('#step_2')
+    })
 
     it('should wait for element to be removed by XPath', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step Two Button');
-      await I.seeElement('//div[@id="step_2"]');
-      await I.waitForInvisible('//div[@id="step_2"]', 2);
-      await I.dontSeeElement('//div[@id="step_2"]');
-    });
-  });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step Two Button')
+      await I.seeElement('//div[@id="step_2"]')
+      await I.waitForInvisible('//div[@id="step_2"]', 2)
+      await I.dontSeeElement('//div[@id="step_2"]')
+    })
+  })
 
   describe('#waitToHide', () => {
     it('should wait for element to be invisible', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step One Button');
-      await I.seeElement('#step_1');
-      await I.waitToHide('#step_1', 2);
-      await I.dontSeeElement('#step_1');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step One Button')
+      await I.seeElement('#step_1')
+      await I.waitToHide('#step_1', 2)
+      await I.dontSeeElement('#step_1')
+    })
 
     it('should wait for element to be invisible by XPath', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.seeElement('//div[@id="step_1"]');
-      await I.waitToHide('//div[@id="step_1"]');
-      await I.dontSeeElement('//div[@id="step_1"]');
-      await I.seeElementInDOM('//div[@id="step_1"]');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.seeElement('//div[@id="step_1"]')
+      await I.waitToHide('//div[@id="step_1"]')
+      await I.dontSeeElement('//div[@id="step_1"]')
+      await I.seeElementInDOM('//div[@id="step_1"]')
+    })
 
     it('should wait for element to be removed', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step Two Button');
-      await I.seeElement('#step_2');
-      await I.waitToHide('#step_2', 2);
-      await I.dontSeeElement('#step_2');
-    });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step Two Button')
+      await I.seeElement('#step_2')
+      await I.waitToHide('#step_2', 2)
+      await I.dontSeeElement('#step_2')
+    })
 
     it('should wait for element to be removed by XPath', async () => {
-      await I.amOnPage('/form/wait_invisible');
-      await I.see('Step Two Button');
-      await I.seeElement('//div[@id="step_2"]');
-      await I.waitToHide('//div[@id="step_2"]', 2);
-      await I.dontSeeElement('//div[@id="step_2"]');
-    });
-  });
+      await I.amOnPage('/form/wait_invisible')
+      await I.see('Step Two Button')
+      await I.seeElement('//div[@id="step_2"]')
+      await I.waitToHide('//div[@id="step_2"]', 2)
+      await I.dontSeeElement('//div[@id="step_2"]')
+    })
+  })
 
   describe('#waitForDetached', () => {
     it('should throw an error if the element still exists in DOM', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/wait_detached');
-      await I.see('Step One Button');
-      await I.seeElement('#step_1');
+      await I.amOnPage('/form/wait_detached')
+      await I.see('Step One Button')
+      await I.seeElement('#step_1')
 
       try {
-        await I.waitForDetached('#step_1', 2);
-        throw Error('Should not get this far');
+        await I.waitForDetached('#step_1', 2)
+        throw Error('Should not get this far')
       } catch (err) {
-        err.message.should.include('still on page after');
+        err.message.should.include('still on page after')
       }
-    });
+    })
 
     it('should throw an error if the element still exists in DOM by XPath', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/wait_detached');
-      await I.see('Step One Button');
-      await I.seeElement('#step_1');
+      await I.amOnPage('/form/wait_detached')
+      await I.see('Step One Button')
+      await I.seeElement('#step_1')
 
       try {
-        await I.waitForDetached('#step_1', 2);
-        throw Error('Should not get this far');
+        await I.waitForDetached('#step_1', 2)
+        throw Error('Should not get this far')
       } catch (err) {
-        err.message.should.include('still on page after');
+        err.message.should.include('still on page after')
       }
-    });
+    })
 
     it('should wait for element to be removed from DOM', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/wait_detached');
-      await I.see('Step Two Button');
-      await I.seeElement('#step_2');
-      await I.waitForDetached('#step_2', 2);
-      await I.dontSeeElementInDOM('#step_2');
-    });
+      await I.amOnPage('/form/wait_detached')
+      await I.see('Step Two Button')
+      await I.seeElement('#step_2')
+      await I.waitForDetached('#step_2', 2)
+      await I.dontSeeElementInDOM('#step_2')
+    })
 
     it('should wait for element to be removed from DOM by XPath', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/wait_detached');
-      await I.seeElement('//div[@id="step_2"]');
-      await I.waitForDetached('//div[@id="step_2"]');
-      await I.dontSeeElement('//div[@id="step_2"]');
-      await I.dontSeeElementInDOM('//div[@id="step_2"]');
-    });
-  });
+      await I.amOnPage('/form/wait_detached')
+      await I.seeElement('//div[@id="step_2"]')
+      await I.waitForDetached('//div[@id="step_2"]')
+      await I.dontSeeElement('//div[@id="step_2"]')
+      await I.dontSeeElementInDOM('//div[@id="step_2"]')
+    })
+  })
 
   describe('within tests', () => {
-    afterEach(() => I._withinEnd());
+    afterEach(() => I._withinEnd())
 
     it('should execute within block', async () => {
-      await I.amOnPage('/form/example4');
-      await I.seeElement('#navbar-collapse-menu');
+      await I.amOnPage('/form/example4')
+      await I.seeElement('#navbar-collapse-menu')
       I._withinBegin('#register')
         .then(() => I.see('E-Mail'))
         .then(() => I.dontSee('Toggle navigation'))
-        .then(() => I.dontSeeElement('#navbar-collapse-menu'));
-    });
+        .then(() => I.dontSeeElement('#navbar-collapse-menu'))
+    })
 
     it('should respect form fields inside within block ', async () => {
-      let rethrow;
-
-      await I.amOnPage('/form/example4');
-      await I.seeElement('#navbar-collapse-menu');
-      await I.see('E-Mail');
-      await I.see('Hasło');
-      await I.fillField('Hasło', '12345');
-      await I.seeInField('Hasło', '12345');
-      await I.checkOption('terms');
-      await I.seeCheckboxIsChecked('terms');
+      let rethrow
+
+      await I.amOnPage('/form/example4')
+      await I.seeElement('#navbar-collapse-menu')
+      await I.see('E-Mail')
+      await I.see('Hasło')
+      await I.fillField('Hasło', '12345')
+      await I.seeInField('Hasło', '12345')
+      await I.checkOption('terms')
+      await I.seeCheckboxIsChecked('terms')
       I._withinBegin({ css: '.form-group' })
         .then(() => I.see('E-Mail'))
         .then(() => I.dontSee('Hasło'))
-        .then(() => I.dontSeeElement('#navbar-collapse-menu'));
+        .then(() => I.dontSeeElement('#navbar-collapse-menu'))
 
       try {
-        await I.dontSeeCheckboxIsChecked('terms');
+        await I.dontSeeCheckboxIsChecked('terms')
       } catch (err) {
-        if (!err) assert.fail('seen checkbox');
+        if (!err) assert.fail('seen checkbox')
       }
 
       try {
-        await I.seeInField('Hasło', '12345');
+        await I.seeInField('Hasło', '12345')
       } catch (err) {
-        if (!err) assert.fail('seen field');
+        if (!err) assert.fail('seen field')
       }
 
-      if (rethrow) throw rethrow;
-    });
+      if (rethrow) throw rethrow
+    })
 
     it('should execute within block 2', async () => {
-      await I.amOnPage('/form/example4');
-      await I.fillField('Hasło', '12345');
+      await I.amOnPage('/form/example4')
+      await I.fillField('Hasło', '12345')
       I._withinBegin({ xpath: '//div[@class="form-group"][2]' })
         .then(() => I.dontSee('E-Mail'))
         .then(() => I.see('Hasło'))
         .then(() => I.grabTextFrom('label'))
         .then((label) => assert.equal(label, 'Hasło'))
         .then(() => I.grabValueFrom('input'))
-        .then((input) => assert.equal(input, '12345'));
-    });
+        .then((input) => assert.equal(input, '12345'))
+    })
 
     it('within should respect context in see', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/example4');
-      await I.see('Rejestracja', 'fieldset');
+      await I.amOnPage('/form/example4')
+      await I.see('Rejestracja', 'fieldset')
       I._withinBegin({ css: '.navbar-header' })
         .then(() => I.see('Rejestracja', '.container fieldset'))
-        .then(() => I.see('Toggle navigation', '.container fieldset'));
-    });
+        .then(() => I.see('Toggle navigation', '.container fieldset'))
+    })
 
     it('within should respect context in see when using nested frames', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/iframe_nested');
+      await I.amOnPage('/iframe_nested')
       await I._withinBegin({
         frame: ['#wrapperId', '[name=content]'],
-      });
+      })
 
       try {
-        await I.see('Kill & Destroy');
+        await I.see('Kill & Destroy')
       } catch (err) {
-        if (!err) assert.fail('seen "Kill & Destroy"');
+        if (!err) assert.fail('seen "Kill & Destroy"')
       }
 
       try {
-        await I.dontSee('Nested Iframe test');
+        await I.dontSee('Nested Iframe test')
       } catch (err) {
-        if (!err) assert.fail('seen "Nested Iframe test"');
+        if (!err) assert.fail('seen "Nested Iframe test"')
       }
 
       try {
-        await I.dontSee('Iframe test');
+        await I.dontSee('Iframe test')
       } catch (err) {
-        if (!err) assert.fail('seen "Iframe test"');
+        if (!err) assert.fail('seen "Iframe test"')
       }
-    });
+    })
 
     it('within should respect context in see when using frame', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/iframe');
+      await I.amOnPage('/iframe')
       await I._withinBegin({
         frame: '#number-frame-1234',
-      });
+      })
 
       try {
-        await I.see('Information');
+        await I.see('Information')
       } catch (err) {
-        if (!err) assert.fail('seen "Information"');
+        if (!err) assert.fail('seen "Information"')
       }
-    });
+    })
 
     it('within should respect context in see when using frame with strict locator', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/iframe');
+      await I.amOnPage('/iframe')
       await I._withinBegin({
         frame: { css: '#number-frame-1234' },
-      });
+      })
 
       try {
-        await I.see('Information');
+        await I.see('Information')
       } catch (err) {
-        if (!err) assert.fail('seen "Information"');
+        if (!err) assert.fail('seen "Information"')
       }
-    });
-  });
+    })
+  })
 
   describe('scroll: #scrollTo, #scrollPageToTop, #scrollPageToBottom', () => {
     it('should scroll inside an iframe', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/iframe');
-      await I.resizeWindow(500, 700);
-      await I.switchTo(0);
+      await I.amOnPage('/iframe')
+      await I.resizeWindow(500, 700)
+      await I.switchTo(0)
 
-      const { x, y } = await I.grabPageScrollPosition();
-      await I.scrollTo('.sign');
+      const { x, y } = await I.grabPageScrollPosition()
+      await I.scrollTo('.sign')
 
-      const { x: afterScrollX, y: afterScrollY } = await I.grabPageScrollPosition();
-      assert.notEqual(afterScrollY, y);
-      assert.equal(afterScrollX, x);
-    });
+      const { x: afterScrollX, y: afterScrollY } = await I.grabPageScrollPosition()
+      assert.notEqual(afterScrollY, y)
+      assert.equal(afterScrollX, x)
+    })
 
     it('should scroll to an element', async () => {
-      await I.amOnPage('/form/scroll');
-      await I.resizeWindow(500, 700);
-      const { y } = await I.grabPageScrollPosition();
-      await I.scrollTo('.section3 input[name="test"]');
+      await I.amOnPage('/form/scroll')
+      await I.resizeWindow(500, 700)
+      const { y } = await I.grabPageScrollPosition()
+      await I.scrollTo('.section3 input[name="test"]')
 
-      const { y: afterScrollY } = await I.grabPageScrollPosition();
-      assert.notEqual(afterScrollY, y);
-    });
+      const { y: afterScrollY } = await I.grabPageScrollPosition()
+      assert.notEqual(afterScrollY, y)
+    })
 
     it('should scroll to coordinates', async () => {
-      await I.amOnPage('/form/scroll');
-      await I.resizeWindow(500, 700);
-      await I.scrollTo(50, 70);
+      await I.amOnPage('/form/scroll')
+      await I.resizeWindow(500, 700)
+      await I.scrollTo(50, 70)
 
-      const { x: afterScrollX, y: afterScrollY } = await I.grabPageScrollPosition();
-      assert.equal(afterScrollX, 50);
-      assert.equal(afterScrollY, 70);
-    });
+      const { x: afterScrollX, y: afterScrollY } = await I.grabPageScrollPosition()
+      assert.equal(afterScrollX, 50)
+      assert.equal(afterScrollY, 70)
+    })
 
     it('should scroll to bottom of page', async () => {
-      await I.amOnPage('/form/scroll');
-      await I.resizeWindow(500, 700);
-      const { y } = await I.grabPageScrollPosition();
-      await I.scrollPageToBottom();
+      await I.amOnPage('/form/scroll')
+      await I.resizeWindow(500, 700)
+      const { y } = await I.grabPageScrollPosition()
+      await I.scrollPageToBottom()
 
-      const { y: afterScrollY } = await I.grabPageScrollPosition();
-      assert.notEqual(afterScrollY, y);
-      assert.notEqual(afterScrollY, 0);
-    });
+      const { y: afterScrollY } = await I.grabPageScrollPosition()
+      assert.notEqual(afterScrollY, y)
+      assert.notEqual(afterScrollY, 0)
+    })
 
     it('should scroll to top of page', async () => {
-      await I.amOnPage('/form/scroll');
-      await I.resizeWindow(500, 700);
-      await I.scrollPageToBottom();
-      const { y } = await I.grabPageScrollPosition();
-      await I.scrollPageToTop();
-
-      const { y: afterScrollY } = await I.grabPageScrollPosition();
-      assert.notEqual(afterScrollY, y);
-      assert.equal(afterScrollY, 0);
-    });
-  });
+      await I.amOnPage('/form/scroll')
+      await I.resizeWindow(500, 700)
+      await I.scrollPageToBottom()
+      const { y } = await I.grabPageScrollPosition()
+      await I.scrollPageToTop()
+
+      const { y: afterScrollY } = await I.grabPageScrollPosition()
+      assert.notEqual(afterScrollY, y)
+      assert.equal(afterScrollY, 0)
+    })
+  })
 
   describe('#grabCssPropertyFrom', () => {
     it('should grab css property for given element', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/doubleclick');
-      const css = await I.grabCssPropertyFrom('#block', 'height');
-      assert.equal(css, '100px');
-    });
+      await I.amOnPage('/form/doubleclick')
+      const css = await I.grabCssPropertyFrom('#block', 'height')
+      assert.equal(css, '100px')
+    })
 
     it('should grab camelcased css properies', async () => {
-      if (isHelper('TestCafe')) return;
+      if (isHelper('TestCafe')) return
 
-      await I.amOnPage('/form/doubleclick');
-      const css = await I.grabCssPropertyFrom('#block', 'user-select');
-      assert.equal(css, 'text');
-    });
+      await I.amOnPage('/form/doubleclick')
+      const css = await I.grabCssPropertyFrom('#block', 'user-select')
+      assert.equal(css, 'text')
+    })
 
     it('should grab multiple values if more than one matching element found', async () => {
-      if (isHelper('TestCafe')) return;
+      if (isHelper('TestCafe')) return
 
-      await I.amOnPage('/info');
-      const css = await I.grabCssPropertyFromAll('.span', 'height');
-      assert.equal(css[0], '12px');
-      assert.equal(css[1], '15px');
-    });
-  });
+      await I.amOnPage('/info')
+      const css = await I.grabCssPropertyFromAll('.span', 'height')
+      assert.equal(css[0], '12px')
+      assert.equal(css[1], '15px')
+    })
+  })
 
   describe('#seeAttributesOnElements', () => {
     it('should check attributes values for given element', async function () {
-      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip();
+      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip()
 
       try {
-        await I.amOnPage('/info');
+        await I.amOnPage('/info')
         await I.seeAttributesOnElements('//form', {
           method: 'post',
-        });
+        })
         await I.seeAttributesOnElements('//form', {
           method: 'get',
-        });
-        throw Error('It should never get this far');
+        })
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('all elements (//form) to have attributes {"method":"get"}');
+        e.message.should.include('all elements (//form) to have attributes {"method":"get"}')
       }
-    });
+    })
 
     it('should check href with slash', async function () {
-      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip();
+      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip()
 
       try {
-        await I.amOnPage('https://github.com/codeceptjs/CodeceptJS/');
-        await I.seeAttributesOnElements({ css: 'a[href="/codeceptjs/CodeceptJS"]' }, {
-          href: '/codeceptjs/CodeceptJS',
-        });
+        await I.amOnPage('https://github.com/codeceptjs/CodeceptJS/')
+        await I.seeAttributesOnElements(
+          { css: 'a[href="/codeceptjs/CodeceptJS"]' },
+          {
+            href: '/codeceptjs/CodeceptJS',
+          },
+        )
       } catch (e) {
-        e.message.should.include('all elements (a[href="/codeceptjs/CodeceptJS"]) to have attributes {"href"="/codeceptjs/CodeceptJS"}');
+        e.message.should.include(
+          'all elements (a[href="/codeceptjs/CodeceptJS"]) to have attributes {"href"="/codeceptjs/CodeceptJS"}',
+        )
       }
-    });
+    })
 
     it('should check attributes values for several elements', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
       try {
-        await I.amOnPage('/');
+        await I.amOnPage('/')
         await I.seeAttributesOnElements('a', {
           'qa-id': 'test',
           'qa-link': 'test',
-        });
+        })
         await I.seeAttributesOnElements('//div', {
           'qa-id': 'test',
-        });
+        })
         await I.seeAttributesOnElements('a', {
           'qa-id': 'test',
           href: '/info',
-        });
-        throw new Error('It should never get this far');
+        })
+        throw new Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('all elements (a) to have attributes {"qa-id":"test","href":"/info"}');
+        e.message.should.include('all elements (a) to have attributes {"qa-id":"test","href":"/info"}')
       }
-    });
+    })
 
     it('should return error when using non existing attribute', async function () {
-      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip();
+      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip()
 
       try {
-        await I.amOnPage('https://github.com/codeceptjs/CodeceptJS/');
-        await I.seeAttributesOnElements({ css: 'a[href="/codeceptjs/CodeceptJS"]' }, {
-          disable: true,
-        });
+        await I.amOnPage('https://github.com/codeceptjs/CodeceptJS/')
+        await I.seeAttributesOnElements(
+          { css: 'a[href="/codeceptjs/CodeceptJS"]' },
+          {
+            disable: true,
+          },
+        )
       } catch (e) {
-        e.message.should.include('expected all elements ({css: a[href="/codeceptjs/CodeceptJS"]}) to have attributes {"disable":true} "0" to equal "3"');
+        e.message.should.include(
+          'expected all elements ({css: a[href="/codeceptjs/CodeceptJS"]}) to have attributes {"disable":true} "0" to equal "3"',
+        )
       }
-    });
+    })
 
     it('should verify the boolean attribute', async function () {
-      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip();
+      if (isHelper('TestCafe') || isHelper('WebDriver')) this.skip()
 
       try {
-        await I.amOnPage('/');
+        await I.amOnPage('/')
         await I.seeAttributesOnElements('input', {
           disabled: true,
-        });
+        })
       } catch (e) {
-        e.message.should.include('expected all elements (input) to have attributes {"disabled":true} "0" to equal "1"');
+        e.message.should.include('expected all elements (input) to have attributes {"disabled":true} "0" to equal "1"')
       }
-    });
-  });
+    })
+  })
 
   describe('#seeCssPropertiesOnElements', () => {
     it('should check css property for given element', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
       try {
-        await I.amOnPage('/info');
+        await I.amOnPage('/info')
         await I.seeCssPropertiesOnElements('h4', {
           'font-weight': 300,
-        });
+        })
         await I.seeCssPropertiesOnElements('h3', {
           'font-weight': 'bold',
           display: 'block',
-        });
+        })
         await I.seeCssPropertiesOnElements('h3', {
           'font-weight': 'non-bold',
-        });
-        throw Error('It should never get this far');
+        })
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('expected all elements (h3) to have CSS property {"font-weight":"non-bold"}');
+        e.message.should.include('expected all elements (h3) to have CSS property {"font-weight":"non-bold"}')
       }
-    });
+    })
 
     it('should check css property for several elements', async function () {
-      if (isHelper('TestCafe') || process.env.BROWSER === 'firefox' || process.env.DevTools === 'true') this.skip();
+      if (isHelper('TestCafe') || process.env.BROWSER === 'firefox' || process.env.DevTools === 'true') this.skip()
 
       try {
-        await I.amOnPage('/');
+        await I.amOnPage('/')
         await I.seeCssPropertiesOnElements('a', {
           color: 'rgb(0, 0, 238)',
           cursor: 'pointer',
-        });
+        })
         await I.seeCssPropertiesOnElements('a', {
           color: '#0000EE',
           cursor: 'pointer',
-        });
+        })
         await I.seeCssPropertiesOnElements('//div', {
           display: 'block',
-        });
+        })
         await I.seeCssPropertiesOnElements('a', {
           'margin-top': '0em',
           cursor: 'pointer',
-        });
-        throw Error('It should never get this far');
+        })
+        throw Error('It should never get this far')
       } catch (e) {
-        e.message.should.include('expected all elements (a) to have CSS property {"margin-top":"0em","cursor":"pointer"}');
+        e.message.should.include(
+          'expected all elements (a) to have CSS property {"margin-top":"0em","cursor":"pointer"}',
+        )
       }
-    });
+    })
 
     it('should normalize css color properties for given element', async function () {
-      if (isHelper('TestCafe')) this.skip();
+      if (isHelper('TestCafe')) this.skip()
 
-      await I.amOnPage('/form/css_colors');
+      await I.amOnPage('/form/css_colors')
       await I.seeCssPropertiesOnElements('#namedColor', {
         'background-color': 'purple',
         color: 'yellow',
-      });
+      })
       await I.seeCssPropertiesOnElements('#namedColor', {
         'background-color': '#800080',
         color: '#ffff00',
-      });
+      })
 
       await I.seeCssPropertiesOnElements('#namedColor', {
         'background-color': 'rgb(128,0,128)',
         color: 'rgb(255,255,0)',
-      });
+      })
 
       await I.seeCssPropertiesOnElements('#namedColor', {
         'background-color': 'rgba(128,0,128,1)',
         color: 'rgba(255,255,0,1)',
-      });
-    });
-  });
+      })
+    })
+  })
 
   describe('#customLocators', () => {
     beforeEach(() => {
-      originalLocators = Locator.filters;
-      Locator.filters = [];
-    });
+      originalLocators = Locator.filters
+      Locator.filters = []
+    })
     afterEach(() => {
       // reset custom locators
-      Locator.filters = originalLocators;
-    });
+      Locator.filters = originalLocators
+    })
     it('should support xpath custom locator by default', async () => {
       customLocators({
         attribute: 'data-test-id',
         enabled: true,
-      });
-      await I.amOnPage('/form/custom_locator');
-      await I.dontSee('Step One Button');
-      await I.dontSeeElement('$step_1');
-      await I.waitForVisible('$step_1', 2);
-      await I.seeElement('$step_1');
-      await I.click('$step_1');
-      await I.waitForVisible('$step_2', 2);
-      await I.see('Step Two Button');
-    });
+      })
+      await I.amOnPage('/form/custom_locator')
+      await I.dontSee('Step One Button')
+      await I.dontSeeElement('$step_1')
+      await I.waitForVisible('$step_1', 2)
+      await I.seeElement('$step_1')
+      await I.click('$step_1')
+      await I.waitForVisible('$step_2', 2)
+      await I.see('Step Two Button')
+    })
     it('can use css strategy for custom locator', async () => {
       customLocators({
         attribute: 'data-test-id',
         enabled: true,
         strategy: 'css',
-      });
-      await I.amOnPage('/form/custom_locator');
-      await I.dontSee('Step One Button');
-      await I.dontSeeElement('$step_1');
-      await I.waitForVisible('$step_1', 2);
-      await I.seeElement('$step_1');
-      await I.click('$step_1');
-      await I.waitForVisible('$step_2', 2);
-      await I.see('Step Two Button');
-    });
+      })
+      await I.amOnPage('/form/custom_locator')
+      await I.dontSee('Step One Button')
+      await I.dontSeeElement('$step_1')
+      await I.waitForVisible('$step_1', 2)
+      await I.seeElement('$step_1')
+      await I.click('$step_1')
+      await I.waitForVisible('$step_2', 2)
+      await I.see('Step Two Button')
+    })
     it('can use xpath strategy for custom locator', async () => {
       customLocators({
         attribute: 'data-test-id',
         enabled: true,
         strategy: 'xpath',
-      });
-      await I.amOnPage('/form/custom_locator');
-      await I.dontSee('Step One Button');
-      await I.dontSeeElement('$step_1');
-      await I.waitForVisible('$step_1', 2);
-      await I.seeElement('$step_1');
-      await I.click('$step_1');
-      await I.waitForVisible('$step_2', 2);
-      await I.see('Step Two Button');
-    });
-  });
+      })
+      await I.amOnPage('/form/custom_locator')
+      await I.dontSee('Step One Button')
+      await I.dontSeeElement('$step_1')
+      await I.waitForVisible('$step_1', 2)
+      await I.seeElement('$step_1')
+      await I.click('$step_1')
+      await I.waitForVisible('$step_2', 2)
+      await I.see('Step Two Button')
+    })
+  })
 
   describe('#focus, #blur', () => {
     it('should focus a button, field and textarea', async () => {
-      await I.amOnPage('/form/focus_blur_elements');
+      await I.amOnPage('/form/focus_blur_elements')
 
-      await I.focus('#button');
-      await I.see('Button is focused', '#buttonMessage');
+      await I.focus('#button')
+      await I.see('Button is focused', '#buttonMessage')
 
-      await I.focus('#field');
-      await I.see('Button not focused', '#buttonMessage');
-      await I.see('Input field is focused', '#fieldMessage');
+      await I.focus('#field')
+      await I.see('Button not focused', '#buttonMessage')
+      await I.see('Input field is focused', '#fieldMessage')
 
-      await I.focus('#textarea');
-      await I.see('Button not focused', '#buttonMessage');
-      await I.see('Input field not focused', '#fieldMessage');
-      await I.see('Textarea is focused', '#textareaMessage');
-    });
+      await I.focus('#textarea')
+      await I.see('Button not focused', '#buttonMessage')
+      await I.see('Input field not focused', '#fieldMessage')
+      await I.see('Textarea is focused', '#textareaMessage')
+    })
 
     it('should blur focused button, field and textarea', async () => {
-      await I.amOnPage('/form/focus_blur_elements');
+      await I.amOnPage('/form/focus_blur_elements')
 
-      await I.focus('#button');
-      await I.see('Button is focused', '#buttonMessage');
-      await I.blur('#button');
-      await I.see('Button not focused', '#buttonMessage');
+      await I.focus('#button')
+      await I.see('Button is focused', '#buttonMessage')
+      await I.blur('#button')
+      await I.see('Button not focused', '#buttonMessage')
 
-      await I.focus('#field');
-      await I.see('Input field is focused', '#fieldMessage');
-      await I.blur('#field');
-      await I.see('Input field not focused', '#fieldMessage');
+      await I.focus('#field')
+      await I.see('Input field is focused', '#fieldMessage')
+      await I.blur('#field')
+      await I.see('Input field not focused', '#fieldMessage')
 
-      await I.focus('#textarea');
-      await I.see('Textarea is focused', '#textareaMessage');
-      await I.blur('#textarea');
-      await I.see('Textarea not focused', '#textareaMessage');
-    });
-  });
+      await I.focus('#textarea')
+      await I.see('Textarea is focused', '#textareaMessage')
+      await I.blur('#textarea')
+      await I.see('Textarea not focused', '#textareaMessage')
+    })
+  })
 
   describe('#startRecordingTraffic, #seeTraffic, #stopRecordingTraffic, #dontSeeTraffic, #grabRecordedNetworkTraffics', () => {
     beforeEach(function () {
-      if (isHelper('TestCafe') || process.env.isSelenium === 'true') this.skip();
-    });
+      if (isHelper('TestCafe') || process.env.isSelenium === 'true') this.skip()
+    })
 
     it('should throw error when calling seeTraffic before recording traffics', async () => {
       try {
-        I.amOnPage('https://codecept.io/');
-        await I.seeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
+        I.amOnPage('https://codecept.io/')
+        await I.seeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
       } catch (e) {
-        expect(e.message).to.equal('Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.');
+        expect(e.message).to.equal(
+          'Failure in test automation. You use "I.seeTraffic", but "I.startRecordingTraffic" was never called before.',
+        )
       }
-    });
+    })
 
     it('should throw error when calling seeTraffic but missing name', async () => {
       try {
-        I.amOnPage('https://codecept.io/');
-        await I.seeTraffic({ url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
+        I.amOnPage('https://codecept.io/')
+        await I.seeTraffic({ url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
       } catch (e) {
-        expect(e.message).to.equal('Missing required key "name" in object given to "I.seeTraffic".');
+        expect(e.message).to.equal('Missing required key "name" in object given to "I.seeTraffic".')
       }
-    });
+    })
 
     it('should throw error when calling seeTraffic but missing url', async () => {
       try {
-        I.amOnPage('https://codecept.io/');
-        await I.seeTraffic({ name: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
+        I.amOnPage('https://codecept.io/')
+        await I.seeTraffic({ name: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
       } catch (e) {
-        expect(e.message).to.equal('Missing required key "url" in object given to "I.seeTraffic".');
+        expect(e.message).to.equal('Missing required key "url" in object given to "I.seeTraffic".')
       }
-    });
+    })
 
     it('should flush the network traffics', async () => {
-      await I.startRecordingTraffic();
-      await I.amOnPage('https://codecept.io/');
-      await I.flushNetworkTraffics();
-      const traffics = await I.grabRecordedNetworkTraffics();
-      expect(traffics.length).to.equal(0);
-    });
+      await I.startRecordingTraffic()
+      await I.amOnPage('https://codecept.io/')
+      await I.flushNetworkTraffics()
+      const traffics = await I.grabRecordedNetworkTraffics()
+      expect(traffics.length).to.equal(0)
+    })
 
     it('should see recording traffics', async () => {
-      I.startRecordingTraffic();
-      I.amOnPage('https://codecept.io/');
-      await I.seeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
-    });
+      I.startRecordingTraffic()
+      I.amOnPage('https://codecept.io/')
+      await I.seeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
+    })
 
     it('should not see recording traffics', async () => {
-      I.startRecordingTraffic();
-      I.amOnPage('https://codecept.io/');
-      I.stopRecordingTraffic();
-      await I.dontSeeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
-    });
+      I.startRecordingTraffic()
+      I.amOnPage('https://codecept.io/')
+      I.stopRecordingTraffic()
+      await I.dontSeeTraffic({ name: 'traffics', url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
+    })
 
     it('should not see recording traffics using regex url', async () => {
-      I.startRecordingTraffic();
-      I.amOnPage('https://codecept.io/');
-      I.stopRecordingTraffic();
-      await I.dontSeeTraffic({ name: 'traffics', url: /BC_LogoScreen_C.jpg/ });
-    });
+      I.startRecordingTraffic()
+      I.amOnPage('https://codecept.io/')
+      I.stopRecordingTraffic()
+      await I.dontSeeTraffic({ name: 'traffics', url: /BC_LogoScreen_C.jpg/ })
+    })
 
     it('should throw error when calling dontSeeTraffic but missing name', async () => {
-      I.startRecordingTraffic();
-      I.amOnPage('https://codecept.io/');
-      I.stopRecordingTraffic();
+      I.startRecordingTraffic()
+      I.amOnPage('https://codecept.io/')
+      I.stopRecordingTraffic()
       try {
-        await I.dontSeeTraffic({ url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' });
+        await I.dontSeeTraffic({ url: 'https://codecept.io/img/companies/BC_LogoScreen_C.jpg' })
       } catch (e) {
-        expect(e.message).to.equal('Missing required key "name" in object given to "I.dontSeeTraffic".');
+        expect(e.message).to.equal('Missing required key "name" in object given to "I.dontSeeTraffic".')
       }
-    });
+    })
 
     it('should throw error when calling dontSeeTraffic but missing url', async () => {
-      I.startRecordingTraffic();
-      I.amOnPage('https://codecept.io/');
-      I.stopRecordingTraffic();
+      I.startRecordingTraffic()
+      I.amOnPage('https://codecept.io/')
+      I.stopRecordingTraffic()
       try {
-        await I.dontSeeTraffic({ name: 'traffics' });
+        await I.dontSeeTraffic({ name: 'traffics' })
       } catch (e) {
-        expect(e.message).to.equal('Missing required key "url" in object given to "I.dontSeeTraffic".');
+        expect(e.message).to.equal('Missing required key "url" in object given to "I.dontSeeTraffic".')
       }
-    });
+    })
 
     it('should check traffics with more advanced params', async () => {
-      await I.startRecordingTraffic();
-      await I.amOnPage('https://openaI.com/blog/chatgpt');
-      const traffics = await I.grabRecordedNetworkTraffics();
+      await I.startRecordingTraffic()
+      await I.amOnPage('https://openaI.com/blog/chatgpt')
+      const traffics = await I.grabRecordedNetworkTraffics()
 
       for (const traffic of traffics) {
         if (traffic.url.includes('&width=')) {
           // new URL object
-          const currentUrl = new URL(traffic.url);
+          const currentUrl = new URL(traffic.url)
 
           // get access to URLSearchParams object
-          const searchParams = currentUrl.searchParams;
+          const searchParams = currentUrl.searchParams
 
           await I.seeTraffic({
             name: 'sentry event',
             url: currentUrl.origin + currentUrl.pathname,
             parameters: searchParams,
-          });
+          })
 
-          break;
+          break
         }
       }
-    });
+    })
 
     it.skip('should check traffics with more advanced post data', async () => {
-      await I.amOnPage('https://openaI.com/blog/chatgpt');
-      await I.startRecordingTraffic();
+      await I.amOnPage('https://openaI.com/blog/chatgpt')
+      await I.startRecordingTraffic()
       await I.seeTraffic({
         name: 'event',
         url: 'https://region1.google-analytics.com',
         requestPostData: {
           st: 2,
         },
-      });
-    });
-  });
+      })
+    })
+  })
 
   // the WS test website is not so stable. So we skip those tests for now.
   describe.skip('#startRecordingWebSocketMessages, #grabWebSocketMessages, #stopRecordingWebSocketMessages', () => {
     beforeEach(function () {
-      if (isHelper('TestCafe') || isHelper('WebDriver') || process.env.BROWSER === 'firefox') this.skip();
-    });
+      if (isHelper('TestCafe') || isHelper('WebDriver') || process.env.BROWSER === 'firefox') this.skip()
+    })
 
     it('should throw error when calling grabWebSocketMessages before startRecordingWebSocketMessages', () => {
       try {
-        I.amOnPage('https://websocketstest.com/');
-        I.waitForText('Work for You!');
-        I.grabWebSocketMessages();
+        I.amOnPage('https://websocketstest.com/')
+        I.waitForText('Work for You!')
+        I.grabWebSocketMessages()
       } catch (e) {
-        expect(e.message).to.equal('Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.');
+        expect(e.message).to.equal(
+          'Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.',
+        )
       }
-    });
+    })
 
     it('should flush the WS messages', async () => {
-      await I.startRecordingWebSocketMessages();
-      I.amOnPage('https://websocketstest.com/');
-      I.waitForText('Work for You!');
-      I.flushWebSocketMessages();
-      const wsMessages = I.grabWebSocketMessages();
-      expect(wsMessages.length).to.equal(0);
-    });
+      await I.startRecordingWebSocketMessages()
+      I.amOnPage('https://websocketstest.com/')
+      I.waitForText('Work for You!')
+      I.flushWebSocketMessages()
+      const wsMessages = I.grabWebSocketMessages()
+      expect(wsMessages.length).to.equal(0)
+    })
 
     it('should see recording WS messages', async () => {
-      await I.startRecordingWebSocketMessages();
-      await I.amOnPage('https://websocketstest.com/');
-      I.waitForText('Work for You!');
-      const wsMessages = await I.grabWebSocketMessages();
-      expect(wsMessages.length).to.greaterThan(0);
-    });
+      await I.startRecordingWebSocketMessages()
+      await I.amOnPage('https://websocketstest.com/')
+      I.waitForText('Work for You!')
+      const wsMessages = await I.grabWebSocketMessages()
+      expect(wsMessages.length).to.greaterThan(0)
+    })
 
     it('should not see recording WS messages', async () => {
-      await I.startRecordingWebSocketMessages();
-      await I.amOnPage('https://websocketstest.com/');
-      I.waitForText('Work for You!');
-      const wsMessages = I.grabWebSocketMessages();
-      await I.stopRecordingWebSocketMessages();
-      await I.amOnPage('https://websocketstest.com/');
-      I.waitForText('Work for You!');
-      const afterWsMessages = I.grabWebSocketMessages();
-      expect(wsMessages.length).to.equal(afterWsMessages.length);
-    });
-  });
-};
+      await I.startRecordingWebSocketMessages()
+      await I.amOnPage('https://websocketstest.com/')
+      I.waitForText('Work for You!')
+      const wsMessages = I.grabWebSocketMessages()
+      await I.stopRecordingWebSocketMessages()
+      await I.amOnPage('https://websocketstest.com/')
+      I.waitForText('Work for You!')
+      const afterWsMessages = I.grabWebSocketMessages()
+      expect(wsMessages.length).to.equal(afterWsMessages.length)
+    })
+  })
+}
diff --git a/test/plugin/plugin_test.js b/test/plugin/plugin_test.js
index 4a4f49f66..2aca83c17 100644
--- a/test/plugin/plugin_test.js
+++ b/test/plugin/plugin_test.js
@@ -1,84 +1,77 @@
-const path = require('path');
-const { exec } = require('child_process');
-const { expect } = require('expect');
+const path = require('path')
+const { exec } = require('child_process')
+const { expect } = require('expect')
 
-const runner = path.join(__dirname, '../../bin/codecept.js');
-const codecept_dir = path.join(
-  __dirname,
-  '../acceptance',
-);
-const codecept_run = `${runner} run`;
-const config_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} ${
-  grep ? `--grep "${grep}"` : ''
-}`;
+const runner = path.join(__dirname, '../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '../acceptance')
+const codecept_run = `${runner} run`
+const config_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS plugin', function () {
-  this.timeout(30000);
+  this.timeout(30000)
 
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('should retry the await/non await steps', (done) => {
     exec(`${config_run_config('codecept.Playwright.retryTo.js', '@plugin')} --verbose`, (err, stdout) => {
-      const lines = stdout.split('\n');
-      expect(lines).toEqual(
-        expect.arrayContaining([
-          expect.stringContaining('... Retrying'),
-        ]),
-      );
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      const lines = stdout.split('\n')
+      expect(lines).toEqual(expect.arrayContaining([expect.stringContaining('... Retrying')]))
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should failed before the retryTo instruction', (done) => {
     exec(`${config_run_config('codecept.Playwright.retryTo.js', 'Should be succeed')} --verbose`, (err, stdout) => {
-      expect(stdout).toContain('locator.waitFor: Timeout 1000ms exceeded.');
-      expect(stdout).toContain('[1] Error | Error: element (.nothing) still not visible after 1 sec');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      expect(stdout).toContain('locator.waitFor: Timeout 1000ms exceeded.')
+      expect(stdout).toContain('[1] Error | Error: element (.nothing) still not visible after 1 sec')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should generate the coverage report', (done) => {
     exec(`${config_run_config('codecept.Playwright.coverage.js', '@coverage')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
+      const lines = stdout.split('\n')
       expect(lines).toEqual(
         expect.arrayContaining([
           expect.stringContaining('writing output/coverage'),
           expect.stringContaining('generated coverage reports:'),
           expect.stringContaining('output/coverage/index.html'),
         ]),
-      );
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      )
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should generate the coverage report - WebDriver - Devtools protocol', (done) => {
     exec(`${config_run_config('codecept.WebDriver.devtools.coverage.js', '@coverage')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
+      const lines = stdout.split('\n')
       expect(lines).toEqual(
         expect.arrayContaining([
           expect.stringContaining('writing output/coverage'),
           expect.stringContaining('generated coverage reports:'),
           expect.stringContaining('output/coverage/index.html'),
         ]),
-      );
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      )
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should retry to failure', (done) => {
-    exec(`${config_run_config('codecept.Playwright.retryTo.js', 'Should fail after reached max retries')} --verbose`, (err, stdout) => {
-      const lines = stdout.split('\n');
-      expect(lines).toEqual(
-        expect.arrayContaining([expect.stringContaining('Custom pluginRetryTo Error')]),
-      );
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
-});
+    exec(
+      `${config_run_config('codecept.Playwright.retryTo.js', 'Should fail after reached max retries')} --verbose`,
+      (err, stdout) => {
+        const lines = stdout.split('\n')
+        expect(lines).toEqual(expect.arrayContaining([expect.stringContaining('Custom pluginRetryTo Error')]))
+        expect(err).toBeTruthy()
+        done()
+      },
+    )
+  })
+})
diff --git a/test/rest/ApiDataFactory_test.js b/test/rest/ApiDataFactory_test.js
index b8149b417..f749c2b6e 100644
--- a/test/rest/ApiDataFactory_test.js
+++ b/test/rest/ApiDataFactory_test.js
@@ -1,15 +1,15 @@
-const path = require('path');
-const fs = require('fs');
+const path = require('path')
+const fs = require('fs')
 
-require('../support/setup');
-const TestHelper = require('../support/TestHelper');
-const ApiDataFactory = require('../../lib/helper/ApiDataFactory');
-global.codeceptjs = require('../../lib');
+require('../support/setup')
+const TestHelper = require('../support/TestHelper')
+const ApiDataFactory = require('../../lib/helper/ApiDataFactory')
+global.codeceptjs = require('../../lib')
 
-const api_url = TestHelper.jsonServerUrl();
+const api_url = TestHelper.jsonServerUrl()
 
-let I;
-const dbFile = path.join(__dirname, '/../data/rest/db.json');
+let I
+const dbFile = path.join(__dirname, '/../data/rest/db.json')
 
 const data = {
   comments: [],
@@ -20,11 +20,11 @@ const data = {
       author: 'davert',
     },
   ],
-};
+}
 
 describe('ApiDataFactory', function () {
-  this.timeout(20000);
-  this.retries(1);
+  this.timeout(20000)
+  this.retries(1)
 
   before(() => {
     I = new ApiDataFactory({
@@ -35,36 +35,36 @@ describe('ApiDataFactory', function () {
           uri: '/posts',
         },
       },
-    });
-  });
+    })
+  })
 
   beforeEach((done) => {
     try {
-      fs.writeFileSync(dbFile, JSON.stringify(data));
+      fs.writeFileSync(dbFile, JSON.stringify(data))
     } catch (err) {
       // continue regardless of error
     }
-    setTimeout(done, 5000);
-  });
+    setTimeout(done, 5000)
+  })
 
-  afterEach(() => I._after());
+  afterEach(() => I._after())
 
   describe('create and cleanup records', function () {
-    this.retries(2);
+    this.retries(2)
 
     it('should create a new post', async () => {
-      await I.have('post');
-      const resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(2);
-    });
+      await I.have('post')
+      const resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(2)
+    })
 
     it('should create a new post with predefined field', async () => {
-      await I.have('post', { author: 'Tapac' });
-      let resp = await I.restHelper.sendGetRequest('/posts/1');
-      resp.data.author.should.eql('davert');
-      resp = await I.restHelper.sendGetRequest('/posts/2');
-      resp.data.author.should.eql('Tapac');
-    });
+      await I.have('post', { author: 'Tapac' })
+      let resp = await I.restHelper.sendGetRequest('/posts/1')
+      resp.data.author.should.eql('davert')
+      resp = await I.restHelper.sendGetRequest('/posts/2')
+      resp.data.author.should.eql('Tapac')
+    })
 
     it('should obtain id by function', async () => {
       const I = new ApiDataFactory({
@@ -77,25 +77,25 @@ describe('ApiDataFactory', function () {
             fetchId: () => 'someId',
           },
         },
-      });
-      const id = await I.have('post');
-      id.should.eql('someId');
-    });
+      })
+      const id = await I.have('post')
+      id.should.eql('someId')
+    })
 
     it('should update request with onRequest', async () => {
       const I = new ApiDataFactory({
         endpoint: api_url,
-        onRequest: request => request.data.author = 'Vasya',
+        onRequest: (request) => (request.data.author = 'Vasya'),
         factories: {
           post: {
             factory: path.join(__dirname, '/../data/rest/posts_factory.js'),
             uri: '/posts',
           },
         },
-      });
-      const post = await I.have('post');
-      post.author.should.eql('Vasya');
-    });
+      })
+      const post = await I.have('post')
+      post.author.should.eql('Vasya')
+    })
 
     it('can use functions to set factories', async () => {
       const I = new ApiDataFactory({
@@ -103,46 +103,50 @@ describe('ApiDataFactory', function () {
         factories: {
           post: {
             factory: path.join(__dirname, '/../data/rest/posts_factory.js'),
-            create: () => ({ url: '/posts', method: 'post', data: { author: 'Yorik', title: 'xxx', body: 'yyy' } }),
-            delete: id => ({ url: `/posts/${id}`, method: 'delete' }),
+            create: () => ({
+              url: '/posts',
+              method: 'post',
+              data: { author: 'Yorik', title: 'xxx', body: 'yyy' },
+            }),
+            delete: (id) => ({ url: `/posts/${id}`, method: 'delete' }),
           },
         },
-      });
-      const post = await I.have('post');
-      post.author.should.eql('Yorik');
-    });
+      })
+      const post = await I.have('post')
+      post.author.should.eql('Yorik')
+    })
 
     it('should cleanup created data', async () => {
-      await I.have('post', { author: 'Tapac' });
-      let resp = await I.restHelper.sendGetRequest('/posts');
+      await I.have('post', { author: 'Tapac' })
+      let resp = await I.restHelper.sendGetRequest('/posts')
       for (const post of resp.data) {
         if (post.author === 'Tapac') {
-          post.author.should.eql('Tapac');
+          post.author.should.eql('Tapac')
         }
       }
-      await I._after();
-      resp = await I.restHelper.sendGetRequest('/posts/2');
-      resp.data.should.be.empty;
-      resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(1);
-    });
+      await I._after()
+      resp = await I.restHelper.sendGetRequest('/posts/2')
+      resp.data.should.be.empty
+      resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(1)
+    })
 
     it('should create multiple posts and cleanup after', async () => {
-      let resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(1);
-      await I.haveMultiple('post', 3);
-      await new Promise(done => {
-        setTimeout(done, 500);
-      });
-      resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(4);
-      await I._after();
-      await new Promise(done => {
-        setTimeout(done, 500);
-      });
-      resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(1);
-    });
+      let resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(1)
+      await I.haveMultiple('post', 3)
+      await new Promise((done) => {
+        setTimeout(done, 500)
+      })
+      resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(4)
+      await I._after()
+      await new Promise((done) => {
+        setTimeout(done, 500)
+      })
+      resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(1)
+    })
 
     it('should create with different api', async () => {
       I = new ApiDataFactory({
@@ -155,13 +159,13 @@ describe('ApiDataFactory', function () {
             delete: { delete: '/comments/{id}' },
           },
         },
-      });
-      await I.have('post');
-      let resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(1);
-      resp = await I.restHelper.sendGetRequest('/comments');
-      resp.data.length.should.eql(1);
-    });
+      })
+      await I.have('post')
+      let resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(1)
+      resp = await I.restHelper.sendGetRequest('/comments')
+      resp.data.length.should.eql(1)
+    })
 
     it('should not remove records if cleanup:false', async () => {
       I = new ApiDataFactory({
@@ -173,17 +177,17 @@ describe('ApiDataFactory', function () {
             uri: '/posts',
           },
         },
-      });
-      await I.have('post');
-      let resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(2);
-      await I._after();
-      await new Promise(done => {
-        setTimeout(done, 500);
-      });
-      resp = await I.restHelper.sendGetRequest('/posts');
-      resp.data.length.should.eql(2);
-    });
+      })
+      await I.have('post')
+      let resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(2)
+      await I._after()
+      await new Promise((done) => {
+        setTimeout(done, 500)
+      })
+      resp = await I.restHelper.sendGetRequest('/posts')
+      resp.data.length.should.eql(2)
+    })
 
     it('should send default headers', async () => {
       I = new ApiDataFactory({
@@ -199,11 +203,11 @@ describe('ApiDataFactory', function () {
             create: { post: '/headers' },
           },
         },
-      });
-      const resp = await I.have('post');
-      resp.should.have.property('authorization');
-      resp.should.have.property('auth');
-      resp.auth.should.eql('111');
-    });
-  });
-});
+      })
+      const resp = await I.have('post')
+      resp.should.have.property('authorization')
+      resp.should.have.property('auth')
+      resp.auth.should.eql('111')
+    })
+  })
+})
diff --git a/test/rest/REST_test.js b/test/rest/REST_test.js
index 81d2362f2..7d80acd36 100644
--- a/test/rest/REST_test.js
+++ b/test/rest/REST_test.js
@@ -1,18 +1,18 @@
-const path = require('path');
-const { expect } = require('expect');
-const fs = require('fs');
+const path = require('path')
+const { expect } = require('expect')
+const fs = require('fs')
 
-const TestHelper = require('../support/TestHelper');
-const REST = require('../../lib/helper/REST');
-const Container = require('../../lib/container');
-const Secret = require('../../lib/secret');
+const TestHelper = require('../support/TestHelper')
+const REST = require('../../lib/helper/REST')
+const Container = require('../../lib/container')
+const Secret = require('../../lib/secret')
 
-const api_url = TestHelper.jsonServerUrl();
-global.codeceptjs = require('../../lib');
+const api_url = TestHelper.jsonServerUrl()
+global.codeceptjs = require('../../lib')
 
-let I;
-const dbFile = path.join(__dirname, '/../data/rest/db.json');
-const testFile = path.join(__dirname, '/../data/rest/testUpload.json');
+let I
+const dbFile = path.join(__dirname, '/../data/rest/db.json')
+const testFile = path.join(__dirname, '/../data/rest/testUpload.json')
 
 const data = {
   posts: [
@@ -25,7 +25,7 @@ const data = {
   user: {
     name: 'davert',
   },
-};
+}
 
 describe('REST', () => {
   beforeEach((done) => {
@@ -34,97 +34,97 @@ describe('REST', () => {
       defaultHeaders: {
         'X-Test': 'test',
       },
-    });
+    })
 
     try {
-      fs.writeFileSync(dbFile, JSON.stringify(data));
+      fs.writeFileSync(dbFile, JSON.stringify(data))
     } catch (err) {
       // continue regardless of error
     }
-    setTimeout(done, 1000);
-  });
+    setTimeout(done, 1000)
+  })
 
   describe('basic requests', () => {
     it('should send GET requests', async () => {
-      const response = await I.sendGetRequest('/user');
-      response.data.name.should.eql('davert');
-    });
+      const response = await I.sendGetRequest('/user')
+      response.data.name.should.eql('davert')
+    })
 
     it('should send PATCH requests: payload format = json', async () => {
-      const response = await I.sendPatchRequest('/user', { email: 'user@user.com' });
-      response.data.email.should.eql('user@user.com');
-    });
+      const response = await I.sendPatchRequest('/user', { email: 'user@user.com' })
+      response.data.email.should.eql('user@user.com')
+    })
 
     it('should send PATCH requests: payload format = form urlencoded', async () => {
-      const response = await I.sendPatchRequest('/user', 'email=user@user.com');
-      response.data.email.should.eql('user@user.com');
-    });
+      const response = await I.sendPatchRequest('/user', 'email=user@user.com')
+      response.data.email.should.eql('user@user.com')
+    })
 
     it('should send POST requests: payload format = json', async () => {
-      const response = await I.sendPostRequest('/user', { name: 'john' });
-      response.data.name.should.eql('john');
-    });
+      const response = await I.sendPostRequest('/user', { name: 'john' })
+      response.data.name.should.eql('john')
+    })
 
     it('should send POST requests: payload format = form urlencoded', async () => {
-      const response = await I.sendPostRequest('/user', 'name=john');
-      response.data.name.should.eql('john');
-    });
+      const response = await I.sendPostRequest('/user', 'name=john')
+      response.data.name.should.eql('john')
+    })
 
     it('should send POST requests with secret', async () => {
-      const secretData = Secret.secret({ name: 'john', password: '123456' }, 'password');
-      const response = await I.sendPostRequest('/user', secretData);
-      response.data.name.should.eql('john');
-      expect(response.data.password).toEqual({ _secret: '123456' });
-      expect(secretData.password.getMasked()).toEqual('*****');
-    });
+      const secretData = Secret.secret({ name: 'john', password: '123456' }, 'password')
+      const response = await I.sendPostRequest('/user', secretData)
+      response.data.name.should.eql('john')
+      expect(response.data.password).toEqual({ _secret: '123456' })
+      expect(secretData.password.getMasked()).toEqual('*****')
+    })
 
     it('should send POST requests with secret form encoded is not converted to string', async () => {
-      const secretData = Secret.secret('name=john&password=123456');
-      const response = await I.sendPostRequest('/user', secretData);
-      response.data.name.should.eql('john');
-      response.data.password.should.eql('123456');
-      secretData.getMasked().should.eql('*****');
-    });
+      const secretData = Secret.secret('name=john&password=123456')
+      const response = await I.sendPostRequest('/user', secretData)
+      response.data.name.should.eql('john')
+      response.data.password.should.eql('123456')
+      secretData.getMasked().should.eql('*****')
+    })
 
     it('should send PUT requests: payload format = json', async () => {
-      const putResponse = await I.sendPutRequest('/posts/1', { author: 'john' });
-      putResponse.data.author.should.eql('john');
+      const putResponse = await I.sendPutRequest('/posts/1', { author: 'john' })
+      putResponse.data.author.should.eql('john')
 
-      const getResponse = await I.sendGetRequest('/posts/1');
-      getResponse.data.author.should.eql('john');
-    });
+      const getResponse = await I.sendGetRequest('/posts/1')
+      getResponse.data.author.should.eql('john')
+    })
 
     it('should send PUT requests: payload format = form urlencoded', async () => {
-      const putResponse = await I.sendPutRequest('/posts/1', 'author=john');
-      putResponse.data.author.should.eql('john');
+      const putResponse = await I.sendPutRequest('/posts/1', 'author=john')
+      putResponse.data.author.should.eql('john')
 
-      const getResponse = await I.sendGetRequest('/posts/1');
-      getResponse.data.author.should.eql('john');
-    });
+      const getResponse = await I.sendGetRequest('/posts/1')
+      getResponse.data.author.should.eql('john')
+    })
 
     it('should send DELETE requests', async () => {
-      await I.sendDeleteRequest('/posts/1');
-      const getResponse = await I.sendGetRequest('/posts');
+      await I.sendDeleteRequest('/posts/1')
+      const getResponse = await I.sendGetRequest('/posts')
 
-      getResponse.data.should.be.empty;
-    });
+      getResponse.data.should.be.empty
+    })
 
     it('should update request with onRequest', async () => {
-      I.config.onRequest = request => (request.data = { name: 'Vasya' });
+      I.config.onRequest = (request) => (request.data = { name: 'Vasya' })
 
-      const response = await I.sendPostRequest('/user', { name: 'john' });
-      response.data.name.should.eql('Vasya');
-    });
+      const response = await I.sendPostRequest('/user', { name: 'john' })
+      response.data.name.should.eql('Vasya')
+    })
 
     it('should set timeout for the request', async () => {
-      await I.setRequestTimeout(2000);
-      const response = await I.sendGetRequest('/posts');
-      response.config.timeout.should.eql(2000);
-    });
-  });
+      await I.setRequestTimeout(2000)
+      const response = await I.sendGetRequest('/posts')
+      response.config.timeout.should.eql(2000)
+    })
+  })
 
   describe('JSONResponse integration', () => {
-    let jsonResponse;
+    let jsonResponse
 
     beforeEach(() => {
       Container.create({
@@ -132,214 +132,207 @@ describe('REST', () => {
           REST: {},
           JSONResponse: {},
         },
-      });
-      I = Container.helpers('REST');
-      jsonResponse = Container.helpers('JSONResponse');
-      jsonResponse._beforeSuite();
-    });
+      })
+      I = Container.helpers('REST')
+      jsonResponse = Container.helpers('JSONResponse')
+      jsonResponse._beforeSuite()
+    })
 
     afterEach(() => {
-      Container.clear();
-    });
+      Container.clear()
+    })
 
     it('should be able to parse JSON responses', async () => {
-      await I.sendGetRequest('https://reqres.in/api/comments/1');
-      await jsonResponse.seeResponseCodeIsSuccessful();
-      await jsonResponse.seeResponseContainsKeys(['data', 'support']);
-    });
-  });
+      await I.sendGetRequest('https://reqres.in/api/comments/1')
+      await jsonResponse.seeResponseCodeIsSuccessful()
+      await jsonResponse.seeResponseContainsKeys(['data', 'support'])
+    })
+  })
 
   describe('headers', () => {
     it('should send request headers', async () => {
-      const response = await I.sendGetRequest('/user', { 'Content-Type': 'application/json' });
+      const response = await I.sendGetRequest('/user', { 'Content-Type': 'application/json' })
 
-      response.headers.should.have.property('content-type');
-      response.headers['content-type'].should.include('application/json');
+      response.headers.should.have.property('content-type')
+      response.headers['content-type'].should.include('application/json')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should set request headers', async () => {
       const response = await I.sendGetRequest('/user', {
         'Content-Type': 'application/json',
         HTTP_X_REQUESTED_WITH: 'xmlhttprequest',
-      });
+      })
 
-      response.config.headers.should.have.property('Content-Type');
-      response.config.headers['Content-Type'].should.eql('application/json');
+      response.config.headers.should.have.property('Content-Type')
+      response.config.headers['Content-Type'].should.eql('application/json')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
 
-      response.config.headers.should.have.property('HTTP_X_REQUESTED_WITH');
-      response.config.headers.HTTP_X_REQUESTED_WITH.should.eql('xmlhttprequest');
-    });
+      response.config.headers.should.have.property('HTTP_X_REQUESTED_WITH')
+      response.config.headers.HTTP_X_REQUESTED_WITH.should.eql('xmlhttprequest')
+    })
 
     it('should set Content-Type header if data is string and Content-Type is omitted', async () => {
-      const response = await I.sendPostRequest(
-        '/user',
-        'string of data',
-      );
+      const response = await I.sendPostRequest('/user', 'string of data')
 
-      response.config.headers.should.have.property('Content-Type');
-      response.config.headers['Content-Type'].should.eql('application/x-www-form-urlencoded');
-    });
+      response.config.headers.should.have.property('Content-Type')
+      response.config.headers['Content-Type'].should.eql('application/x-www-form-urlencoded')
+    })
 
     it('should respect any passsed in Content-Type header', async () => {
-      const response = await I.sendPostRequest(
-        '/user',
-        'bad json data',
-        { 'Content-Type': 'application/json' },
-      );
+      const response = await I.sendPostRequest('/user', 'bad json data', { 'Content-Type': 'application/json' })
 
-      response.config.headers.should.have.property('Content-Type');
-      response.config.headers['Content-Type'].should.eql('application/json');
-    });
+      response.config.headers.should.have.property('Content-Type')
+      response.config.headers['Content-Type'].should.eql('application/json')
+    })
 
     it('should set headers for all requests', async () => {
-      I.haveRequestHeaders({ 'XY1-Test': 'xy1test' });
+      I.haveRequestHeaders({ 'XY1-Test': 'xy1test' })
       // 1st request
       {
-        const response = await I.sendGetRequest('/user');
+        const response = await I.sendGetRequest('/user')
 
-        response.config.headers.should.have.property('XY1-Test');
-        response.config.headers['XY1-Test'].should.eql('xy1test');
+        response.config.headers.should.have.property('XY1-Test')
+        response.config.headers['XY1-Test'].should.eql('xy1test')
 
-        response.config.headers.should.have.property('X-Test');
-        response.config.headers['X-Test'].should.eql('test');
+        response.config.headers.should.have.property('X-Test')
+        response.config.headers['X-Test'].should.eql('test')
       }
       // 2nd request
       {
-        const response = await I.sendPostRequest('/user', { name: 'john' }, { 'XY2-Test': 'xy2test' });
+        const response = await I.sendPostRequest('/user', { name: 'john' }, { 'XY2-Test': 'xy2test' })
 
-        response.config.headers.should.have.property('XY1-Test');
-        response.config.headers['XY1-Test'].should.eql('xy1test');
+        response.config.headers.should.have.property('XY1-Test')
+        response.config.headers['XY1-Test'].should.eql('xy1test')
 
-        response.config.headers.should.have.property('XY2-Test');
-        response.config.headers['XY2-Test'].should.include('xy2test');
+        response.config.headers.should.have.property('XY2-Test')
+        response.config.headers['XY2-Test'].should.include('xy2test')
 
-        response.config.headers.should.have.property('X-Test');
-        response.config.headers['X-Test'].should.eql('test');
+        response.config.headers.should.have.property('X-Test')
+        response.config.headers['X-Test'].should.eql('test')
       }
-    });
+    })
 
     it('should set headers for all requests multiple times', async () => {
-      I.haveRequestHeaders({ 'XY1-Test': 'xy1-first' });
-      I.haveRequestHeaders({ 'XY1-Test': 'xy1-second' });
-      I.haveRequestHeaders({ 'XY2-Test': 'xy2' });
+      I.haveRequestHeaders({ 'XY1-Test': 'xy1-first' })
+      I.haveRequestHeaders({ 'XY1-Test': 'xy1-second' })
+      I.haveRequestHeaders({ 'XY2-Test': 'xy2' })
       {
-        const response = await I.sendGetRequest('/user');
+        const response = await I.sendGetRequest('/user')
 
-        response.config.headers.should.have.property('XY1-Test');
-        response.config.headers['XY1-Test'].should.eql('xy1-second');
+        response.config.headers.should.have.property('XY1-Test')
+        response.config.headers['XY1-Test'].should.eql('xy1-second')
 
-        response.config.headers.should.have.property('XY2-Test');
-        response.config.headers['XY2-Test'].should.eql('xy2');
+        response.config.headers.should.have.property('XY2-Test')
+        response.config.headers['XY2-Test'].should.eql('xy2')
 
-        response.config.headers.should.have.property('X-Test');
-        response.config.headers['X-Test'].should.eql('test');
+        response.config.headers.should.have.property('X-Test')
+        response.config.headers['X-Test'].should.eql('test')
       }
-    });
+    })
 
     it('should override the header set for all requests', async () => {
-      I.haveRequestHeaders({ 'XY-Test': 'first' });
+      I.haveRequestHeaders({ 'XY-Test': 'first' })
       {
-        const response = await I.sendGetRequest('/user', { 'XY-Test': 'value_custom' });
+        const response = await I.sendGetRequest('/user', { 'XY-Test': 'value_custom' })
 
-        response.config.headers.should.have.property('XY-Test');
-        response.config.headers['XY-Test'].should.eql('value_custom');
+        response.config.headers.should.have.property('XY-Test')
+        response.config.headers['XY-Test'].should.eql('value_custom')
 
-        response.config.headers.should.have.property('X-Test');
-        response.config.headers['X-Test'].should.eql('test');
+        response.config.headers.should.have.property('X-Test')
+        response.config.headers['X-Test'].should.eql('test')
       }
-    });
+    })
 
     it('should set Bearer authorization', async () => {
-      I.amBearerAuthenticated('token');
-      const response = await I.sendGetRequest('/user');
+      I.amBearerAuthenticated('token')
+      const response = await I.sendGetRequest('/user')
 
-      response.config.headers.should.have.property('Authorization');
-      response.config.headers.Authorization.should.eql('Bearer token');
+      response.config.headers.should.have.property('Authorization')
+      response.config.headers.Authorization.should.eql('Bearer token')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should set Bearer authorization multiple times', async () => {
-      I.amBearerAuthenticated('token1');
-      I.amBearerAuthenticated('token2');
-      const response = await I.sendGetRequest('/user');
+      I.amBearerAuthenticated('token1')
+      I.amBearerAuthenticated('token2')
+      const response = await I.sendGetRequest('/user')
 
-      response.config.headers.should.have.property('Authorization');
-      response.config.headers.Authorization.should.eql('Bearer token2');
+      response.config.headers.should.have.property('Authorization')
+      response.config.headers.Authorization.should.eql('Bearer token2')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
 
     it('should override Bearer authorization', async () => {
-      I.amBearerAuthenticated('token');
-      const response = await I.sendGetRequest('/user', { Authorization: 'Bearer token_custom' });
+      I.amBearerAuthenticated('token')
+      const response = await I.sendGetRequest('/user', { Authorization: 'Bearer token_custom' })
 
-      response.config.headers.should.have.property('Authorization');
-      response.config.headers.Authorization.should.eql('Bearer token_custom');
+      response.config.headers.should.have.property('Authorization')
+      response.config.headers.Authorization.should.eql('Bearer token_custom')
 
-      response.config.headers.should.have.property('X-Test');
-      response.config.headers['X-Test'].should.eql('test');
-    });
-  });
+      response.config.headers.should.have.property('X-Test')
+      response.config.headers['X-Test'].should.eql('test')
+    })
+  })
 
   describe('_url autocompletion', () => {
     it('should not prepend base url, when url is absolute', () => {
-      I._url('https://bla.bla/blabla').should.eql('https://bla.bla/blabla');
-    });
+      I._url('https://bla.bla/blabla').should.eql('https://bla.bla/blabla')
+    })
 
     it('should prepend base url, when url is not absolute', () => {
-      I._url('/blabla').should.eql(`${api_url}/blabla`);
-    });
+      I._url('/blabla').should.eql(`${api_url}/blabla`)
+    })
 
     it('should prepend base url, when url is not absolute, and "http" in request', () => {
-      I._url('/blabla&p=http://bla.bla').should.eql(`${api_url}/blabla&p=http://bla.bla`);
-    });
-  });
-});
+      I._url('/blabla&p=http://bla.bla').should.eql(`${api_url}/blabla&p=http://bla.bla`)
+    })
+  })
+})
 
 describe('REST - Form upload', () => {
   beforeEach((done) => {
     I = new REST({
       endpoint: 'http://the-internet.herokuapp.com/',
-      maxUploadFileSize: 0.000080,
+      maxUploadFileSize: 0.00008,
       defaultHeaders: {
         'X-Test': 'test',
       },
-    });
+    })
 
-    setTimeout(done, 1000);
-  });
+    setTimeout(done, 1000)
+  })
 
   describe('upload file', () => {
     it('should show error when file size exceedes the permit', async () => {
-      const form = new FormData();
-      form.append('file', fs.createReadStream(testFile));
+      const form = new FormData()
+      form.append('file', fs.createReadStream(testFile))
 
       try {
-        await I.sendPostRequest('upload', form);
+        await I.sendPostRequest('upload', form)
       } catch (error) {
-        error.message.should.eql('Request body larger than maxBodyLength limit');
+        error.message.should.eql('Request body larger than maxBodyLength limit')
       }
-    });
+    })
 
     it('should not show error when file size doesnt exceedes the permit', async () => {
-      const form = new FormData();
-      form.append('file', fs.createReadStream(testFile));
+      const form = new FormData()
+      form.append('file', fs.createReadStream(testFile))
 
       try {
-        const response = await I.sendPostRequest('upload', form);
-        response.data.should.include('File Uploaded!');
+        const response = await I.sendPostRequest('upload', form)
+        response.data.should.include('File Uploaded!')
       } catch (error) {
-        console.log(error.message);
+        console.log(error.message)
       }
-    });
-  });
-});
+    })
+  })
+})
diff --git a/test/runner/bdd_test.js b/test/runner/bdd_test.js
index 15de73f4e..9725e5e22 100644
--- a/test/runner/bdd_test.js
+++ b/test/runner/bdd_test.js
@@ -1,257 +1,290 @@
-const assert = require('assert');
-const path = require('path');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run`;
-const config_run_config = config => `${codecept_run} --config ${codecept_dir}/${config}`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run`
+const config_run_config = (config) => `${codecept_run} --config ${codecept_dir}/${config}`
 
 describe('BDD Gherkin', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('should run feature files', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout process"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Checkout process'); // feature
-      stdout.should.include('-- before checkout --');
-      stdout.should.include('-- after checkout --');
+    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout process"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Checkout process') // feature
+      stdout.should.include('-- before checkout --')
+      stdout.should.include('-- after checkout --')
       // stdout.should.include('In order to buy products'); // test name
-      stdout.should.include('Given I have product with $600 price');
-      stdout.should.include('And I have product with $1000 price');
-      stdout.should.include('Then I should see that total number of products is 2');
-      stdout.should.include('And my order amount is $1600');
-      stdout.should.not.include('I add item 600'); // 'Given' actor's non-gherkin step check
-      stdout.should.not.include('I see sum 1600'); // 'And' actor's non-gherkin step check
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Given I have product with $600 price')
+      stdout.should.include('And I have product with $1000 price')
+      stdout.should.include('Then I should see that total number of products is 2')
+      stdout.should.include('And my order amount is $1600')
+      stdout.should.not.include('I add item 600') // 'Given' actor's non-gherkin step check
+      stdout.should.not.include('I see sum 1600') // 'And' actor's non-gherkin step check
+      assert(!err)
+      done()
+    })
+  })
 
   it('should print substeps in debug mode', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --debug --grep "Checkout process"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Checkout process'); // feature
+    exec(config_run_config('codecept.bdd.js') + ' --debug --grep "Checkout process"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Checkout process') // feature
       // stdout.should.include('In order to buy products'); // test name
-      stdout.should.include('Given I have product with $600 price');
-      stdout.should.include('I add item 600');
-      stdout.should.include('And I have product with $1000 price');
-      stdout.should.include('I add item 1000');
-      stdout.should.include('Then I should see that total number of products is 2');
-      stdout.should.include('I see num 2');
-      stdout.should.include('And my order amount is $1600');
-      stdout.should.include('I see sum 1600');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Given I have product with $600 price')
+      stdout.should.include('I add item 600')
+      stdout.should.include('And I have product with $1000 price')
+      stdout.should.include('I add item 1000')
+      stdout.should.include('Then I should see that total number of products is 2')
+      stdout.should.include('I see num 2')
+      stdout.should.include('And my order amount is $1600')
+      stdout.should.include('I see sum 1600')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should print events in nodejs debug mode', (done) => {
-    exec(`DEBUG=codeceptjs:* ${config_run_config('codecept.bdd.js')} --grep "Checkout products" --debug`, (err, stdout, stderr) => { //eslint-disable-line
-      stderr.should.include('Emitted | step.start (I add product "Harry Potter", 5)');
-      stdout.should.include('name            | category        | price');
-      stdout.should.include('Harry Potter    | Books           | 5');
-      stdout.should.include('iPhone 5        | Smartphones     | 1200 ');
-      stdout.should.include('Nuclear Bomb    | Weapons         | 100000');
-      assert(!err);
-      done();
-    });
-  });
+    exec(
+      `DEBUG=codeceptjs:* ${config_run_config('codecept.bdd.js')} --grep "Checkout products" --debug`,
+      (err, stdout, stderr) => {
+        //eslint-disable-line
+        stderr.should.include('Emitted | step.start (I add product "Harry Potter", 5)')
+        stdout.should.include('name            | category        | price')
+        stdout.should.include('Harry Potter    | Books           | 5')
+        stdout.should.include('iPhone 5        | Smartphones     | 1200 ')
+        stdout.should.include('Nuclear Bomb    | Weapons         | 100000')
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should obfuscate secret substeps in debug mode', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --debug --grep "Secrets"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Given I login'); // feature
-      stdout.should.not.include('password');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --debug --grep "Secrets"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Given I login') // feature
+      stdout.should.not.include('password')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature with examples files', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout examples"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include(' order discount {"price":"10","total":"10.0"}');
-      stdout.should.include(' Given I have product with price 10$ in my cart');
+    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout examples"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include(' order discount {"price":"10","total":"10.0"}')
+      stdout.should.include(' Given I have product with price 10$ in my cart')
 
-      stdout.should.include(' order discount {"price":"20","total":"20.0"}');
-      stdout.should.include(' Given I have product with price 20$ in my cart');
+      stdout.should.include(' order discount {"price":"20","total":"20.0"}')
+      stdout.should.include(' Given I have product with price 20$ in my cart')
 
-      stdout.should.include(' order discount {"price":"21","total":"18.9"}');
-      stdout.should.include(' Given I have product with price 21$ in my cart');
+      stdout.should.include(' order discount {"price":"21","total":"18.9"}')
+      stdout.should.include(' Given I have product with price 21$ in my cart')
 
-      stdout.should.include(' order discount {"price":"30","total":"27.0"}');
-      stdout.should.include(' Given I have product with price 30$ in my cart');
+      stdout.should.include(' order discount {"price":"30","total":"27.0"}')
+      stdout.should.include(' Given I have product with price 30$ in my cart')
 
-      stdout.should.include(' order discount {"price":"50","total":"45.0"}');
-      stdout.should.include(' Given I have product with price 50$ in my cart');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include(' order discount {"price":"50","total":"45.0"}')
+      stdout.should.include(' Given I have product with price 50$ in my cart')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature with table and examples files', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Include Examples in dataTtable placeholder"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('name            | Nuclear Bomb ');
-      stdout.should.include('price           | 20 ');
-      stdout.should.include('name            | iPhone 5 ');
-      stdout.should.include('price           | 10 ');
-      assert(!err);
-      done();
-    });
-  });
+    exec(
+      config_run_config('codecept.bdd.js') + ' --steps --grep "Include Examples in dataTtable placeholder"',
+      (err, stdout, stderr) => {
+        //eslint-disable-line
+        stdout.should.include('name            | Nuclear Bomb ')
+        stdout.should.include('price           | 20 ')
+        stdout.should.include('name            | iPhone 5 ')
+        stdout.should.include('price           | 10 ')
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should show data from examples in test title', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Include Examples in dataTtable placeholder"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('order a product with discount - iPhone 5 - 10  @IncludeExamplesIndataTtable');
-      stdout.should.include('name            | Nuclear Bomb ');
-      stdout.should.include('price           | 20 ');
-      stdout.should.include('name            | iPhone 5 ');
-      stdout.should.include('price           | 10 ');
-      assert(!err);
-      done();
-    });
-  });
+    exec(
+      config_run_config('codecept.bdd.js') + ' --steps --grep "Include Examples in dataTtable placeholder"',
+      (err, stdout, stderr) => {
+        //eslint-disable-line
+        stdout.should.include('order a product with discount - iPhone 5 - 10  @IncludeExamplesIndataTtable')
+        stdout.should.include('name            | Nuclear Bomb ')
+        stdout.should.include('price           | 20 ')
+        stdout.should.include('name            | iPhone 5 ')
+        stdout.should.include('price           | 10 ')
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should run feature with tables', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout products"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Given I have products in my cart');
-      stdout.should.include('name');
-      stdout.should.include('Harry Potter');
-      stdout.should.include('Smartphones');
-      stdout.should.include('100000');
-      stdout.should.include('Then my order amount is $101205');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout products"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Given I have products in my cart')
+      stdout.should.include('name')
+      stdout.should.include('Harry Potter')
+      stdout.should.include('Smartphones')
+      stdout.should.include('100000')
+      stdout.should.include('Then my order amount is $101205')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature with tables contain long text', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout products"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Given I have products in my cart');
-      stdout.should.include('name');
-      stdout.should.include('Harry Potter and the deathly hallows');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout products"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Given I have products in my cart')
+      stdout.should.include('name')
+      stdout.should.include('Harry Potter and the deathly hallows')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature with long strings', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout string"', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Given I have product described as');
-      stdout.should.include('The goal of the product description is to provide the customer with enough information to compel them to want to buy the product immediately.');
-      stdout.should.include('Then my order amount is $582');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --steps --grep "Checkout string"', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Given I have product described as')
+      stdout.should.include(
+        'The goal of the product description is to provide the customer with enough information to compel them to want to buy the product immediately.',
+      )
+      stdout.should.include('Then my order amount is $582')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature by file name', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --steps features/tables.feature', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Checkout product');
-      stdout.should.include('checkout 3 products');
-      stdout.should.not.include('Checkout string');
-      stdout.should.not.include('describe product');
-      stdout.should.not.include('Checkout process');
-      stdout.should.not.include('Checkout examples process');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --steps features/tables.feature', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Checkout product')
+      stdout.should.include('checkout 3 products')
+      stdout.should.not.include('Checkout string')
+      stdout.should.not.include('describe product')
+      stdout.should.not.include('Checkout process')
+      stdout.should.not.include('Checkout examples process')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature by scenario name', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "checkout 3 products" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Checkout product');
-      stdout.should.include('checkout 3 products');
-      stdout.should.not.include('Checkout string');
-      stdout.should.not.include('describe product');
-      stdout.should.not.include('Checkout process');
-      stdout.should.not.include('Checkout examples process');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "checkout 3 products" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Checkout product')
+      stdout.should.include('checkout 3 products')
+      stdout.should.not.include('Checkout string')
+      stdout.should.not.include('describe product')
+      stdout.should.not.include('Checkout process')
+      stdout.should.not.include('Checkout examples process')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run feature by tag name', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "@important" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('I have product with $600 price in my cart');
-      stdout.should.not.include('Checkout string');
-      stdout.should.not.include('describe product');
-      stdout.should.not.include('Checkout table');
-      stdout.should.not.include('Checkout examples process');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@important" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('I have product with $600 price in my cart')
+      stdout.should.not.include('Checkout string')
+      stdout.should.not.include('describe product')
+      stdout.should.not.include('Checkout table')
+      stdout.should.not.include('Checkout examples process')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run scenario by tag name', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "@very" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('I have product with $600 price in my cart');
-      stdout.should.not.include('Checkout string');
-      stdout.should.not.include('describe product');
-      stdout.should.not.include('Checkout table');
-      stdout.should.not.include('Checkout examples process');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@very" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('I have product with $600 price in my cart')
+      stdout.should.not.include('Checkout string')
+      stdout.should.not.include('describe product')
+      stdout.should.not.include('Checkout table')
+      stdout.should.not.include('Checkout examples process')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run scenario outline by tag', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "@user" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.not.include('0 passed');
-      stdout.should.include('I have product with price 10$');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@user" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.not.include('0 passed')
+      stdout.should.include('I have product with price 10$')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run scenario and scenario outline by tags', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "\@user|\@very" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.not.include('0 passed');
-      stdout.should.include('I have product with price 10$');
-      stdout.should.include('I have product with $600 price in my cart');
-      stdout.should.include('6 passed');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@user|@very" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.not.include('0 passed')
+      stdout.should.include('I have product with price 10$')
+      stdout.should.include('I have product with $600 price in my cart')
+      stdout.should.include('6 passed')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run scenario and scenario outline by tags', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "\@user|\@very" --steps', (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.not.include('0 passed');
-      stdout.should.include('I have product with price 10$');
-      stdout.should.include('I have product with $600 price in my cart');
-      stdout.should.include('6 passed');
-      assert(!err);
-      done();
-    });
-  });
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@user|@very" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.not.include('0 passed')
+      stdout.should.include('I have product with price 10$')
+      stdout.should.include('I have product with $600 price in my cart')
+      stdout.should.include('6 passed')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run not get stuck on failing step', (done) => {
-    exec(config_run_config('codecept.bdd.js') + ' --grep "@fail" --steps', (err, stdout, stderr) => { //eslint-disable-line
+    exec(config_run_config('codecept.bdd.js') + ' --grep "@fail" --steps', (err, stdout, stderr) => {
+      //eslint-disable-line
       // stdout.should.include('Given I make a request (and it fails)');
       // stdout.should.not.include('Then my test execution gets stuck');
-      stdout.should.include('1 failed');
-      stdout.should.include('[Wrapped Error]');
-      assert(err);
-      done();
-    });
-  });
+      stdout.should.include('1 failed')
+      stdout.should.include('[Wrapped Error]')
+      assert(err)
+      done()
+    })
+  })
 
   it('should show all available steps', (done) => {
-    exec(`${runner} gherkin:steps --config ${codecept_dir}/codecept.bdd.js`, (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include('Gherkin');
-      stdout.should.include('/I have product with \\$(\\d+) price/');
-      stdout.should.include('step_definitions/my_steps.js:3:1');
-      stdout.should.include('step_definitions/my_steps.js:3:1');
-      stdout.should.include('I should see that total number of products is {int}');
-      stdout.should.include('I should see overall price is "{float}" $');
-      assert(!err);
-      done();
-    });
-  });
+    exec(`${runner} gherkin:steps --config ${codecept_dir}/codecept.bdd.js`, (err, stdout, stderr) => {
+      //eslint-disable-line
+      stdout.should.include('Gherkin')
+      stdout.should.include('/I have product with \\$(\\d+) price/')
+      stdout.should.include('step_definitions/my_steps.js:3:1')
+      stdout.should.include('step_definitions/my_steps.js:3:1')
+      stdout.should.include('I should see that total number of products is {int}')
+      stdout.should.include('I should see overall price is "{float}" $')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should generate snippets for missing steps', (done) => {
-    exec(`${runner} gherkin:snippets --dry-run --config ${codecept_dir}/codecept.dummy.bdd.js`, (err, stdout, stderr) => { //eslint-disable-line
-      stdout.should.include(`Given('I open a browser on a site', () => {
+    exec(
+      `${runner} gherkin:snippets --dry-run --config ${codecept_dir}/codecept.dummy.bdd.js`,
+      (err, stdout, stderr) => {
+        //eslint-disable-line
+        stdout.should.include(`Given('I open a browser on a site', () => {
   // From "support/dummy.feature" {"line":4,"column":5}
   throw new Error('Not implemented yet');
 });
@@ -314,44 +347,50 @@ When(/^I define a step with a \\( paren and a (\\d+\\.\\d+) float$/, () => {
 When(/^I define a step with a \\( paren and a "(.*?)" string$/, () => {
   // From "support/dummy.feature" {"line":16,"column":5}
   throw new Error('Not implemented yet');
-});`);
-      assert(!err);
-      done();
-    });
-  });
+});`)
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should not generate duplicated steps', (done) => {
-    exec(`${runner} gherkin:snippets --dry-run --config ${codecept_dir}/codecept.duplicate.bdd.js`, (err, stdout, stderr) => { //eslint-disable-line
-      assert.equal(stdout.match(/I open a browser on a site/g).length, 1);
-      assert(!err);
-      done();
-    });
-  });
+    exec(
+      `${runner} gherkin:snippets --dry-run --config ${codecept_dir}/codecept.duplicate.bdd.js`,
+      (err, stdout, stderr) => {
+        //eslint-disable-line
+        assert.equal(stdout.match(/I open a browser on a site/g).length, 1)
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   describe('i18n', () => {
-    const codecept_dir = path.join(__dirname, '/../data/sandbox/i18n');
-    const config_run_config = config => `${codecept_run} --config ${codecept_dir}/${config}`;
+    const codecept_dir = path.join(__dirname, '/../data/sandbox/i18n')
+    const config_run_config = (config) => `${codecept_run} --config ${codecept_dir}/${config}`
 
     before(() => {
-      process.chdir(codecept_dir);
-    });
+      process.chdir(codecept_dir)
+    })
     it('should run feature files in DE', (done) => {
-      exec(config_run_config('codecept.bdd.de.js') + ' --steps --grep "@i18n"', (err, stdout, stderr) => { //eslint-disable-line
-        stdout.should.include('On Angenommen: ich habe ein produkt mit einem preis von 10$ in meinem warenkorb');
-        stdout.should.include('On Und: der rabatt für bestellungen über $20 beträgt 10 %');
-        stdout.should.include('On Wenn: ich zur kasse gehe');
-        stdout.should.include('On Dann: sollte ich den gesamtpreis von "10.0" $ sehen');
-        stdout.should.include('On Angenommen: ich habe ein produkt mit einem preis von 10$ in meinem warenkorb');
-        stdout.should.include('Ich add item 10');
-        stdout.should.include('On Und: der rabatt für bestellungen über $20 beträgt 10 %');
-        stdout.should.include('Ich have discount for price 20, 10');
-        stdout.should.include('On Wenn: ich zur kasse gehe');
-        stdout.should.include('Ich checkout');
-        stdout.should.include('On Dann: sollte ich den gesamtpreis von "10.0" $ sehen');
-        stdout.should.include('Ich see sum 10');
-        assert(!err);
-        done();
-      });
-    });
-  });
-});
+      exec(config_run_config('codecept.bdd.de.js') + ' --steps --grep "@i18n"', (err, stdout, stderr) => {
+        //eslint-disable-line
+        stdout.should.include('On Angenommen: ich habe ein produkt mit einem preis von 10$ in meinem warenkorb')
+        stdout.should.include('On Und: der rabatt für bestellungen über $20 beträgt 10 %')
+        stdout.should.include('On Wenn: ich zur kasse gehe')
+        stdout.should.include('On Dann: sollte ich den gesamtpreis von "10.0" $ sehen')
+        stdout.should.include('On Angenommen: ich habe ein produkt mit einem preis von 10$ in meinem warenkorb')
+        stdout.should.include('Ich add item 10')
+        stdout.should.include('On Und: der rabatt für bestellungen über $20 beträgt 10 %')
+        stdout.should.include('Ich have discount for price 20, 10')
+        stdout.should.include('On Wenn: ich zur kasse gehe')
+        stdout.should.include('Ich checkout')
+        stdout.should.include('On Dann: sollte ich den gesamtpreis von "10.0" $ sehen')
+        stdout.should.include('Ich see sum 10')
+        assert(!err)
+        done()
+      })
+    })
+  })
+})
diff --git a/test/runner/before_failure_test.js b/test/runner/before_failure_test.js
index 34540ba82..c0b243bb1 100644
--- a/test/runner/before_failure_test.js
+++ b/test/runner/before_failure_test.js
@@ -1,38 +1,38 @@
-const path = require('path');
-const exec = require('child_process').exec;
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.beforetest.failure.js `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.beforetest.failure.js `
 
 describe('Failure in before', function () {
-  this.timeout(40000);
+  this.timeout(40000)
   it('should skip tests that are skipped because of failure in before hook', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('✔ First test will be passed');
-      stdout.should.include('S Third test will be skipped @grep');
-      stdout.should.include('S Fourth test will be skipped');
-      stdout.should.include('1 passed, 1 failed, 2 skipped');
-      err.code.should.eql(1);
-      done();
-    });
-  });
+      stdout.should.include('✔ First test will be passed')
+      stdout.should.include('S Third test will be skipped @grep')
+      stdout.should.include('S Fourth test will be skipped')
+      stdout.should.include('1 passed, 1 failed, 2 skipped')
+      err.code.should.eql(1)
+      done()
+    })
+  })
 
   it('should skip tests correctly with grep options', (done) => {
     exec(`${codecept_run} --grep @grep`, (err, stdout) => {
-      stdout.should.include('✔ First test will be passed');
-      stdout.should.include('S Third test will be skipped @grep');
-      stdout.should.include('1 passed, 1 failed, 1 skipped');
-      err.code.should.eql(1);
-      done();
-    });
-  });
+      stdout.should.include('✔ First test will be passed')
+      stdout.should.include('S Third test will be skipped @grep')
+      stdout.should.include('1 passed, 1 failed, 1 skipped')
+      err.code.should.eql(1)
+      done()
+    })
+  })
 
   it('should trigger skipped events', (done) => {
     exec(`DEBUG=codeceptjs:* ${codecept_run} --verbose`, (err, stdout, stderr) => {
-      err.code.should.eql(1);
-      stderr.should.include('Emitted | test.skipped');
-      done();
-    });
-  });
-});
+      err.code.should.eql(1)
+      stderr.should.include('Emitted | test.skipped')
+      done()
+    })
+  })
+})
diff --git a/test/runner/bootstrap_test.js b/test/runner/bootstrap_test.js
index bf109387c..11a572038 100644
--- a/test/runner/bootstrap_test.js
+++ b/test/runner/bootstrap_test.js
@@ -1,85 +1,87 @@
-const assert = require('assert');
-const path = require('path');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/bootstrap');
-const codecept_run = `${runner} run`;
-const codecept_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep ${grep}` : ''}`;
-const config_run_override = (config, override) => `${codecept_run} --config ${codecept_dir}/${config} --override '${JSON.stringify(override)}'`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/bootstrap')
+const codecept_run = `${runner} run`
+const codecept_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep ${grep}` : ''}`
+const config_run_override = (config, override) =>
+  `${codecept_run} --config ${codecept_dir}/${config} --override '${JSON.stringify(override)}'`
 
 describe('CodeceptJS Bootstrap and Teardown', () => {
   // success
   it('should run bootstrap', (done) => {
     exec(codecept_run_config('bootstrap.conf.js', '@important'), (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('I am bootstrap');
-      stdout.should.include('I am teardown');
-      const lines = stdout.split('\n');
-      const bootstrapIndex = lines.findIndex(l => l === 'I am bootstrap');
-      const testIndex = lines.findIndex(l => l.indexOf('Filesystem @main') === 0);
-      const teardownIndex = lines.findIndex(l => l === 'I am teardown');
-      assert(testIndex > bootstrapIndex, `${testIndex} (test) > ${bootstrapIndex} (bootstrap)`);
-      assert(teardownIndex > testIndex, `${teardownIndex} (teardown) > ${testIndex} (test)`);
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('I am bootstrap')
+      stdout.should.include('I am teardown')
+      const lines = stdout.split('\n')
+      const bootstrapIndex = lines.findIndex((l) => l === 'I am bootstrap')
+      const testIndex = lines.findIndex((l) => l.indexOf('Filesystem @main') === 0)
+      const teardownIndex = lines.findIndex((l) => l === 'I am teardown')
+      assert(testIndex > bootstrapIndex, `${testIndex} (test) > ${bootstrapIndex} (bootstrap)`)
+      assert(teardownIndex > testIndex, `${teardownIndex} (teardown) > ${testIndex} (test)`)
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run async bootstrap', (done) => {
     exec(codecept_run_config('bootstrap.async.conf.js', '@important'), (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('I am bootstrap');
-      stdout.should.include('I am teardown');
-      const lines = stdout.split('\n');
-      const bootstrap0Index = lines.indexOf('I am 0 bootstrap');
-      const teardown0Index = lines.indexOf('I am 0 teardown');
-      const bootstrapIndex = lines.findIndex(l => l === 'I am bootstrap');
-      const testIndex = lines.findIndex(l => l.indexOf('Filesystem @main') === 0);
-      const teardownIndex = lines.findIndex(l => l === 'I am teardown');
-      assert(bootstrap0Index < bootstrapIndex, `${bootstrap0Index} < ${bootstrapIndex} (bootstrap)`);
-      assert(teardown0Index < teardownIndex, `${teardown0Index} < ${teardownIndex} (teardown)`);
-      assert(testIndex > bootstrapIndex, `${testIndex} (test) > ${bootstrapIndex} (bootstrap)`);
-      assert(teardownIndex > testIndex, `${teardownIndex} (teardown) > ${testIndex} (test)`);
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('I am bootstrap')
+      stdout.should.include('I am teardown')
+      const lines = stdout.split('\n')
+      const bootstrap0Index = lines.indexOf('I am 0 bootstrap')
+      const teardown0Index = lines.indexOf('I am 0 teardown')
+      const bootstrapIndex = lines.findIndex((l) => l === 'I am bootstrap')
+      const testIndex = lines.findIndex((l) => l.indexOf('Filesystem @main') === 0)
+      const teardownIndex = lines.findIndex((l) => l === 'I am teardown')
+      assert(bootstrap0Index < bootstrapIndex, `${bootstrap0Index} < ${bootstrapIndex} (bootstrap)`)
+      assert(teardown0Index < teardownIndex, `${teardown0Index} < ${teardownIndex} (teardown)`)
+      assert(testIndex > bootstrapIndex, `${testIndex} (test) > ${bootstrapIndex} (bootstrap)`)
+      assert(teardownIndex > testIndex, `${teardownIndex} (teardown) > ${testIndex} (test)`)
+      assert(!err)
+      done()
+    })
+  })
 
   // with teaedown - failed tests
   it('should fail with code 1 when test failed and async bootstrap/teardown function with args', (done) => {
     exec(config_run_override('bootstrap.async.conf.js', { tests: './failed_test.js' }), (err, stdout) => {
-      assert(err);
-      assert.equal(err.code, 1);
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('I am bootstrap');
-      stdout.should.include('✖ check current dir @slow @important');
-      stdout.should.include('I am teardown');
-      done();
-    });
-  });
+      assert(err)
+      assert.equal(err.code, 1)
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('I am bootstrap')
+      stdout.should.include('✖ check current dir @slow @important')
+      stdout.should.include('I am teardown')
+      done()
+    })
+  })
 
   it('should fail with code 1 when test failed and async bootstrap/teardown function without args', (done) => {
     exec(config_run_override('bootstrap.async.conf.js', { tests: './failed_test.js' }), (err, stdout) => {
-      assert(err);
-      assert.equal(err.code, 1);
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('I am bootstrap');
-      stdout.should.include('✖ check current dir @slow @important');
-      stdout.should.include('I am teardown');
-      done();
-    });
-  });
+      assert(err)
+      assert.equal(err.code, 1)
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('I am bootstrap')
+      stdout.should.include('✖ check current dir @slow @important')
+      stdout.should.include('I am teardown')
+      done()
+    })
+  })
 
   // with teardown and fail bootstrap - teardown not call
   it('should fail with code 1 when async bootstrap failed and not call teardown', (done) => {
     exec(codecept_run_config('without.args.failed.bootstrap.async.func.js'), (err, stdout) => {
-      assert(err);
-      assert.equal(err.code, 1);
-      stdout.should.include('Error from async bootstrap');
-      stdout.should.not.include('✔ check current dir @slow @important in 2ms');
-      stdout.should.not.include('I am teardown');
-      done();
-    });
-  });
-});
+      assert(err)
+      assert.equal(err.code, 1)
+      stdout.should.include('Error from async bootstrap')
+      stdout.should.not.include('✔ check current dir @slow @important in 2ms')
+      stdout.should.not.include('I am teardown')
+      done()
+    })
+  })
+})
diff --git a/test/runner/codecept_test.js b/test/runner/codecept_test.js
index d6147a964..c4a17e865 100644
--- a/test/runner/codecept_test.js
+++ b/test/runner/codecept_test.js
@@ -1,322 +1,323 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const assert = require('assert');
-const path = require('path');
-const exec = require('child_process').exec;
-const event = require('../../lib').event;
-
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run`;
-const codecept_run_config = config => `${codecept_run} --config ${codecept_dir}/${config}`;
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const assert = require('assert')
+const path = require('path')
+const exec = require('child_process').exec
+const event = require('../../lib').event
+
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run`
+const codecept_run_config = (config) => `${codecept_run} --config ${codecept_dir}/${config}`
 
 describe('CodeceptJS Runner', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should be executed in current dir', (done) => {
-    process.chdir(codecept_dir);
+    process.chdir(codecept_dir)
     exec(codecept_run, (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('check current dir'); // test name
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('check current dir') // test name
+      assert(!err)
+      done()
+    })
+  })
 
   it('should be executed with glob', (done) => {
-    process.chdir(codecept_dir);
+    process.chdir(codecept_dir)
     exec(codecept_run_config('codecept.glob.js'), (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('glob current dir'); // test name
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('glob current dir') // test name
+      assert(!err)
+      done()
+    })
+  })
 
   it('should be executed with config path', (done) => {
-    process.chdir(__dirname);
+    process.chdir(__dirname)
     exec(`${codecept_run} -c ${codecept_dir}`, (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      stdout.should.include('check current dir'); // test name
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      stdout.should.include('check current dir') // test name
+      assert(!err)
+      done()
+    })
+  })
 
   it('should show failures and exit with 1 on fail', (done) => {
     exec(codecept_run_config('codecept.failed.js'), (err, stdout) => {
-      stdout.should.include('Not-A-Filesystem');
-      stdout.should.include('file is not in dir');
-      stdout.should.include('FAILURES');
-      err.code.should.eql(1);
-      done();
-    });
+      stdout.should.include('Not-A-Filesystem')
+      stdout.should.include('file is not in dir')
+      stdout.should.include('FAILURES')
+      err.code.should.eql(1)
+      done()
+    })
 
     it('should except a directory glob pattern', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${codecept_run} "test-dir/*"`, (err, stdout) => {
-        stdout.should.include('2 passed'); // number of tests present in directory
-        done();
-      });
-    });
-  });
+        stdout.should.include('2 passed') // number of tests present in directory
+        done()
+      })
+    })
+  })
 
   describe('grep', () => {
     it('filter by scenario tags', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${codecept_run} --grep @slow`, (err, stdout) => {
-        stdout.should.include('Filesystem'); // feature
-        stdout.should.include('check current dir'); // test name
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include('Filesystem') // feature
+        stdout.should.include('check current dir') // test name
+        assert(!err)
+        done()
+      })
+    })
 
     it('filter by scenario tags #2', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${codecept_run} --grep @important`, (err, stdout) => {
-        stdout.should.include('Filesystem'); // feature
-        stdout.should.include('check current dir'); // test name
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include('Filesystem') // feature
+        stdout.should.include('check current dir') // test name
+        assert(!err)
+        done()
+      })
+    })
 
     it('filter by feature tags', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${codecept_run} --grep @main`, (err, stdout) => {
-        stdout.should.include('Filesystem'); // feature
-        stdout.should.include('check current dir'); // test name
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include('Filesystem') // feature
+        stdout.should.include('check current dir') // test name
+        assert(!err)
+        done()
+      })
+    })
 
     describe('without "invert" option', () => {
       it('should filter by scenario tags', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @1_grep`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.include('grep message 1');
-          stdout.should.not.include('grep message 2');
-          assert(!err);
-          done();
-        });
-      });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.include('grep message 1')
+          stdout.should.not.include('grep message 2')
+          assert(!err)
+          done()
+        })
+      })
 
       it('should filter by scenario tags #2', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @2_grep`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.include('grep message 2');
-          stdout.should.not.include('grep message 1');
-          assert(!err);
-          done();
-        });
-      });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.include('grep message 2')
+          stdout.should.not.include('grep message 1')
+          assert(!err)
+          done()
+        })
+      })
 
       it('should filter by feature tags', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @feature_grep`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.include('grep message 1');
-          stdout.should.include('grep message 2');
-          assert(!err);
-          done();
-        });
-      });
-    });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.include('grep message 1')
+          stdout.should.include('grep message 2')
+          assert(!err)
+          done()
+        })
+      })
+    })
 
     describe('with "invert" option', () => {
       it('should filter by scenario tags', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @1_grep --invert`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.not.include('grep message 1');
-          stdout.should.include('grep message 2');
-          assert(!err);
-          done();
-        });
-      });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.not.include('grep message 1')
+          stdout.should.include('grep message 2')
+          assert(!err)
+          done()
+        })
+      })
 
       it('should filter by scenario tags #2', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @2_grep --invert`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.not.include('grep message 2');
-          stdout.should.include('grep message 1');
-          assert(!err);
-          done();
-        });
-      });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.not.include('grep message 2')
+          stdout.should.include('grep message 1')
+          assert(!err)
+          done()
+        })
+      })
 
       it('should filter by feature tags', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @main --invert`, (err, stdout) => {
-          stdout.should.include('@feature_grep'); // feature
-          stdout.should.include('grep message 1');
-          stdout.should.include('grep message 2');
-          assert(!err);
-          done();
-        });
-      });
+          stdout.should.include('@feature_grep') // feature
+          stdout.should.include('grep message 1')
+          stdout.should.include('grep message 2')
+          assert(!err)
+          done()
+        })
+      })
 
       it('should filter by feature tags', (done) => {
-        process.chdir(codecept_dir);
+        process.chdir(codecept_dir)
         exec(`${codecept_run_config('codecept.grep.2.js')} --grep @feature_grep --invert`, (err, stdout) => {
-          stdout.should.not.include('@feature_grep'); // feature
-          stdout.should.not.include('grep message 1');
-          stdout.should.not.include('grep message 2');
-          assert(!err);
-          done();
-        });
-      });
-    });
-  });
+          stdout.should.not.include('@feature_grep') // feature
+          stdout.should.not.include('grep message 1')
+          stdout.should.not.include('grep message 2')
+          assert(!err)
+          done()
+        })
+      })
+    })
+  })
 
   it('should run hooks from suites', (done) => {
     exec(codecept_run_config('codecept.testhooks.json'), (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const uniqueLines = lines.filter((v, i, a) => a.indexOf(v) === i);
+      const uniqueLines = lines.filter((v, i, a) => a.indexOf(v) === i)
 
-      expect(uniqueLines.length).to.eql(lines.length, `No duplicates in output +${lines} \n\n -${uniqueLines}`);
+      expect(uniqueLines.length).to.eql(lines.length, `No duplicates in output +${lines} \n\n -${uniqueLines}`)
 
       expect(lines).to.include.members([
-        'Helper: I\'m initialized',
-        'Helper: I\'m simple BeforeSuite hook',
-        'Test: I\'m simple BeforeSuite hook',
-        'Test: I\'m generator BeforeSuite hook',
-        'Test: I\'m async/await BeforeSuite hook',
-        'Helper: I\'m simple Before hook',
-        'Test: I\'m simple Before hook',
-        'Test: I\'m generator Before hook',
-        'Test: I\'m async/await Before hook',
-        'Test: I\'m generator After hook',
-        'Test: I\'m simple After hook',
-        'Test: I\'m async/await After hook',
-        'Helper: I\'m simple After hook',
-        'Test: I\'m generator AfterSuite hook',
-        'Test: I\'m simple AfterSuite hook',
-        'Test: I\'m async/await AfterSuite hook',
-        'Helper: I\'m simple AfterSuite hook',
-      ]);
-
-      stdout.should.include('OK  | 1 passed');
-      assert(!err);
-      done();
-    });
-  });
+        "Helper: I'm initialized",
+        "Helper: I'm simple BeforeSuite hook",
+        "Test: I'm simple BeforeSuite hook",
+        "Test: I'm generator BeforeSuite hook",
+        "Test: I'm async/await BeforeSuite hook",
+        "Helper: I'm simple Before hook",
+        "Test: I'm simple Before hook",
+        "Test: I'm generator Before hook",
+        "Test: I'm async/await Before hook",
+        "Test: I'm generator After hook",
+        "Test: I'm simple After hook",
+        "Test: I'm async/await After hook",
+        "Helper: I'm simple After hook",
+        "Test: I'm generator AfterSuite hook",
+        "Test: I'm simple AfterSuite hook",
+        "Test: I'm async/await AfterSuite hook",
+        "Helper: I'm simple AfterSuite hook",
+      ])
+
+      stdout.should.include('OK  | 1 passed')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run hooks from suites (in different order)', (done) => {
     exec(codecept_run_config('codecept.testhooks.different.order.json'), (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
       expect(lines).to.include.members([
-        'Helper: I\'m simple BeforeSuite hook',
-        'Test: I\'m async/await BeforeSuite hook',
-        'Helper: I\'m simple Before hook',
-        'Test: I\'m async/await Before hook',
-        'Test: I\'m async/await After hook',
-        'Helper: I\'m simple After hook',
-        'Test: I\'m async/await AfterSuite hook',
-        'Helper: I\'m simple AfterSuite hook',
-      ]);
-      stdout.should.include('OK  | 1 passed');
-      assert(!err);
-      done();
-    });
-  });
+        "Helper: I'm simple BeforeSuite hook",
+        "Test: I'm async/await BeforeSuite hook",
+        "Helper: I'm simple Before hook",
+        "Test: I'm async/await Before hook",
+        "Test: I'm async/await After hook",
+        "Helper: I'm simple After hook",
+        "Test: I'm async/await AfterSuite hook",
+        "Helper: I'm simple AfterSuite hook",
+      ])
+      stdout.should.include('OK  | 1 passed')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run different types of scenario', (done) => {
     exec(codecept_run_config('codecept.testscenario.json'), (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
       expect(lines).to.include.members([
         'Test scenario types --',
-        'It\'s usual test',
-        'Test: I\'m async/await test',
-        'Test: I\'m asyncbrackets test',
-      ]);
-      stdout.should.include('OK  | 3 passed');
-      assert(!err);
-      done();
-    });
-  });
+        "It's usual test",
+        "Test: I'm async/await test",
+        "Test: I'm asyncbrackets test",
+      ])
+      stdout.should.include('OK  | 3 passed')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run dynamic config', (done) => {
     exec(codecept_run_config('config.js'), (err, stdout) => {
-      stdout.should.include('Filesystem'); // feature
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Filesystem') // feature
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run dynamic config with profile', (done) => {
     exec(`${codecept_run_config('config.js')} --profile failed`, (err, stdout) => {
-      stdout.should.include('FAILURES');
-      stdout.should.not.include('I am bootstrap');
-      assert(err.code);
-      done();
-    });
-  });
+      stdout.should.include('FAILURES')
+      stdout.should.not.include('I am bootstrap')
+      assert(err.code)
+      done()
+    })
+  })
 
   it('should exit code 1 when error in config', (done) => {
     exec(`${codecept_run_config('configs/codecept-invalid.config.js')} --profile failed`, (err, stdout, stderr) => {
-      stdout.should.not.include('UnhandledPromiseRejectionWarning');
-      stderr.should.not.include('UnhandledPromiseRejectionWarning');
-      stdout.should.include('badFn is not defined');
-      assert(err.code);
-      done();
-    });
-  });
+      stdout.should.not.include('UnhandledPromiseRejectionWarning')
+      stderr.should.not.include('UnhandledPromiseRejectionWarning')
+      stdout.should.include('badFn is not defined')
+      assert(err.code)
+      done()
+    })
+  })
 
   describe('with require parameter', () => {
-    const moduleOutput = 'Module was required 1';
-    const moduleOutput2 = 'Module was required 2';
+    const moduleOutput = 'Module was required 1'
+    const moduleOutput2 = 'Module was required 2'
 
     it('should be executed with module when described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(codecept_run_config('codecept.require.single.json'), (err, stdout) => {
-        stdout.should.include(moduleOutput);
-        stdout.should.not.include(moduleOutput2);
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include(moduleOutput)
+        stdout.should.not.include(moduleOutput2)
+        assert(!err)
+        done()
+      })
+    })
 
     it('should be executed with several modules when described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(codecept_run_config('codecept.require.several.json'), (err, stdout) => {
-        stdout.should.include(moduleOutput);
-        stdout.should.include(moduleOutput2);
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include(moduleOutput)
+        stdout.should.include(moduleOutput2)
+        assert(!err)
+        done()
+      })
+    })
 
     it('should not be executed without module when not described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(codecept_run_config('codecept.require.without.json'), (err, stdout) => {
-        stdout.should.not.include(moduleOutput);
-        stdout.should.not.include(moduleOutput2);
-        assert(!err);
-        done();
-      });
-    });
-  });
-});
+        stdout.should.not.include(moduleOutput)
+        stdout.should.not.include(moduleOutput2)
+        assert(!err)
+        done()
+      })
+    })
+  })
+})
 
 describe('Codeceptjs Events', () => {
   it('should fire events with only passing tests', (done) => {
     exec(`${codecept_run_config('codecept.testevents.js')} --grep @willpass`, (err, stdout) => {
-      assert(!err);
-      const eventMessages = stdout.split('\n')
-        .filter(text => text.startsWith('Event:'))
-        .map(text => text.replace(/^Event:/i, ''));
+      assert(!err)
+      const eventMessages = stdout
+        .split('\n')
+        .filter((text) => text.startsWith('Event:'))
+        .map((text) => text.replace(/^Event:/i, ''))
 
       expect(eventMessages).to.deep.equal([
         event.all.before,
@@ -329,17 +330,18 @@ describe('Codeceptjs Events', () => {
         event.suite.after,
         event.all.result,
         event.all.after,
-      ]);
-      done();
-    });
-  });
+      ])
+      done()
+    })
+  })
 
   it('should fire events with passing and failing tests', (done) => {
     exec(codecept_run_config('codecept.testevents.js'), (err, stdout) => {
-      assert(err);
-      const eventMessages = stdout.split('\n')
-        .filter(text => text.startsWith('Event:'))
-        .map(text => text.replace(/^Event:/i, ''));
+      assert(err)
+      const eventMessages = stdout
+        .split('\n')
+        .filter((text) => text.startsWith('Event:'))
+        .map((text) => text.replace(/^Event:/i, ''))
 
       expect(eventMessages).to.deep.equal([
         event.all.before,
@@ -362,8 +364,8 @@ describe('Codeceptjs Events', () => {
         event.suite.after,
         event.all.result,
         event.all.after,
-      ]);
-      done();
-    });
-  });
-});
+      ])
+      done()
+    })
+  })
+})
diff --git a/test/runner/comment_step_test.js b/test/runner/comment_step_test.js
index 3dcd72086..4d1bf77dc 100644
--- a/test/runner/comment_step_test.js
+++ b/test/runner/comment_step_test.js
@@ -1,27 +1,23 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const { expect } = require('expect');
+const path = require('path')
+const exec = require('child_process').exec
+const { expect } = require('expect')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(
-  __dirname,
-  '/../data/sandbox/configs/commentStep',
-);
-const codecept_run = `${runner} run`;
-const config_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} ${
-  grep ? `--grep "${grep}"` : ''
-}`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/commentStep')
+const codecept_run = `${runner} run`
+const config_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS commentStep plugin', function () {
-  this.timeout(3000);
+  this.timeout(3000)
 
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
-  it('should print nested steps when global var comments used', done => {
+  it('should print nested steps when global var comments used', (done) => {
     exec(`${config_run_config('codecept.conf.js', 'global var')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
+      const lines = stdout.split('\n')
       expect(lines).toEqual(
         expect.arrayContaining([
           expect.stringContaining('Prepare user base:'),
@@ -31,15 +27,15 @@ describe('CodeceptJS commentStep plugin', function () {
           expect.stringContaining('Check the result:'),
           expect.stringContaining('I print "see everything works"'),
         ]),
-      );
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      )
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
-  it('should print nested steps when local var comments used', done => {
+  it('should print nested steps when local var comments used', (done) => {
     exec(`${config_run_config('codecept.conf.js', 'local var')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
+      const lines = stdout.split('\n')
       expect(lines).toEqual(
         expect.arrayContaining([
           expect.stringContaining('Prepare project:'),
@@ -49,9 +45,9 @@ describe('CodeceptJS commentStep plugin', function () {
           expect.stringContaining('Check project:'),
           expect.stringContaining('I print "see everything works"'),
         ]),
-      );
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
-});
+      )
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/consts.js b/test/runner/consts.js
index 518238793..29c11a6dd 100644
--- a/test/runner/consts.js
+++ b/test/runner/consts.js
@@ -1,11 +1,11 @@
-const path = require('path');
+const path = require('path')
 
-const runner = path.join(process.cwd(), 'bin/codecept.js');
-const codecept_dir = path.join(process.cwd(), 'test/data/sandbox');
-const codecept_run = `${runner} run`;
+const runner = path.join(process.cwd(), 'bin/codecept.js')
+const codecept_dir = path.join(process.cwd(), 'test/data/sandbox')
+const codecept_run = `${runner} run`
 
 module.exports = {
   codecept_run,
   codecept_dir,
   runner,
-};
+}
diff --git a/test/runner/definitions_test.js b/test/runner/definitions_test.js
index fbfd46d5e..a2db39ab2 100644
--- a/test/runner/definitions_test.js
+++ b/test/runner/definitions_test.js
@@ -1,173 +1,189 @@
-const fs = require('fs');
-const assert = require('assert');
-const path = require('path');
-const { exec, execSync } = require('child_process');
-
-const { Project, StructureKind, ts } = require('ts-morph');
-
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/definitions');
-const pathToRootOfProject = path.join(__dirname, '../../');
-const pathOfStaticDefinitions = path.join(pathToRootOfProject, 'typings/index.d.ts');
-const pathOfJSDocDefinitions = path.join(pathToRootOfProject, 'typings/types.d.ts');
-const pathToTests = path.resolve(pathToRootOfProject, 'test');
-const pathToTypings = path.resolve(pathToRootOfProject, 'typings');
-
-import('chai').then(chai => {
-  chai.use(require('chai-subset'));
+const fs = require('fs')
+const assert = require('assert')
+const path = require('path')
+const { exec, execSync } = require('child_process')
+
+const { Project, StructureKind, ts } = require('ts-morph')
+
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/definitions')
+const pathToRootOfProject = path.join(__dirname, '../../')
+const pathOfStaticDefinitions = path.join(pathToRootOfProject, 'typings/index.d.ts')
+const pathOfJSDocDefinitions = path.join(pathToRootOfProject, 'typings/types.d.ts')
+const pathToTests = path.resolve(pathToRootOfProject, 'test')
+const pathToTypings = path.resolve(pathToRootOfProject, 'typings')
+
+import('chai').then((chai) => {
+  chai.use(require('chai-subset'))
   /** @type {Chai.ChaiPlugin */
   chai.use((chai, utils) => {
     utils.addProperty(chai.Assertion.prototype, 'valid', function () {
       /** @type {import('ts-morph').Project} */
-      const project = utils.flag(this, 'object');
-      new chai.Assertion(project).to.be.instanceof(Project);
+      const project = utils.flag(this, 'object')
+      new chai.Assertion(project).to.be.instanceof(Project)
 
-      let diagnostics = project.getPreEmitDiagnostics();
+      let diagnostics = project.getPreEmitDiagnostics()
       diagnostics = diagnostics.filter((diagnostic) => {
-        const filePath = diagnostic.getSourceFile().getFilePath();
-        return filePath.startsWith(pathToTests) || filePath.startsWith(pathToTypings);
-      });
-      if (diagnostics.length > 0) throw new Error(project.formatDiagnosticsWithColorAndContext(diagnostics));
-    });
-  });
-});
+        const filePath = diagnostic.getSourceFile().getFilePath()
+        return filePath.startsWith(pathToTests) || filePath.startsWith(pathToTypings)
+      })
+      if (diagnostics.length > 0) throw new Error(project.formatDiagnosticsWithColorAndContext(diagnostics))
+    })
+  })
+})
 
 describe('Definitions', function () {
-  this.timeout(30000);
-  this.retries(4);
+  this.timeout(30000)
+  this.retries(4)
 
   before(() => {
-    execSync('npm run def', { cwd: pathToRootOfProject });
-  });
+    execSync('npm run def', { cwd: pathToRootOfProject })
+  })
   afterEach(() => {
     try {
-      fs.unlinkSync(`${codecept_dir}/steps.d.ts`);
-      fs.unlinkSync(`${codecept_dir}/../../steps.d.ts`);
+      fs.unlinkSync(`${codecept_dir}/steps.d.ts`)
+      fs.unlinkSync(`${codecept_dir}/../../steps.d.ts`)
     } catch (e) {
       // continue regardless of error
     }
-  });
+  })
 
   describe('Static files', () => {
     it('should have internal object that is available as variable codeceptjs', (done) => {
       exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, () => {
-        const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-        types.should.be.valid;
+        const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+        types.should.be.valid
 
-        const definitionsFile = types.getSourceFileOrThrow(pathOfJSDocDefinitions);
-        const index = definitionsFile.getModule('CodeceptJS').getModule('index').getStructure();
+        const definitionsFile = types.getSourceFileOrThrow(pathOfJSDocDefinitions)
+        const index = definitionsFile.getModule('CodeceptJS').getModule('index').getStructure()
         index.statements.should.containSubset([
           { declarations: [{ name: 'recorder', type: 'CodeceptJS.recorder' }] },
           { declarations: [{ name: 'event', type: 'typeof CodeceptJS.event' }] },
           { declarations: [{ name: 'output', type: 'typeof CodeceptJS.output' }] },
           { declarations: [{ name: 'config', type: 'typeof CodeceptJS.Config' }] },
           { declarations: [{ name: 'container', type: 'typeof CodeceptJS.Container' }] },
-        ]);
-        const codeceptjs = types.getSourceFileOrThrow(pathOfStaticDefinitions).getVariableDeclarationOrThrow('codeceptjs').getStructure();
-        codeceptjs.type.should.equal('typeof CodeceptJS.index');
-        done();
-      });
-    });
-  });
+        ])
+        const codeceptjs = types
+          .getSourceFileOrThrow(pathOfStaticDefinitions)
+          .getVariableDeclarationOrThrow('codeceptjs')
+          .getStructure()
+        codeceptjs.type.should.equal('typeof CodeceptJS.index')
+        done()
+      })
+    })
+  })
 
   it('def should create definition file', (done) => {
     exec(`${runner} def ${codecept_dir}`, (err, stdout) => {
-      stdout.should.include('Definitions were generated in steps.d.ts');
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
-
-      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`);
-      const extend = getExtends(definitionFile.getModule('CodeceptJS').getInterfaceOrThrow('I'));
-      extend.should.containSubset([{
-        methods: [{
-          name: 'amInPath',
-          returnType: 'void',
-          parameters: [{ name: 'openPath', type: 'string' }],
-        }, {
-          name: 'seeFile',
-          returnType: 'void',
-          parameters: [{ name: 'name', type: 'string' }],
-        }],
-      }]);
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Definitions were generated in steps.d.ts')
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
+
+      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`)
+      const extend = getExtends(definitionFile.getModule('CodeceptJS').getInterfaceOrThrow('I'))
+      extend.should.containSubset([
+        {
+          methods: [
+            {
+              name: 'amInPath',
+              returnType: 'void',
+              parameters: [{ name: 'openPath', type: 'string' }],
+            },
+            {
+              name: 'seeFile',
+              returnType: 'void',
+              parameters: [{ name: 'name', type: 'string' }],
+            },
+          ],
+        },
+      ])
+      assert(!err)
+      done()
+    })
+  })
 
   it('def should create definition file with correct page def', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, (err, stdout) => {
-      stdout.should.include('Definitions were generated in steps.d.ts');
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
+      stdout.should.include('Definitions were generated in steps.d.ts')
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
 
-      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`);
-      const extend = definitionFile.getFullText();
+      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`)
+      const extend = definitionFile.getFullText()
 
-      extend.should.include("type CurrentPage = typeof import('./po/custom_steps.js');");
-      assert(!err);
-      done();
-    });
-  });
+      extend.should.include("type CurrentPage = typeof import('./po/custom_steps.js');")
+      assert(!err)
+      done()
+    })
+  })
 
   it('def should create definition file given a config file', (done) => {
     exec(`${runner} def --config ${codecept_dir}/../../codecept.ddt.js`, (err, stdout) => {
-      stdout.should.include('Definitions were generated in steps.d.ts');
-      const types = typesFrom(`${codecept_dir}/../../steps.d.ts`);
-      types.should.be.valid;
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Definitions were generated in steps.d.ts')
+      const types = typesFrom(`${codecept_dir}/../../steps.d.ts`)
+      types.should.be.valid
+      assert(!err)
+      done()
+    })
+  })
 
   it('def should create definition file with support object', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, () => {
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
-
-      const definitionsFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`);
-      const MyPage = getAliasStructure(definitionsFile.getTypeAliasOrThrow('MyPage'));
-      MyPage.properties.should.containSubset([{
-        name: 'hasFile',
-        returnType: undefined,
-        kind: StructureKind.Method,
-      }]);
-      const I = getExtends(definitionsFile.getModule('CodeceptJS').getInterfaceOrThrow('I'));
-      I.should.containSubset([{
-        methods: [{
-          name: 'openDir',
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
+
+      const definitionsFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`)
+      const MyPage = getAliasStructure(definitionsFile.getTypeAliasOrThrow('MyPage'))
+      MyPage.properties.should.containSubset([
+        {
+          name: 'hasFile',
           returnType: undefined,
           kind: StructureKind.Method,
-        }],
-      }]);
-      done();
-    });
-  });
+        },
+      ])
+      const I = getExtends(definitionsFile.getModule('CodeceptJS').getInterfaceOrThrow('I'))
+      I.should.containSubset([
+        {
+          methods: [
+            {
+              name: 'openDir',
+              returnType: undefined,
+              kind: StructureKind.Method,
+            },
+          ],
+        },
+      ])
+      done()
+    })
+  })
 
   it('def should create definition file with inject which contains support objects', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, () => {
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
-
-      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions);
-      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'));
-      returned.should.containSubset([{
-        properties: [
-          { name: 'SecondPage', type: 'SecondPage' },
-          { name: 'MyPage', type: 'MyPage' },
-        ],
-      }]);
-      done();
-    });
-  });
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
+
+      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions)
+      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'))
+      returned.should.containSubset([
+        {
+          properties: [
+            { name: 'SecondPage', type: 'SecondPage' },
+            { name: 'MyPage', type: 'MyPage' },
+          ],
+        },
+      ])
+      done()
+    })
+  })
 
   it('def should create definition file with inject which contains I object', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, (err) => {
-      assert(!err);
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
+      assert(!err)
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
 
-      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions);
-      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'));
+      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions)
+      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'))
       returned.should.containSubset([
         {
           properties: [
@@ -175,65 +191,72 @@ describe('Definitions', function () {
             { name: 'MyPage', type: 'MyPage' },
           ],
         },
-      ]);
-      done();
-    });
-  });
+      ])
+      done()
+    })
+  })
 
   it('def should create definition file with inject which contains I object from helpers', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.powi.js`, () => {
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
-
-      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions);
-      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'));
-      returned.should.containSubset([{
-        properties: [{ name: 'I', type: 'I' }],
-      }]);
-      done();
-    });
-  });
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
+
+      const definitionsFile = types.getSourceFileOrThrow(pathOfStaticDefinitions)
+      const returned = getReturnStructure(definitionsFile.getFunctionOrThrow('inject'))
+      returned.should.containSubset([
+        {
+          properties: [{ name: 'I', type: 'I' }],
+        },
+      ])
+      done()
+    })
+  })
 
   it('def should create definition file with callback params', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.inject.po.js`, () => {
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
 
-      const definitionsFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`);
-      const CallbackOrder = definitionsFile.getModule('CodeceptJS').getInterfaceOrThrow('SupportObject').getStructure();
+      const definitionsFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`)
+      const CallbackOrder = definitionsFile.getModule('CodeceptJS').getInterfaceOrThrow('SupportObject').getStructure()
       CallbackOrder.properties.should.containSubset([
         { name: 'I', type: 'I' },
         { name: 'MyPage', type: 'MyPage' },
         { name: 'SecondPage', type: 'SecondPage' },
-      ]);
-      done();
-    });
-  });
+      ])
+      done()
+    })
+  })
 
   it('def should create definition file with promise-based feature', (done) => {
     exec(`${runner} def --config ${codecept_dir}/codecept.promise.based.js`, (err, stdout) => {
-      stdout.should.include('Definitions were generated in steps.d.ts');
-      const types = typesFrom(`${codecept_dir}/steps.d.ts`);
-      types.should.be.valid;
-
-      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`);
-      const extend = getExtends(definitionFile.getModule('CodeceptJS').getInterfaceOrThrow('I'));
-      extend.should.containSubset([{
-        methods: [{
-          name: 'amInPath',
-          returnType: 'Promise<any>',
-          parameters: [{ name: 'openPath', type: 'string' }],
-        }, {
-          name: 'seeFile',
-          returnType: 'Promise<any>',
-          parameters: [{ name: 'name', type: 'string' }],
-        }],
-      }]);
-      assert(!err);
-      done();
-    });
-  });
-});
+      stdout.should.include('Definitions were generated in steps.d.ts')
+      const types = typesFrom(`${codecept_dir}/steps.d.ts`)
+      types.should.be.valid
+
+      const definitionFile = types.getSourceFileOrThrow(`${codecept_dir}/steps.d.ts`)
+      const extend = getExtends(definitionFile.getModule('CodeceptJS').getInterfaceOrThrow('I'))
+      extend.should.containSubset([
+        {
+          methods: [
+            {
+              name: 'amInPath',
+              returnType: 'Promise<any>',
+              parameters: [{ name: 'openPath', type: 'string' }],
+            },
+            {
+              name: 'seeFile',
+              returnType: 'Promise<any>',
+              parameters: [{ name: 'name', type: 'string' }],
+            },
+          ],
+        },
+      ])
+      assert(!err)
+      done()
+    })
+  })
+})
 
 /**
  * Resolves 'codeceptjs' type directive to the internal file,
@@ -241,12 +264,12 @@ describe('Definitions', function () {
  * @type {import('ts-morph').ResolutionHostFactory}
  */
 function resolutionHost(moduleResolutionHost, getCompilerOptions) {
-  const packageJson = require('../../package.json');
+  const packageJson = require('../../package.json')
   return {
     resolveTypeReferenceDirectives: (typeDirectiveNames, containingFile) => {
-      const compilerOptions = getCompilerOptions();
-      const resolvedTypeReferenceDirectives = [];
-      let result;
+      const compilerOptions = getCompilerOptions()
+      const resolvedTypeReferenceDirectives = []
+      let result
 
       for (const typeDirectiveName of typeDirectiveNames) {
         if (typeDirectiveName === 'codeceptjs') {
@@ -262,16 +285,23 @@ function resolutionHost(moduleResolutionHost, getCompilerOptions) {
               isExternalLibraryImport: true,
             },
             failedLookupLocations: [],
-          };
+          }
         } else {
-          result = ts.resolveTypeReferenceDirective(typeDirectiveName, containingFile, compilerOptions, moduleResolutionHost);
+          result = ts.resolveTypeReferenceDirective(
+            typeDirectiveName,
+            containingFile,
+            compilerOptions,
+            moduleResolutionHost,
+          )
+        }
+        if (result.resolvedTypeReferenceDirective) {
+          resolvedTypeReferenceDirectives.push(result.resolvedTypeReferenceDirective)
         }
-        if (result.resolvedTypeReferenceDirective) { resolvedTypeReferenceDirectives.push(result.resolvedTypeReferenceDirective); }
       }
 
-      return resolvedTypeReferenceDirectives;
+      return resolvedTypeReferenceDirectives
     },
-  };
+  }
 }
 
 /**
@@ -281,58 +311,63 @@ function typesFrom(sourceFile) {
   const project = new Project({
     tsConfigFilePath: path.join(pathToRootOfProject, 'tsconfig.json'),
     resolutionHost,
-  });
-  project.addSourceFileAtPath(sourceFile);
-  project.resolveSourceFileDependencies();
-  return project;
+  })
+  project.addSourceFileAtPath(sourceFile)
+  project.resolveSourceFileDependencies()
+  return project
 }
 
 /**
  * @param {import('ts-morph').Node} node
-*/
+ */
 function getExtends(node) {
   return node.getExtends().map(() => {
-    const result = {};
+    const result = {}
     /** @type {import('ts-morph').Type} */
-    result.properties = result.properties || [];
-    result.methods = result.methods || [];
-    node.getExtends().map(symbol => symbol.getType().getProperties().forEach((symbol) => {
-      symbol.getDeclarations().forEach((declaration) => {
-        const structure = declaration.getStructure();
-        if (structure.kind === StructureKind.Method || structure.kind === StructureKind.MethodSignature) {
-          result.methods.push(structure);
-        } else {
-          result.properties.push(structure);
-        }
-      });
-    }));
-    return result;
-  });
+    result.properties = result.properties || []
+    result.methods = result.methods || []
+    node.getExtends().map((symbol) =>
+      symbol
+        .getType()
+        .getProperties()
+        .forEach((symbol) => {
+          symbol.getDeclarations().forEach((declaration) => {
+            const structure = declaration.getStructure()
+            if (structure.kind === StructureKind.Method || structure.kind === StructureKind.MethodSignature) {
+              result.methods.push(structure)
+            } else {
+              result.properties.push(structure)
+            }
+          })
+        }),
+    )
+    return result
+  })
 }
 
 /**
  * @param {import('ts-morph').Node} node
  * @returns {import('ts-morph').Structure[]}
-*/
+ */
 function getReturnStructure(node) {
   /** @type {import('ts-morph').Type} */
-  const returnType = node.getSignature().getReturnType();
-  const nodes = returnType.getSymbol().getDeclarations();
-  return nodes.map(node => node.getStructure());
+  const returnType = node.getSignature().getReturnType()
+  const nodes = returnType.getSymbol().getDeclarations()
+  return nodes.map((node) => node.getStructure())
 }
 
 /**
  * @param {import('ts-morph').Node} node
  * @returns {import('ts-morph').TypeAliasDeclarationStructure}
-*/
+ */
 function getAliasStructure(node) {
-  const result = node.getStructure();
-  const type = node.getType();
+  const result = node.getStructure()
+  const type = node.getType()
   const properties = type.getProperties().reduce((arr, symbol) => {
-    const node = symbol.getValueDeclaration();
-    if (node) arr.push(node.getStructure());
-    return arr;
-  }, []);
-  if (properties.length) result.properties = properties;
-  return result;
+    const node = symbol.getValueDeclaration()
+    if (node) arr.push(node.getStructure())
+    return arr
+  }, [])
+  if (properties.length) result.properties = properties
+  return result
 }
diff --git a/test/runner/dry_run_test.js b/test/runner/dry_run_test.js
index 1881f7706..444de2fde 100644
--- a/test/runner/dry_run_test.js
+++ b/test/runner/dry_run_test.js
@@ -1,83 +1,84 @@
-const path = require('path');
-const { expect } = require('expect');
-const exec = require('child_process').exec;
+const path = require('path')
+const { expect } = require('expect')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} dry-run`;
-const codecept_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`;
-const char = require('figures').checkboxOff;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} dry-run`
+const codecept_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`
+const char = require('figures').checkboxOff
 
 describe('dry-run command', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('should be executed with config path', (done) => {
-    process.chdir(__dirname);
+    process.chdir(__dirname)
     exec(`${codecept_run_config('codecept.js')}`, (err, stdout) => {
-      expect(stdout).toContain('Filesystem'); // feature
-      expect(stdout).toContain('check current dir'); // test name
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Filesystem') // feature
+      expect(stdout).toContain('check current dir') // test name
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should list all tests', (done) => {
-    process.chdir(__dirname);
+    process.chdir(__dirname)
     exec(`${codecept_run_config('codecept.js')}`, (err, stdout) => {
-      expect(stdout).toContain('Filesystem'); // feature
-      expect(stdout).toContain('check current dir'); // test name
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Filesystem') // feature
+      expect(stdout).toContain('check current dir') // test name
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should not run actual steps', (done) => {
     exec(`${codecept_run_config('codecept.flaky.js')}`, (err, stdout) => {
-      expect(stdout).toContain('Flaky'); // feature
-      expect(stdout).toContain('Not so flaky test'); // test name
-      expect(stdout).toContain('Old style flaky'); // test name
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Flaky') // feature
+      expect(stdout).toContain('Not so flaky test') // test name
+      expect(stdout).toContain('Old style flaky') // test name
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should not run helper hooks', (done) => {
     exec(`${codecept_run_config('codecept.testhooks.json')} --debug`, (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
       expect(lines).not.toEqual(
         expect.arrayContaining([
-          'Helper: I\'m initialized',
-          'Helper: I\'m simple BeforeSuite hook',
-          'Helper: I\'m simple Before hook',
-          'Helper: I\'m simple After hook',
-          'Helper: I\'m simple AfterSuite hook',
+          "Helper: I'm initialized",
+          "Helper: I'm simple BeforeSuite hook",
+          "Helper: I'm simple Before hook",
+          "Helper: I'm simple After hook",
+          "Helper: I'm simple AfterSuite hook",
         ]),
-      );
+      )
 
       expect(lines).toEqual(
         expect.arrayContaining([
-          'Test: I\'m simple BeforeSuite hook',
-          'Test: I\'m simple Before hook',
-          'Test: I\'m simple After hook',
-          'Test: I\'m simple AfterSuite hook',
+          "Test: I'm simple BeforeSuite hook",
+          "Test: I'm simple Before hook",
+          "Test: I'm simple After hook",
+          "Test: I'm simple AfterSuite hook",
         ]),
-      );
+      )
 
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should display meta steps and substeps', (done) => {
     exec(`${codecept_run_config('configs/pageObjects/codecept.po.js')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
+      const lines = stdout.split('\n')
       expect(lines).toEqual(
         expect.arrayContaining([
           '  check current dir',
@@ -89,111 +90,116 @@ describe('dry-run command', () => {
           '      I see file "codecept.po.js"',
           '    I see file "codecept.po.js"',
         ]),
-      );
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      )
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should run feature files', (done) => {
-    exec(codecept_run_config('codecept.bdd.js') + ' --steps --grep "Checkout process"', (err, stdout) => { //eslint-disable-line
-      expect(stdout).toContain('Checkout process'); // feature
-      expect(stdout).toContain('-- before checkout --');
-      expect(stdout).toContain('-- after checkout --');
+    exec(codecept_run_config('codecept.bdd.js') + ' --steps --grep "Checkout process"', (err, stdout) => {
+      //eslint-disable-line
+      expect(stdout).toContain('Checkout process') // feature
+      expect(stdout).toContain('-- before checkout --')
+      expect(stdout).toContain('-- after checkout --')
       // expect(stdout).toContain('In order to buy products'); // test name
-      expect(stdout).toContain('Given I have product with $600 price');
-      expect(stdout).toContain('And I have product with $1000 price');
-      expect(stdout).toContain('Then I should see that total number of products is 2');
-      expect(stdout).toContain('And my order amount is $1600');
-      expect(stdout).not.toContain('I add item 600'); // 'Given' actor's non-gherkin step check
-      expect(stdout).not.toContain('I see sum 1600'); // 'And' actor's non-gherkin step check
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Given I have product with $600 price')
+      expect(stdout).toContain('And I have product with $1000 price')
+      expect(stdout).toContain('Then I should see that total number of products is 2')
+      expect(stdout).toContain('And my order amount is $1600')
+      expect(stdout).not.toContain('I add item 600') // 'Given' actor's non-gherkin step check
+      expect(stdout).not.toContain('I see sum 1600') // 'And' actor's non-gherkin step check
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should print substeps in debug mode', (done) => {
-    exec(codecept_run_config('codecept.bdd.js') + ' --debug --grep "Checkout process @important"', (err, stdout) => { //eslint-disable-line
-      expect(stdout).toContain('Checkout process'); // feature
+    exec(codecept_run_config('codecept.bdd.js') + ' --debug --grep "Checkout process @important"', (err, stdout) => {
+      //eslint-disable-line
+      expect(stdout).toContain('Checkout process') // feature
       // expect(stdout).toContain('In order to buy products'); // test name
-      expect(stdout).toContain('Given I have product with $600 price');
-      expect(stdout).toContain('I add item 600');
-      expect(stdout).toContain('And I have product with $1000 price');
-      expect(stdout).toContain('I add item 1000');
-      expect(stdout).toContain('Then I should see that total number of products is 2');
-      expect(stdout).toContain('I see num 2');
-      expect(stdout).toContain('And my order amount is $1600');
-      expect(stdout).toContain('I see sum 1600');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(stdout).toContain('No tests were executed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Given I have product with $600 price')
+      expect(stdout).toContain('I add item 600')
+      expect(stdout).toContain('And I have product with $1000 price')
+      expect(stdout).toContain('I add item 1000')
+      expect(stdout).toContain('Then I should see that total number of products is 2')
+      expect(stdout).toContain('I see num 2')
+      expect(stdout).toContain('And my order amount is $1600')
+      expect(stdout).toContain('I see sum 1600')
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(stdout).toContain('No tests were executed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should run tests with different data', (done) => {
     exec(`${codecept_run_config('codecept.ddt.js')} --debug`, (err, stdout) => {
-      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '');
-      expect(output).toContain('OK  | 11 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '')
+      expect(output).toContain('OK  | 11 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should work with inject() keyword', (done) => {
-    exec(`${codecept_run_config('configs/pageObjects/codecept.inject.po.js', 'check current dir')} --debug`, (err, stdout) => {
-      const lines = stdout.split('\n');
-      expect(stdout).toContain('injected');
-      expect(lines).toEqual(
-        expect.arrayContaining([
-          '  check current dir',
-          '    I open dir "aaa"',
-          '      I am in path "."',
-          '      I see file "codecept.class.js"',
-          '    On MyPage: has file "uu"',
-          '      I see file "codecept.class.js"',
-          '      I see file "codecept.po.js"',
-          '    I see file "codecept.po.js"',
-        ]),
-      );
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+    exec(
+      `${codecept_run_config('configs/pageObjects/codecept.inject.po.js', 'check current dir')} --debug`,
+      (err, stdout) => {
+        const lines = stdout.split('\n')
+        expect(stdout).toContain('injected')
+        expect(lines).toEqual(
+          expect.arrayContaining([
+            '  check current dir',
+            '    I open dir "aaa"',
+            '      I am in path "."',
+            '      I see file "codecept.class.js"',
+            '    On MyPage: has file "uu"',
+            '      I see file "codecept.class.js"',
+            '      I see file "codecept.po.js"',
+            '    I see file "codecept.po.js"',
+          ]),
+        )
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      },
+    )
+  })
 
   it('should inject page objects via proxy', (done) => {
     exec(`${codecept_run_config('../inject-fail-example')} --debug`, (err, stdout) => {
-      expect(stdout).toContain('newdomain');
-      expect(stdout).toContain("[ 'veni', 'vedi', 'vici' ]", 'array objects work');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('newdomain')
+      expect(stdout).toContain("[ 'veni', 'vedi', 'vici' ]", 'array objects work')
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should enable all plugins in dry-mode when passing -p all', (done) => {
     exec(`${codecept_run_config('codecept.customLocator.js')} --verbose -p all`, (err, stdout) => {
-      expect(stdout).toContain('Plugins: screenshotOnFail, customLocator');
-      expect(stdout).toContain('I see element {xpath: .//*[@data-testid=\'COURSE\']//a}');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(stdout).toContain('--- DRY MODE: No tests were executed ---');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Plugins: screenshotOnFail, customLocator')
+      expect(stdout).toContain("I see element {xpath: .//*[@data-testid='COURSE']//a}")
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(stdout).toContain('--- DRY MODE: No tests were executed ---')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should enable a particular plugin in dry-mode when passing it to -p', (done) => {
     exec(`${codecept_run_config('codecept.customLocator.js')} --verbose -p customLocator`, (err, stdout) => {
-      expect(stdout).toContain('Plugins: customLocator');
-      expect(stdout).toContain('I see element {xpath: .//*[@data-testid=\'COURSE\']//a}');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(stdout).toContain('--- DRY MODE: No tests were executed ---');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
-});
+      expect(stdout).toContain('Plugins: customLocator')
+      expect(stdout).toContain("I see element {xpath: .//*[@data-testid='COURSE']//a}")
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(stdout).toContain('--- DRY MODE: No tests were executed ---')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/gherkin_test.js b/test/runner/gherkin_test.js
index 77e7070d2..9f4a3b030 100644
--- a/test/runner/gherkin_test.js
+++ b/test/runner/gherkin_test.js
@@ -1,53 +1,52 @@
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const path = require('path')
+const fs = require('fs')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/gherkin/');
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/gherkin/')
 
 describe('gherkin bdd commands', () => {
   describe('bdd:init', () => {
-    const codecept_dir_js = path.join(codecept_dir, 'config_js');
-    const codecept_dir_ts = path.join(codecept_dir, 'config_ts');
+    const codecept_dir_js = path.join(codecept_dir, 'config_js')
+    const codecept_dir_ts = path.join(codecept_dir, 'config_ts')
 
     beforeEach(() => {
       fs.copyFileSync(
         path.join(codecept_dir_js, 'codecept.conf.init.js'),
         path.join(codecept_dir_js, 'codecept.conf.js'),
-      );
+      )
       fs.copyFileSync(
         path.join(codecept_dir_ts, 'codecept.conf.init.ts'),
         path.join(codecept_dir_ts, 'codecept.conf.ts'),
-      );
-    });
+      )
+    })
 
     afterEach(() => {
       try {
-        fs.rmSync(path.join(codecept_dir_js, 'codecept.conf.js'));
+        fs.rmSync(path.join(codecept_dir_js, 'codecept.conf.js'))
         fs.rmSync(path.join(codecept_dir_js, 'features'), {
           recursive: true,
-        });
+        })
         fs.rmSync(path.join(codecept_dir_js, 'step_definitions'), {
           recursive: true,
-        });
+        })
       } catch (e) {
         // catch some error
       }
       try {
-        fs.rmSync(path.join(codecept_dir_ts, 'codecept.conf.ts'));
+        fs.rmSync(path.join(codecept_dir_ts, 'codecept.conf.ts'))
         fs.rmSync(path.join(codecept_dir_ts, 'features'), {
           recursive: true,
-        });
+        })
         fs.rmSync(path.join(codecept_dir_ts, 'step_definitions'), {
           recursive: true,
-        });
+        })
       } catch (e) {
         // catch some error
       }
-    });
-
-    [
+    })
+    ;[
       {
         codecept_dir_test: codecept_dir_js,
         extension: 'js',
@@ -59,39 +58,23 @@ describe('gherkin bdd commands', () => {
     ].forEach(({ codecept_dir_test, extension }) => {
       it(`prepare CodeceptJS to run feature files (codecept.conf.${extension})`, (done) => {
         exec(`${runner} gherkin:init ${codecept_dir_test}`, (err, stdout) => {
-          let dir = path.join(codecept_dir_test, 'features');
+          let dir = path.join(codecept_dir_test, 'features')
 
-          stdout.should.include(
-            'Initializing Gherkin (Cucumber BDD) for CodeceptJS',
-          );
-          stdout.should.include(
-            `Created ${dir}, place your *.feature files in it`,
-          );
-          stdout.should.include(
-            'Created sample feature file: features/basic.feature',
-          );
+          stdout.should.include('Initializing Gherkin (Cucumber BDD) for CodeceptJS')
+          stdout.should.include(`Created ${dir}, place your *.feature files in it`)
+          stdout.should.include('Created sample feature file: features/basic.feature')
 
-          dir = path.join(codecept_dir_test, 'step_definitions');
-          stdout.should.include(
-            `Created ${dir}, place step definitions into it`,
-          );
-          stdout.should.include(
-            `Created sample steps file: step_definitions/steps.${extension}`,
-          );
-          assert(!err);
+          dir = path.join(codecept_dir_test, 'step_definitions')
+          stdout.should.include(`Created ${dir}, place step definitions into it`)
+          stdout.should.include(`Created sample steps file: step_definitions/steps.${extension}`)
+          assert(!err)
 
-          const configResult = fs
-            .readFileSync(
-              path.join(codecept_dir_test, `codecept.conf.${extension}`),
-            )
-            .toString();
-          configResult.should.contain('features: \'./features/*.feature\'');
-          configResult.should.contain(
-            `steps: ['./step_definitions/steps.${extension}']`,
-          );
-          done();
-        });
-      });
-    });
-  });
-});
+          const configResult = fs.readFileSync(path.join(codecept_dir_test, `codecept.conf.${extension}`)).toString()
+          configResult.should.contain("features: './features/*.feature'")
+          configResult.should.contain(`steps: ['./step_definitions/steps.${extension}']`)
+          done()
+        })
+      })
+    })
+  })
+})
diff --git a/test/runner/help_test.js b/test/runner/help_test.js
index b9e0bf405..4f185dd1c 100644
--- a/test/runner/help_test.js
+++ b/test/runner/help_test.js
@@ -1,37 +1,37 @@
-const assert = require('assert');
-const path = require('path');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
+const runner = path.join(__dirname, '/../../bin/codecept.js')
 
 describe('help option', () => {
   it('should print help message with --help option', (done) => {
     exec(`${runner} --help`, (err, stdout) => {
-      stdout.should.include('Usage:');
-      stdout.should.include('Options:');
-      stdout.should.include('Commands:');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Usage:')
+      stdout.should.include('Options:')
+      stdout.should.include('Commands:')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should print help message with -h option', (done) => {
     exec(`${runner} -h`, (err, stdout) => {
-      stdout.should.include('Usage:');
-      stdout.should.include('Options:');
-      stdout.should.include('Commands:');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('Usage:')
+      stdout.should.include('Options:')
+      stdout.should.include('Commands:')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should print help message with no option', (done) => {
     exec(`${runner}`, (err, stdout) => {
-      stdout.should.include('Usage:');
-      stdout.should.include('Options:');
-      stdout.should.include('Commands:');
-      assert(!err);
-      done();
-    });
-  });
-});
+      stdout.should.include('Usage:')
+      stdout.should.include('Options:')
+      stdout.should.include('Commands:')
+      assert(!err)
+      done()
+    })
+  })
+})
diff --git a/test/runner/init_test.js b/test/runner/init_test.js
index e74cc3b77..1128fbffc 100644
--- a/test/runner/init_test.js
+++ b/test/runner/init_test.js
@@ -1,78 +1,84 @@
-const { DOWN, ENTER } = require('inquirer-test');
-const run = require('inquirer-test');
-const path = require('path');
-const fs = require('fs');
-const mkdirp = require('mkdirp');
+const { DOWN, ENTER } = require('inquirer-test')
+const run = require('inquirer-test')
+const path = require('path')
+const fs = require('fs')
+const mkdirp = require('mkdirp')
 
-const runner = path.join(__dirname, '../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/init');
+const runner = path.join(__dirname, '../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/init')
 
 describe('Init Command', function () {
-  this.timeout(20000);
+  this.timeout(20000)
 
   beforeEach(() => {
-    mkdirp.sync(codecept_dir);
-    process.env._INIT_DRY_RUN_INSTALL = true;
-  });
+    mkdirp.sync(codecept_dir)
+    process.env._INIT_DRY_RUN_INSTALL = true
+  })
 
   afterEach(() => {
     try {
-      fs.unlinkSync(`${codecept_dir}/codecept.conf.ts`);
-      fs.unlinkSync(`${codecept_dir}/steps_file.ts`);
-      fs.unlinkSync(`${codecept_dir}/tsconfig.json`);
+      fs.unlinkSync(`${codecept_dir}/codecept.conf.ts`)
+      fs.unlinkSync(`${codecept_dir}/steps_file.ts`)
+      fs.unlinkSync(`${codecept_dir}/tsconfig.json`)
     } catch (e) {
       // continue regardless of error
     }
 
     try {
-      fs.unlinkSync(`${codecept_dir}/codecept.conf.js`);
-      fs.unlinkSync(`${codecept_dir}/steps_file.js`);
-      fs.unlinkSync(`${codecept_dir}/jsconfig.json`);
+      fs.unlinkSync(`${codecept_dir}/codecept.conf.js`)
+      fs.unlinkSync(`${codecept_dir}/steps_file.js`)
+      fs.unlinkSync(`${codecept_dir}/jsconfig.json`)
     } catch (e) {
       // continue regardless of error
     }
 
-    delete process.env._INIT_DRY_RUN_INSTALL;
-  });
+    delete process.env._INIT_DRY_RUN_INSTALL
+  })
 
   it('should init Codecept with TypeScript REST JSONResponse English', async () => {
-    const result = await run([runner, 'init', codecept_dir], ['Y', ENTER, ENTER, DOWN, DOWN, DOWN, ENTER, 'y', ENTER, codecept_dir, ENTER, ENTER, ENTER, ENTER]);
+    const result = await run(
+      [runner, 'init', codecept_dir],
+      ['Y', ENTER, ENTER, DOWN, DOWN, DOWN, ENTER, 'y', ENTER, codecept_dir, ENTER, ENTER, ENTER, ENTER],
+    )
 
-    result.should.include('Welcome to CodeceptJS initialization tool');
-    result.should.include('It will prepare and configure a test environment for you');
-    result.should.include('Installing to');
-    result.should.include('? Do you plan to write tests in TypeScript? (y/N)');
-    result.should.include('Where are your tests located? ./*_test.ts');
-    result.should.include('What helpers do you want to use? REST');
-    result.should.include('? Do you want to use JSONResponse helper for assertions on JSON responses?');
-    result.should.include('? Where should logs, screenshots, and reports to be stored?');
-    result.should.include('? Do you want to enable localization for tests?');
+    result.should.include('Welcome to CodeceptJS initialization tool')
+    result.should.include('It will prepare and configure a test environment for you')
+    result.should.include('Installing to')
+    result.should.include('? Do you plan to write tests in TypeScript? (y/N)')
+    result.should.include('Where are your tests located? ./*_test.ts')
+    result.should.include('What helpers do you want to use? REST')
+    result.should.include('? Do you want to use JSONResponse helper for assertions on JSON responses?')
+    result.should.include('? Where should logs, screenshots, and reports to be stored?')
+    result.should.include('? Do you want to enable localization for tests?')
 
-    const config = fs.readFileSync(`${codecept_dir}/codecept.conf.ts`).toString();
-    config.should.include('I: \'./steps_file\'');
+    const config = fs.readFileSync(`${codecept_dir}/codecept.conf.ts`).toString()
+    config.should.include("I: './steps_file'")
 
-    fs.accessSync(`${codecept_dir}/steps_file.ts`, fs.constants.R_OK);
-    fs.accessSync(`${codecept_dir}/tsconfig.json`, fs.constants.R_OK);
-  });
+    fs.accessSync(`${codecept_dir}/steps_file.ts`, fs.constants.R_OK)
+    fs.accessSync(`${codecept_dir}/tsconfig.json`, fs.constants.R_OK)
+  })
 
   it.skip('should init Codecept with JavaScript REST JSONResponse de-DE', async () => {
-    const result = await run([runner, 'init', codecept_dir], [ENTER, ENTER, DOWN, DOWN, DOWN, ENTER, 'y', ENTER, codecept_dir, ENTER, DOWN, ENTER, ENTER, ENTER]);
+    const result = await run(
+      [runner, 'init', codecept_dir],
+      [ENTER, ENTER, DOWN, DOWN, DOWN, ENTER, 'y', ENTER, codecept_dir, ENTER, DOWN, ENTER, ENTER, ENTER],
+    )
 
-    result.should.include('Welcome to CodeceptJS initialization tool');
-    result.should.include('It will prepare and configure a test environment for you');
-    result.should.include('Installing to');
-    result.should.include('? Do you plan to write tests in TypeScript? (y/N)');
-    result.should.include('Where are your tests located? ./*_test.js');
-    result.should.include('What helpers do you want to use? REST');
-    result.should.include('? Do you want to use JSONResponse helper for assertions on JSON responses?');
-    result.should.include('? Where should logs, screenshots, and reports to be stored?');
-    result.should.include('? Do you want to enable localization for tests?');
-    result.should.include('de-DE');
+    result.should.include('Welcome to CodeceptJS initialization tool')
+    result.should.include('It will prepare and configure a test environment for you')
+    result.should.include('Installing to')
+    result.should.include('? Do you plan to write tests in TypeScript? (y/N)')
+    result.should.include('Where are your tests located? ./*_test.js')
+    result.should.include('What helpers do you want to use? REST')
+    result.should.include('? Do you want to use JSONResponse helper for assertions on JSON responses?')
+    result.should.include('? Where should logs, screenshots, and reports to be stored?')
+    result.should.include('? Do you want to enable localization for tests?')
+    result.should.include('de-DE')
 
-    const config = fs.readFileSync(`${codecept_dir}/codecept.conf.js`).toString();
-    config.should.include('Ich: \'./steps_file.js\'');
+    const config = fs.readFileSync(`${codecept_dir}/codecept.conf.js`).toString()
+    config.should.include("Ich: './steps_file.js'")
 
-    fs.accessSync(`${codecept_dir}/steps_file.js`, fs.constants.R_OK);
-    fs.accessSync(`${codecept_dir}/jsconfig.json`, fs.constants.R_OK);
-  });
-});
+    fs.accessSync(`${codecept_dir}/steps_file.js`, fs.constants.R_OK)
+    fs.accessSync(`${codecept_dir}/jsconfig.json`, fs.constants.R_OK)
+  })
+})
diff --git a/test/runner/interface_test.js b/test/runner/interface_test.js
index efbfcd37a..d0d2319ad 100644
--- a/test/runner/interface_test.js
+++ b/test/runner/interface_test.js
@@ -1,199 +1,191 @@
-const { expect } = require('expect');
-const path = require('path');
-const exec = require('child_process').exec;
+const { expect } = require('expect')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run`;
-const config_run_config = config => `${codecept_run} --config ${codecept_dir}/${config}`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run`
+const config_run_config = (config) => `${codecept_run} --config ${codecept_dir}/${config}`
 
 describe('CodeceptJS Interface', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('should rerun flaky tests', (done) => {
     exec(config_run_config('codecept.flaky.js'), (err, stdout) => {
-      expect(stdout).toContain('Flaky'); // feature
-      expect(stdout).toContain('Not so flaky test'); // test name
-      expect(stdout).toContain('Old style flaky'); // test name
-      expect(stdout).toContain('[T1] Retries: 2'); // test name
-      expect(stdout).toContain('[T2] Retries: 4'); // test name
-      expect(stdout).toContain('[T3] Retries: 1'); // test name
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Flaky') // feature
+      expect(stdout).toContain('Not so flaky test') // test name
+      expect(stdout).toContain('Old style flaky') // test name
+      expect(stdout).toContain('[T1] Retries: 2') // test name
+      expect(stdout).toContain('[T2] Retries: 4') // test name
+      expect(stdout).toContain('[T3] Retries: 1') // test name
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should rerun retried steps', (done) => {
     exec(`${config_run_config('codecept.retry.json')} --grep @test1`, (err, stdout) => {
-      expect(stdout).toContain('Retry'); // feature
-      expect(stdout).toContain('Retries: 4'); // test name
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Retry') // feature
+      expect(stdout).toContain('Retries: 4') // test name
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should not propagate retries to non retried steps', (done) => {
     exec(`${config_run_config('codecept.retry.json')} --grep @test2 --verbose`, (err, stdout) => {
-      expect(stdout).toContain('Retry'); // feature
-      expect(stdout).toContain('Retries: 1'); // test name
-      done();
-    });
-  });
+      expect(stdout).toContain('Retry') // feature
+      expect(stdout).toContain('Retries: 1') // test name
+      done()
+    })
+  })
 
   it('should use retryFailedStep plugin for failed steps', (done) => {
     exec(`${config_run_config('codecept.retryFailed.json')} --grep @test1`, (err, stdout) => {
-      expect(stdout).toContain('Retry'); // feature
-      expect(stdout).toContain('Retries: 5'); // test name
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Retry') // feature
+      expect(stdout).toContain('Retries: 5') // test name
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should not retry wait* steps in retryFailedStep plugin', (done) => {
     exec(`${config_run_config('codecept.retryFailed.json')} --grep @test2`, (err, stdout) => {
-      expect(stdout).toContain('Retry'); // feature
-      expect(stdout).not.toContain('Retries: 5');
-      expect(stdout).toContain('Retries: 1');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Retry') // feature
+      expect(stdout).not.toContain('Retries: 5')
+      expect(stdout).toContain('Retries: 1')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should not retry steps if retryFailedStep plugin disabled', (done) => {
     exec(`${config_run_config('codecept.retryFailed.json')} --grep @test3`, (err, stdout) => {
-      expect(stdout).toContain('Retry'); // feature
-      expect(stdout).not.toContain('Retries: 5');
-      expect(stdout).toContain('Retries: 1');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Retry') // feature
+      expect(stdout).not.toContain('Retries: 5')
+      expect(stdout).toContain('Retries: 1')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should include grep option tests', (done) => {
     exec(config_run_config('codecept.grep.js'), (err, stdout) => {
-      expect(stdout).toContain('Got login davert and password'); // feature
-      expect(stdout).not.toContain('Got changed login'); // test name
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Got login davert and password') // feature
+      expect(stdout).not.toContain('Got changed login') // test name
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should run tests with different data', (done) => {
     exec(config_run_config('codecept.ddt.js'), (err, stdout) => {
-      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '');
+      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '')
       expect(output).toContain(`Got login davert and password 123456
-  ✔ Should log accounts1 | {"login":"davert","password":"123456"}`);
+  ✔ Should log accounts1 | {"login":"davert","password":"123456"}`)
 
       expect(output).toContain(`Got login admin and password 666666
-  ✔ Should log accounts1 | {"login":"admin","password":"666666"}`);
+  ✔ Should log accounts1 | {"login":"admin","password":"666666"}`)
 
       expect(output).toContain(`Got changed login andrey and password 555555
-  ✔ Should log accounts2 | {"login":"andrey","password":"555555"}`);
+  ✔ Should log accounts2 | {"login":"andrey","password":"555555"}`)
 
       expect(output).toContain(`Got changed login collaborator and password 222222
-  ✔ Should log accounts2 | {"login":"collaborator","password":"222222"}`);
+  ✔ Should log accounts2 | {"login":"collaborator","password":"222222"}`)
 
       expect(output).toContain(`Got changed login nick
-  ✔ Should log accounts3 | ["nick","pick"]`);
+  ✔ Should log accounts3 | ["nick","pick"]`)
 
       expect(output).toContain(`Got changed login jack
-  ✔ Should log accounts3 | ["jack","sacj"]`);
+  ✔ Should log accounts3 | ["jack","sacj"]`)
 
       expect(output).toContain(`Got generator login nick
-  ✔ Should log accounts4 | {"user":"nick"}`);
+  ✔ Should log accounts4 | {"user":"nick"}`)
 
       expect(output).toContain(`Got generator login pick
-  ✔ Should log accounts4 | {"user":"pick"}`);
+  ✔ Should log accounts4 | {"user":"pick"}`)
 
       expect(output).toContain(`Got array item 1
-  ✔ Should log array of strings | {"1"}`);
+  ✔ Should log array of strings | {"1"}`)
 
       expect(output).toContain(`Got array item 2
-  ✔ Should log array of strings | {"2"}`);
+  ✔ Should log array of strings | {"2"}`)
 
       expect(output).toContain(`Got array item 3
-  ✔ Should log array of strings | {"3"}`);
+  ✔ Should log array of strings | {"3"}`)
 
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should run all tests with data of array by only', (done) => {
     exec(config_run_config('codecept.addt.js'), (err, stdout) => {
-      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '');
-      expect(output).toContain('Got array item 1');
-      expect(output).toContain('Should log array of strings | {"1"}');
-      expect(output).toContain('Got array item 2');
-      expect(output).toContain('Should log array of strings | {"2"}');
-      expect(output).toContain('Got array item 3');
-      expect(output).toContain('Should log array of strings | {"3"}');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '')
+      expect(output).toContain('Got array item 1')
+      expect(output).toContain('Should log array of strings | {"1"}')
+      expect(output).toContain('Got array item 2')
+      expect(output).toContain('Should log array of strings | {"2"}')
+      expect(output).toContain('Got array item 3')
+      expect(output).toContain('Should log array of strings | {"3"}')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should run all tests with data of generator by only', (done) => {
     exec(config_run_config('codecept.gddt.js'), (err, stdout) => {
-      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '');
+      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '')
       expect(output).toContain(`Got generator login nick
-  ✔ Should log generator of strings | {"user":"nick"}`);
+  ✔ Should log generator of strings | {"user":"nick"}`)
 
       expect(output).toContain(`Got generator login pick
-  ✔ Should log generator of strings | {"user":"pick"}`);
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+  ✔ Should log generator of strings | {"user":"pick"}`)
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should provide skipped test for each entry of data', (done) => {
     exec(config_run_config('codecept.skip_ddt.json'), (err, stdout) => {
-      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '');
-      expect(output).toContain('S Should add skip entry for each item | {"user":"bob"}');
-      expect(output).toContain('S Should add skip entry for each item | {"user":"anne"}');
-      expect(output).toContain('OK');
-      expect(output).toContain('0 passed');
-      expect(output).toContain('2 skipped');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      const output = stdout.replace(/in [0-9]ms/g, '').replace(/\r/g, '')
+      expect(output).toContain('S Should add skip entry for each item | {"user":"bob"}')
+      expect(output).toContain('S Should add skip entry for each item | {"user":"anne"}')
+      expect(output).toContain('OK')
+      expect(output).toContain('0 passed')
+      expect(output).toContain('2 skipped')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should execute expected promise chain', (done) => {
     exec(`${codecept_run} --debug`, (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
       // before hooks
-      const beforeStep = [
-        'I am in path "."',
-      ];
+      const beforeStep = ['I am in path "."']
 
-      lines.filter(l => beforeStep.indexOf(l) > -1)
-        .should.eql(beforeStep, 'check step hooks execution order');
+      lines.filter((l) => beforeStep.indexOf(l) > -1).should.eql(beforeStep, 'check step hooks execution order')
 
       // steps order
-      const step = [
-        'I am in path "."',
-        'hello world',
-        'I see file "codecept.js"',
-      ];
+      const step = ['I am in path "."', 'hello world', 'I see file "codecept.js"']
 
-      lines.filter(l => step.indexOf(l) > -1)
-        .should.eql(step, 'check steps execution order');
+      lines.filter((l) => step.indexOf(l) > -1).should.eql(step, 'check steps execution order')
 
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should display steps and artifacts & error log', (done) => {
     exec(`${config_run_config('./configs/testArtifacts')} --debug`, (err, stdout) => {
-      stdout.should.include('Scenario Steps:');
-      stdout.should.include('Artifacts');
-      stdout.should.include('- screenshot: [ SCREEENSHOT FILE ]');
-      done();
-    });
-  });
-});
+      stdout.should.include('Scenario Steps:')
+      stdout.should.include('Artifacts')
+      stdout.should.include('- screenshot: [ SCREEENSHOT FILE ]')
+      done()
+    })
+  })
+})
diff --git a/test/runner/list_test.js b/test/runner/list_test.js
index f134fec63..c107bdf36 100644
--- a/test/runner/list_test.js
+++ b/test/runner/list_test.js
@@ -1,18 +1,18 @@
-const assert = require('assert');
-const path = require('path');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
 
 describe('list commands', () => {
   it('list should print actions', (done) => {
     exec(`${runner} list ${codecept_dir}`, (err, stdout) => {
-      stdout.should.include('FileSystem'); // helper name
-      stdout.should.include('FileSystem I.amInPath(openPath)'); // action name
-      stdout.should.include('FileSystem I.seeFile(name)');
-      assert(!err);
-      done();
-    });
-  });
-});
+      stdout.should.include('FileSystem') // helper name
+      stdout.should.include('FileSystem I.amInPath(openPath)') // action name
+      stdout.should.include('FileSystem I.seeFile(name)')
+      assert(!err)
+      done()
+    })
+  })
+})
diff --git a/test/runner/pageobject_test.js b/test/runner/pageobject_test.js
index 2cebc6214..ec2c8fb9d 100644
--- a/test/runner/pageobject_test.js
+++ b/test/runner/pageobject_test.js
@@ -1,21 +1,22 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const { expect } = require('expect');
+const path = require('path')
+const exec = require('child_process').exec
+const { expect } = require('expect')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/pageObjects');
-const codecept_run = `${runner} run`;
-const config_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/pageObjects')
+const codecept_run = `${runner} run`
+const config_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS PageObject', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   describe('Failed PageObject', () => {
     it('should fail if page objects was failed', (done) => {
       exec(`${config_run_config('codecept.fail_po.js')} --debug`, (err, stdout) => {
-        const lines = stdout.split('\n');
+        const lines = stdout.split('\n')
         expect(lines).toEqual(
           expect.arrayContaining([
             expect.stringContaining('File notexistfile.js not found in'),
@@ -24,68 +25,68 @@ describe('CodeceptJS PageObject', () => {
             expect.stringContaining('- I.seeFile("codecept.class.js")'),
             expect.stringContaining('- I.amInPath(".")'),
           ]),
-        );
-        expect(stdout).toContain('FAIL  | 0 passed, 1 failed');
-        expect(err).toBeTruthy();
-        done();
-      });
-    });
-  });
+        )
+        expect(stdout).toContain('FAIL  | 0 passed, 1 failed')
+        expect(err).toBeTruthy()
+        done()
+      })
+    })
+  })
 
   describe('PageObject as Class', () => {
     it('should inject page objects by class', (done) => {
       exec(`${config_run_config('codecept.class.js', '@ClassPageObject')} --debug`, (err, stdout) => {
-        expect(stdout).not.toContain('classpage.type is not a function');
-        expect(stdout).toContain('On classpage: type "Class Page Type"');
-        expect(stdout).toContain('I print message "Class Page Type"');
-        expect(stdout).toContain('On classpage: purge domains');
-        expect(stdout).toContain('I print message "purgeDomains"');
-        expect(stdout).toContain('Class Page Type');
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
+        expect(stdout).not.toContain('classpage.type is not a function')
+        expect(stdout).toContain('On classpage: type "Class Page Type"')
+        expect(stdout).toContain('I print message "Class Page Type"')
+        expect(stdout).toContain('On classpage: purge domains')
+        expect(stdout).toContain('I print message "purgeDomains"')
+        expect(stdout).toContain('Class Page Type')
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
 
     it('should inject page objects by class which nested base clas', (done) => {
       exec(`${config_run_config('codecept.class.js', '@NestedClassPageObject')} --debug`, (err, stdout) => {
-        expect(stdout).not.toContain('classnestedpage.type is not a function');
-        expect(stdout).toContain('On classnestedpage: type "Nested Class Page Type"');
-        expect(stdout).toContain('user => User1');
-        expect(stdout).toContain('I print message "Nested Class Page Type"');
-        expect(stdout).toContain('On classnestedpage: purge domains');
-        expect(stdout).toContain('I print message "purgeDomains"');
-        expect(stdout).toContain('Nested Class Page Type');
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
+        expect(stdout).not.toContain('classnestedpage.type is not a function')
+        expect(stdout).toContain('On classnestedpage: type "Nested Class Page Type"')
+        expect(stdout).toContain('user => User1')
+        expect(stdout).toContain('I print message "Nested Class Page Type"')
+        expect(stdout).toContain('On classnestedpage: purge domains')
+        expect(stdout).toContain('I print message "purgeDomains"')
+        expect(stdout).toContain('Nested Class Page Type')
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
 
     it('should print pretty step log and pretty event log', (done) => {
       exec(`${config_run_config('codecept.logs.js', 'Print correct arg message')} --steps`, (err, stdout) => {
-        expect(stdout).toContain('I get humanize args Logs Page Value');
-        expect(stdout).toContain('Start event step: I get humanize args Logs Page Valu');
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
+        expect(stdout).toContain('I get humanize args Logs Page Value')
+        expect(stdout).toContain('Start event step: I get humanize args Logs Page Valu')
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
 
     it('should print pretty failed step log on stack trace', (done) => {
       exec(`${config_run_config('codecept.logs.js', 'Error print correct arg message')} --steps`, (err, stdout) => {
-        expect(stdout).toContain('I.errorMethodHumanizeArgs(Logs Page Value)');
-        expect(stdout).toContain('FAIL  | 0 passed, 1 failed');
-        expect(err).toBeTruthy();
-        done();
-      });
-    });
-  });
+        expect(stdout).toContain('I.errorMethodHumanizeArgs(Logs Page Value)')
+        expect(stdout).toContain('FAIL  | 0 passed, 1 failed')
+        expect(err).toBeTruthy()
+        done()
+      })
+    })
+  })
 
   describe('Show MetaSteps in Log', () => {
     it('should display meta steps and substeps', (done) => {
       exec(`${config_run_config('codecept.po.js')} --debug`, (err, stdout) => {
-        const lines = stdout.split('\n');
+        const lines = stdout.split('\n')
         expect(lines).toEqual(
           expect.arrayContaining([
             '  check current dir',
@@ -97,19 +98,19 @@ describe('CodeceptJS PageObject', () => {
             '      I see file "codecept.po.js"',
             '    I see file "codecept.po.js"',
           ]),
-        );
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
-  });
+        )
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
+  })
 
   describe('Inject PO in Test', () => {
     it('should work with inject() keyword', (done) => {
       exec(`${config_run_config('codecept.inject.po.js', 'check current dir')} --debug`, (err, stdout) => {
-        const lines = stdout.split('\n');
-        expect(stdout).toContain('injected');
+        const lines = stdout.split('\n')
+        expect(stdout).toContain('injected')
         expect(lines).toEqual(
           expect.arrayContaining([
             '  check current dir',
@@ -121,18 +122,18 @@ describe('CodeceptJS PageObject', () => {
             '      I see file "codecept.po.js"',
             '    I see file "codecept.po.js"',
           ]),
-        );
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
-  });
+        )
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
+  })
 
   describe('PageObject with context', () => {
     it('should work when used "this" context on method', (done) => {
       exec(`${config_run_config('codecept.inject.po.js', 'pageobject with context')} --debug`, (err, stdout) => {
-        const lines = stdout.split('\n');
+        const lines = stdout.split('\n')
         expect(lines).toEqual(
           expect.arrayContaining([
             '  pageobject with context',
@@ -144,33 +145,33 @@ describe('CodeceptJS PageObject', () => {
             '      I see file "codecept.po.js"',
             '    I see file "codecept.po.js"',
           ]),
-        );
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
-  });
+        )
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
+  })
 
   describe('Inject PO in another PO', () => {
     it('should inject page objects via proxy', (done) => {
       exec(`${config_run_config('../../../inject-fail-example')} --debug`, (err, stdout) => {
-        expect(stdout).toContain('newdomain');
-        expect(stdout).toContain("[ 'veni', 'vedi', 'vici' ]", 'array objects work');
-        expect(stdout).toContain('OK  | 1 passed');
-        expect(err).toBeFalsy();
-        done();
-      });
-    });
-  });
+        expect(stdout).toContain('newdomain')
+        expect(stdout).toContain("[ 'veni', 'vedi', 'vici' ]", 'array objects work')
+        expect(stdout).toContain('OK  | 1 passed')
+        expect(err).toBeFalsy()
+        done()
+      })
+    })
+  })
 
   it('built methods are still available custom I steps_file is added', (done) => {
     exec(`${config_run_config('codecept.class.js', '@CustomStepsBuiltIn')} --debug`, (err, stdout) => {
-      expect(stdout).toContain('Built in say');
-      expect(stdout).toContain('Say called from custom step');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
-});
+      expect(stdout).toContain('Built in say')
+      expect(stdout).toContain('Say called from custom step')
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/retry_hooks_test.js b/test/runner/retry_hooks_test.js
index a17c77824..3e8d9dd86 100644
--- a/test/runner/retry_hooks_test.js
+++ b/test/runner/retry_hooks_test.js
@@ -1,57 +1,56 @@
-const { expect } = require('expect');
-const exec = require('child_process').exec;
-const { codecept_dir, codecept_run } = require('./consts');
+const { expect } = require('expect')
+const exec = require('child_process').exec
+const { codecept_dir, codecept_run } = require('./consts')
 
-const debug_this_test = false;
+const debug_this_test = false
 
-const config_run_config = (config, grep, verbose = false) => `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/retryHooks/${config} ${grep ? `--grep "${grep}"` : ''}`;
+const config_run_config = (config, grep, verbose = false) =>
+  `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/retryHooks/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS Retry Hooks', function () {
-  this.timeout(10000);
-
-  ['#Async ', '#Before ', '#BeforeSuite ', '#Helper '].forEach(retryHook => {
+  this.timeout(10000)
+  ;['#Async ', '#Before ', '#BeforeSuite ', '#Helper '].forEach((retryHook) => {
     it(`run ${retryHook} config`, (done) => {
       exec(config_run_config('codecept.conf.js', retryHook), (err, stdout) => {
-        debug_this_test && console.log(stdout);
-        expect(stdout).toContain('1 passed');
-        done();
-      });
-    });
-  });
-
-  ['#Before ', '#BeforeSuite '].forEach(retryHook => {
+        debug_this_test && console.log(stdout)
+        expect(stdout).toContain('1 passed')
+        done()
+      })
+    })
+  })
+  ;['#Before ', '#BeforeSuite '].forEach((retryHook) => {
     it(`should ${retryHook} set hook retries from global config`, (done) => {
       exec(config_run_config('codecept.retry.obj.conf.js', retryHook), (err, stdout) => {
-        debug_this_test && console.log(stdout);
-        expect(stdout).toContain('1 passed');
-        done();
-      });
-    });
-  });
+        debug_this_test && console.log(stdout)
+        expect(stdout).toContain('1 passed')
+        done()
+      })
+    })
+  })
 
   it('should finish if retry has not happened', (done) => {
     exec(config_run_config('codecept.conf.js', '#FailBefore '), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('-- FAILURES');
-      expect(stdout).toContain('not works');
-      expect(stdout).toContain('1) Fail #FailBefore hook');
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('-- FAILURES')
+      expect(stdout).toContain('not works')
+      expect(stdout).toContain('1) Fail #FailBefore hook')
+      done()
+    })
+  })
 
   it('should set global retry', (done) => {
     exec(config_run_config('codecept.retry.global.conf.js', '#globalRetry'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('1 passed');
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('1 passed')
+      done()
+    })
+  })
 
   it('should set global scenario retry', (done) => {
     exec(config_run_config('codecept.retry.global.scenario.conf.js', '#globalScenarioRetry'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('1 passed');
-      done();
-    });
-  });
-});
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('1 passed')
+      done()
+    })
+  })
+})
diff --git a/test/runner/run_multiple_test.js b/test/runner/run_multiple_test.js
index 91c40e408..3571669ad 100644
--- a/test/runner/run_multiple_test.js
+++ b/test/runner/run_multiple_test.js
@@ -1,258 +1,264 @@
-const assert = require('assert');
-const { expect } = require('expect');
-const path = require('path');
-const exec = require('child_process').exec;
+const assert = require('assert')
+const { expect } = require('expect')
+const path = require('path')
+const exec = require('child_process').exec
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run-multiple --config ${codecept_dir}/codecept.multiple.js `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run-multiple --config ${codecept_dir}/codecept.multiple.js `
 
 describe('CodeceptJS Multiple Runner', function () {
-  this.timeout(40000);
+  this.timeout(40000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should execute one suite with browser', (done) => {
     exec(`${codecept_run}default:firefox`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('.default:firefox] print browser ');
-      stdout.should.not.include('.default:chrome] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('.default:firefox] print browser ')
+      stdout.should.not.include('.default:chrome] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should execute all suites', (done) => {
     exec(`${codecept_run}--all`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.default:chrome] print browser ');
-      stdout.should.include('[2.default:firefox] print browser ');
-      stdout.should.include('[3.mobile:android] print browser ');
-      stdout.should.include('[4.mobile:safari] print browser ');
-      stdout.should.include('[5.mobile:chrome] print browser ');
-      stdout.should.include('[6.mobile:safari] print browser ');
-      stdout.should.include('[7.grep:chrome] @grep print browser size ');
-      stdout.should.include('[8.grep:firefox] @grep print browser size ');
-      stdout.should.not.include('[7.grep:chrome] print browser ');
-      stdout.should.include('[1.default:chrome] @grep print browser size ');
-      stdout.should.include('[3.mobile:android] @grep print browser size ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.default:chrome] print browser ')
+      stdout.should.include('[2.default:firefox] print browser ')
+      stdout.should.include('[3.mobile:android] print browser ')
+      stdout.should.include('[4.mobile:safari] print browser ')
+      stdout.should.include('[5.mobile:chrome] print browser ')
+      stdout.should.include('[6.mobile:safari] print browser ')
+      stdout.should.include('[7.grep:chrome] @grep print browser size ')
+      stdout.should.include('[8.grep:firefox] @grep print browser size ')
+      stdout.should.not.include('[7.grep:chrome] print browser ')
+      stdout.should.include('[1.default:chrome] @grep print browser size ')
+      stdout.should.include('[3.mobile:android] @grep print browser size ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should replace parameters', (done) => {
     exec(`${codecept_run}grep --debug`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.grep:chrome]     › maximize');
-      stdout.should.include('[2.grep:firefox]     › 1200x840');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.grep:chrome]     › maximize')
+      stdout.should.include('[2.grep:firefox]     › 1200x840')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should execute multiple suites', (done) => {
     exec(`${codecept_run}mobile default `, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.mobile:android] print browser ');
-      stdout.should.include('[2.mobile:safari] print browser ');
-      stdout.should.include('[3.mobile:chrome] print browser ');
-      stdout.should.include('[4.mobile:safari] print browser ');
-      stdout.should.include('[5.default:chrome] print browser ');
-      stdout.should.include('[6.default:firefox] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.mobile:android] print browser ')
+      stdout.should.include('[2.mobile:safari] print browser ')
+      stdout.should.include('[3.mobile:chrome] print browser ')
+      stdout.should.include('[4.mobile:safari] print browser ')
+      stdout.should.include('[5.default:chrome] print browser ')
+      stdout.should.include('[6.default:firefox] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should execute multiple suites with selected browsers', (done) => {
     exec(`${codecept_run}mobile:safari default:chrome `, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.mobile:safari] print browser ');
-      stdout.should.include('[2.mobile:safari] print browser ');
-      stdout.should.include('[3.default:chrome] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.mobile:safari] print browser ')
+      stdout.should.include('[2.mobile:safari] print browser ')
+      stdout.should.include('[3.default:chrome] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should print steps', (done) => {
     exec(`${codecept_run}default --steps`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[2.default:firefox]   print browser ');
-      stdout.should.include('[2.default:firefox]     I print browser ');
-      stdout.should.include('[1.default:chrome]   print browser ');
-      stdout.should.include('[1.default:chrome]     I print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[2.default:firefox]   print browser ')
+      stdout.should.include('[2.default:firefox]     I print browser ')
+      stdout.should.include('[1.default:chrome]   print browser ')
+      stdout.should.include('[1.default:chrome]     I print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should pass grep to configuration', (done) => {
     exec(`${codecept_run}default --grep @grep`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.default:chrome] @grep print browser size');
-      stdout.should.include('[2.default:firefox] @grep print browser size');
-      stdout.should.not.include('[1.default:chrome] print browser ');
-      stdout.should.not.include('[2.default:firefox] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.default:chrome] @grep print browser size')
+      stdout.should.include('[2.default:firefox] @grep print browser size')
+      stdout.should.not.include('[1.default:chrome] print browser ')
+      stdout.should.not.include('[2.default:firefox] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should pass grep invert to configuration', (done) => {
     exec(`${codecept_run}default --grep @grep --invert`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.not.include('[1.default:chrome] @grep print browser size');
-      stdout.should.not.include('[2.default:firefox] @grep print browser size');
-      stdout.should.include('[1.default:chrome] print browser ');
-      stdout.should.include('[2.default:firefox] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.not.include('[1.default:chrome] @grep print browser size')
+      stdout.should.not.include('[2.default:firefox] @grep print browser size')
+      stdout.should.include('[1.default:chrome] print browser ')
+      stdout.should.include('[2.default:firefox] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should pass tests to configuration', (done) => {
     exec(`${codecept_run}test`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.test:chrome] print browser size');
-      stdout.should.include('[2.test:firefox] print browser size');
-      stdout.should.include('[1.test:chrome] print browser ');
-      stdout.should.include('[2.test:firefox] print browser ');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.test:chrome] print browser size')
+      stdout.should.include('[2.test:firefox] print browser size')
+      stdout.should.include('[1.test:chrome] print browser ')
+      stdout.should.include('[2.test:firefox] print browser ')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run chunks', (done) => {
     exec(`${codecept_run}chunks`, (err, stdout) => {
-      stdout.should.include('CodeceptJS'); // feature
-      stdout.should.include('[1.chunks:chunk1:dummy] print browser');
-      stdout.should.include('[2.chunks:chunk2:dummy] @grep print browser size');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('CodeceptJS') // feature
+      stdout.should.include('[1.chunks:chunk1:dummy] print browser')
+      stdout.should.include('[2.chunks:chunk2:dummy] @grep print browser size')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should run features in parallel', (done) => {
-    process.chdir(codecept_dir);
-    exec(`${runner} run-multiple --config codecept.multiple.features.js chunks --features  --grep '(?=.*)^(?!.*@fail)'`, (err, stdout) => {
-      stdout.should.include('[1.chunks:chunk1:default] Checkout examples process');
-      stdout.should.not.include('[2.chunks:chunk2:default] Checkout examples process');
-      stdout.should.include('[2.chunks:chunk2:default] Checkout string');
-      stdout.should.not.include('[1.chunks:chunk1:default] Checkout string');
-      stdout.should.include('[1.chunks:chunk1:default]   OK  |');
-      stdout.should.include('[2.chunks:chunk2:default]   OK  |');
-      stdout.should.not.include('@feature_grep');
-      assert(!err);
-      done();
-    });
-  });
+    process.chdir(codecept_dir)
+    exec(
+      `${runner} run-multiple --config codecept.multiple.features.js chunks --features  --grep '(?=.*)^(?!.*@fail)'`,
+      (err, stdout) => {
+        stdout.should.include('[1.chunks:chunk1:default] Checkout examples process')
+        stdout.should.not.include('[2.chunks:chunk2:default] Checkout examples process')
+        stdout.should.include('[2.chunks:chunk2:default] Checkout string')
+        stdout.should.not.include('[1.chunks:chunk1:default] Checkout string')
+        stdout.should.include('[1.chunks:chunk1:default]   OK  |')
+        stdout.should.include('[2.chunks:chunk2:default]   OK  |')
+        stdout.should.not.include('@feature_grep')
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should run features & tests in parallel', (done) => {
-    process.chdir(codecept_dir);
-    exec(`${runner} run-multiple --config codecept.multiple.features.js chunks --grep '(?=.*)^(?!.*@fail)'`, (err, stdout) => {
-      stdout.should.include('@feature_grep');
-      stdout.should.include('Checkout examples process');
-      stdout.should.include('Checkout string');
-      assert(!err);
-      done();
-    });
-  });
+    process.chdir(codecept_dir)
+    exec(
+      `${runner} run-multiple --config codecept.multiple.features.js chunks --grep '(?=.*)^(?!.*@fail)'`,
+      (err, stdout) => {
+        stdout.should.include('@feature_grep')
+        stdout.should.include('Checkout examples process')
+        stdout.should.include('Checkout string')
+        assert(!err)
+        done()
+      },
+    )
+  })
 
   it('should run only tests in parallel', (done) => {
-    process.chdir(codecept_dir);
+    process.chdir(codecept_dir)
     exec(`${runner} run-multiple --config codecept.multiple.features.js chunks --tests`, (err, stdout) => {
-      stdout.should.include('@feature_grep');
-      stdout.should.not.include('Checkout examples process');
-      stdout.should.not.include('Checkout string');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('@feature_grep')
+      stdout.should.not.include('Checkout examples process')
+      stdout.should.not.include('Checkout string')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should exit with non-zero code for failures during init process', (done) => {
-    process.chdir(codecept_dir);
+    process.chdir(codecept_dir)
     exec(`${runner} run-multiple --config codecept.multiple.initFailure.js default --all`, (err, stdout) => {
-      expect(err).not.toBeFalsy();
-      expect(err.code).toBe(1);
-      expect(stdout).toContain('Failed on FailureHelper');
-      done();
-    });
-  });
+      expect(err).not.toBeFalsy()
+      expect(err.code).toBe(1)
+      expect(stdout).toContain('Failed on FailureHelper')
+      done()
+    })
+  })
 
   it('should exit code 1 when error in config', (done) => {
-    process.chdir(codecept_dir);
+    process.chdir(codecept_dir)
     exec(`${runner} run-multiple --config configs/codecept-invalid.config.js default --all`, (err, stdout, stderr) => {
-      expect(stdout).not.toContain('UnhandledPromiseRejectionWarning');
-      expect(stderr).not.toContain('UnhandledPromiseRejectionWarning');
-      expect(stdout).toContain('badFn is not defined');
-      expect(err).not.toBe(null);
-      done();
-    });
-  });
+      expect(stdout).not.toContain('UnhandledPromiseRejectionWarning')
+      expect(stderr).not.toContain('UnhandledPromiseRejectionWarning')
+      expect(stdout).toContain('badFn is not defined')
+      expect(err).not.toBe(null)
+      done()
+    })
+  })
 
   describe('bootstrapAll and teardownAll', () => {
-    const _codecept_run = `run-multiple --config ${codecept_dir}`;
+    const _codecept_run = `run-multiple --config ${codecept_dir}`
     it('should be executed from async function in config', (done) => {
       exec(`${runner} ${_codecept_run}/codecept.async.bootstrapall.multiple.code.js default`, (err, stdout) => {
-        stdout.should.include('CodeceptJS'); // feature
-        stdout.should.include('Results: inside Promise\n"event.multiple.before" is called');
-        stdout.should.include('"teardownAll" is called.');
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include('CodeceptJS') // feature
+        stdout.should.include('Results: inside Promise\n"event.multiple.before" is called')
+        stdout.should.include('"teardownAll" is called.')
+        assert(!err)
+        done()
+      })
+    })
 
     it('should be executed from function in config', (done) => {
       exec(`${runner} ${_codecept_run}/codecept.bootstrapall.multiple.code.js default`, (err, stdout) => {
-        stdout.should.include('CodeceptJS'); // feature
-        stdout.should.include('"bootstrapAll" is called.');
-        stdout.should.include('"teardownAll" is called.');
-        assert(!err);
-        done();
-      });
-    });
-  });
+        stdout.should.include('CodeceptJS') // feature
+        stdout.should.include('"bootstrapAll" is called.')
+        stdout.should.include('"teardownAll" is called.')
+        assert(!err)
+        done()
+      })
+    })
+  })
 
   describe('with require parameter', () => {
-    const _codecept_run = `run-multiple --config ${codecept_dir}`;
-    const moduleOutput = 'Module was required 1';
-    const moduleOutput2 = 'Module was required 2';
+    const _codecept_run = `run-multiple --config ${codecept_dir}`
+    const moduleOutput = 'Module was required 1'
+    const moduleOutput2 = 'Module was required 2'
 
     it('should be executed with module when described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${runner} ${_codecept_run}/codecept.require.multiple.single.json default`, (err, stdout) => {
-        stdout.should.include(moduleOutput);
-        stdout.should.not.include(moduleOutput2);
-        (stdout.match(new RegExp(moduleOutput, 'g')) || []).should.have.lengthOf(2);
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include(moduleOutput)
+        stdout.should.not.include(moduleOutput2)
+        ;(stdout.match(new RegExp(moduleOutput, 'g')) || []).should.have.lengthOf(2)
+        assert(!err)
+        done()
+      })
+    })
 
     it('should be executed with several module when described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${runner} ${_codecept_run}/codecept.require.multiple.several.js default`, (err, stdout) => {
-        stdout.should.include(moduleOutput);
-        stdout.should.include(moduleOutput2);
-        (stdout.match(new RegExp(moduleOutput, 'g')) || []).should.have.lengthOf(2);
-        (stdout.match(new RegExp(moduleOutput2, 'g')) || []).should.have.lengthOf(2);
-        assert(!err);
-        done();
-      });
-    });
+        stdout.should.include(moduleOutput)
+        stdout.should.include(moduleOutput2)
+        ;(stdout.match(new RegExp(moduleOutput, 'g')) || []).should.have.lengthOf(2)
+        ;(stdout.match(new RegExp(moduleOutput2, 'g')) || []).should.have.lengthOf(2)
+        assert(!err)
+        done()
+      })
+    })
 
     it('should not be executed without module when not described', (done) => {
-      process.chdir(codecept_dir);
+      process.chdir(codecept_dir)
       exec(`${runner} ${_codecept_run}/codecept.require.multiple.without.json default`, (err, stdout) => {
-        stdout.should.not.include(moduleOutput);
-        stdout.should.not.include(moduleOutput2);
-        assert(!err);
-        done();
-      });
-    });
-  });
-});
+        stdout.should.not.include(moduleOutput)
+        stdout.should.not.include(moduleOutput2)
+        assert(!err)
+        done()
+      })
+    })
+  })
+})
diff --git a/test/runner/run_rerun_test.js b/test/runner/run_rerun_test.js
index 216061394..75511583a 100644
--- a/test/runner/run_rerun_test.js
+++ b/test/runner/run_rerun_test.js
@@ -1,92 +1,99 @@
-const { expect } = require('expect');
-const { describe } = require('mocha');
-const path = require('path');
-const exec = require('child_process').exec;
-const semver = require('semver');
+const { expect } = require('expect')
+const { describe } = require('mocha')
+const path = require('path')
+const exec = require('child_process').exec
+const semver = require('semver')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/run-rerun/');
-const codecept_run = `${runner} run-rerun`;
-const codecept_run_config = (config, grep) => `${codecept_run} --config ${codecept_dir}/${config} --grep "${grep || ''}"`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/run-rerun/')
+const codecept_run = `${runner} run-rerun`
+const codecept_run_config = (config, grep) =>
+  `${codecept_run} --config ${codecept_dir}/${config} --grep "${grep || ''}"`
 
 describe('run-rerun command', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('should display count of attemps', (done) => {
     exec(`${codecept_run_config('codecept.conf.js')} --debug`, (err, stdout) => {
-      const runs = stdout.split('Run Rerun - Command --');
+      const runs = stdout.split('Run Rerun - Command --')
 
       // check first run
-      expect(runs[1]).toContain('OK  | 1 passed');
-      expect(runs[1]).toContain('✔ OK');
+      expect(runs[1]).toContain('OK  | 1 passed')
+      expect(runs[1]).toContain('✔ OK')
 
       // check second run
-      expect(runs[2]).toContain('OK  | 1 passed');
-      expect(runs[2]).toContain('✔ OK');
+      expect(runs[2]).toContain('OK  | 1 passed')
+      expect(runs[2]).toContain('✔ OK')
 
       // check third run
-      expect(runs[2]).toContain('OK  | 1 passed');
-      expect(runs[2]).toContain('✔ OK');
+      expect(runs[2]).toContain('OK  | 1 passed')
+      expect(runs[2]).toContain('✔ OK')
 
-      expect(stdout).toContain('Process run 1 of max 3, success runs 1/3');
-      expect(stdout).toContain('Process run 2 of max 3, success runs 2/3');
-      expect(stdout).toContain('Process run 3 of max 3, success runs 3/3');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(err).toBeNull();
-      done();
-    });
-  });
+      expect(stdout).toContain('Process run 1 of max 3, success runs 1/3')
+      expect(stdout).toContain('Process run 2 of max 3, success runs 2/3')
+      expect(stdout).toContain('Process run 3 of max 3, success runs 3/3')
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(err).toBeNull()
+      done()
+    })
+  })
 
   it('should display 2 success count of attemps', (done) => {
     exec(`${codecept_run_config('codecept.conf.min_less_max.js')} --debug`, (err, stdout) => {
-      const runs = stdout.split('Run Rerun - Command --');
+      const runs = stdout.split('Run Rerun - Command --')
 
       // check first run
-      expect(runs[2]).toContain('OK  | 1 passed');
-      expect(runs[2]).toContain('✔ OK');
+      expect(runs[2]).toContain('OK  | 1 passed')
+      expect(runs[2]).toContain('✔ OK')
 
       // check second run
-      expect(runs[2]).toContain('OK  | 1 passed');
-      expect(runs[2]).toContain('✔ OK');
+      expect(runs[2]).toContain('OK  | 1 passed')
+      expect(runs[2]).toContain('✔ OK')
 
-      expect(stdout).toContain('Process run 1 of max 3, success runs 1/2');
-      expect(stdout).toContain('Process run 2 of max 3, success runs 2/2');
-      expect(stdout).not.toContain('Process run 3 of max 3');
-      expect(stdout).toContain('OK  | 1 passed');
-      expect(err).toBeNull();
-      done();
-    });
-  });
+      expect(stdout).toContain('Process run 1 of max 3, success runs 1/2')
+      expect(stdout).toContain('Process run 2 of max 3, success runs 2/2')
+      expect(stdout).not.toContain('Process run 3 of max 3')
+      expect(stdout).toContain('OK  | 1 passed')
+      expect(err).toBeNull()
+      done()
+    })
+  })
 
   it('should display error if minSuccess more than maxReruns', (done) => {
     exec(`${codecept_run_config('codecept.conf.min_more_max.js')} --debug`, (err, stdout) => {
-      expect(stdout).toContain('minSuccess must be less than maxReruns');
-      expect(err.code).toBe(1);
-      done();
-    });
-  });
+      expect(stdout).toContain('minSuccess must be less than maxReruns')
+      expect(err.code).toBe(1)
+      done()
+    })
+  })
 
   it('should display errors if test is fail always', (done) => {
-    exec(`${codecept_run_config('codecept.conf.fail_test.js', '@RunRerun - Fail all attempt')} --debug`, (err, stdout) => {
-      expect(stdout).toContain('Fail run 1 of max 3, success runs 0/2');
-      expect(stdout).toContain('Fail run 2 of max 3, success runs 0/2');
-      expect(stdout).toContain('Fail run 3 of max 3, success runs 0/2');
-      expect(stdout).toContain('Flaky tests detected!');
-      expect(err.code).toBe(1);
-      done();
-    });
-  });
+    exec(
+      `${codecept_run_config('codecept.conf.fail_test.js', '@RunRerun - Fail all attempt')} --debug`,
+      (err, stdout) => {
+        expect(stdout).toContain('Fail run 1 of max 3, success runs 0/2')
+        expect(stdout).toContain('Fail run 2 of max 3, success runs 0/2')
+        expect(stdout).toContain('Fail run 3 of max 3, success runs 0/2')
+        expect(stdout).toContain('Flaky tests detected!')
+        expect(err.code).toBe(1)
+        done()
+      },
+    )
+  })
 
   it('should display success run if test was fail one time of two attepmts and 3 reruns', (done) => {
-    exec(`FAIL_ATTEMPT=0  ${codecept_run_config('codecept.conf.fail_test.js', '@RunRerun - fail second test')} --debug`, (err, stdout) => {
-      expect(stdout).toContain('Process run 1 of max 3, success runs 1/2');
-      expect(stdout).toContain('Fail run 2 of max 3, success runs 1/2');
-      expect(stdout).toContain('Process run 3 of max 3, success runs 2/2');
-      expect(stdout).not.toContain('Flaky tests detected!');
-      expect(err).toBeNull();
-      done();
-    });
-  });
-});
+    exec(
+      `FAIL_ATTEMPT=0  ${codecept_run_config('codecept.conf.fail_test.js', '@RunRerun - fail second test')} --debug`,
+      (err, stdout) => {
+        expect(stdout).toContain('Process run 1 of max 3, success runs 1/2')
+        expect(stdout).toContain('Fail run 2 of max 3, success runs 1/2')
+        expect(stdout).toContain('Process run 3 of max 3, success runs 2/2')
+        expect(stdout).not.toContain('Flaky tests detected!')
+        expect(err).toBeNull()
+        done()
+      },
+    )
+  })
+})
diff --git a/test/runner/run_workers_test.js b/test/runner/run_workers_test.js
index ccd1afe99..063b3d889 100644
--- a/test/runner/run_workers_test.js
+++ b/test/runner/run_workers_test.js
@@ -1,207 +1,207 @@
-const { expect } = require('expect');
-const path = require('path');
-const exec = require('child_process').exec;
-const semver = require('semver');
+const { expect } = require('expect')
+const path = require('path')
+const exec = require('child_process').exec
+const semver = require('semver')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run-workers --config ${codecept_dir}/codecept.workers.conf.js `;
-const codecept_run_glob = config => `${runner} run-workers --config ${codecept_dir}/${config} `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run-workers --config ${codecept_dir}/codecept.workers.conf.js `
+const codecept_run_glob = (config) => `${runner} run-workers --config ${codecept_dir}/${config} `
 
 describe('CodeceptJS Workers Runner', function () {
-  this.timeout(40000);
+  this.timeout(40000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should run tests in 3 workers', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
-    console.log(`${codecept_run} 3 --debug`);
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
+    console.log(`${codecept_run} 3 --debug`)
     exec(`${codecept_run} 3 --debug`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('glob current dir');
-      expect(stdout).toContain('From worker @1_grep print message 1');
-      expect(stdout).toContain('From worker @2_grep print message 2');
-      expect(stdout).toContain('Running tests in 3 workers');
-      expect(stdout).not.toContain('this is running inside worker');
-      expect(stdout).toContain('failed');
-      expect(stdout).toContain('File notafile not found');
-      expect(stdout).toContain('Scenario Steps:');
-      expect(err.code).toEqual(1);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('glob current dir')
+      expect(stdout).toContain('From worker @1_grep print message 1')
+      expect(stdout).toContain('From worker @2_grep print message 2')
+      expect(stdout).toContain('Running tests in 3 workers')
+      expect(stdout).not.toContain('this is running inside worker')
+      expect(stdout).toContain('failed')
+      expect(stdout).toContain('File notafile not found')
+      expect(stdout).toContain('Scenario Steps:')
+      expect(err.code).toEqual(1)
+      done()
+    })
+  })
 
   it('should print correct FAILURES in 3 workers without --debug', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 3`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('glob current dir');
-      expect(stdout).toContain('From worker @1_grep print message 1');
-      expect(stdout).toContain('From worker @2_grep print message 2');
-      expect(stdout).toContain('Running tests in 3 workers');
-      expect(stdout).not.toContain('this is running inside worker');
-      expect(stdout).toContain('failed');
-      expect(stdout).toContain('File notafile not found');
-      expect(stdout).toContain('Scenario Steps:');
-      expect(stdout).toContain('FAIL  | 5 passed, 2 failed');
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('glob current dir')
+      expect(stdout).toContain('From worker @1_grep print message 1')
+      expect(stdout).toContain('From worker @2_grep print message 2')
+      expect(stdout).toContain('Running tests in 3 workers')
+      expect(stdout).not.toContain('this is running inside worker')
+      expect(stdout).toContain('failed')
+      expect(stdout).toContain('File notafile not found')
+      expect(stdout).toContain('Scenario Steps:')
+      expect(stdout).toContain('FAIL  | 5 passed, 2 failed')
       // We are not testing order in logs, because it depends on race condition between workers
-      expect(stdout).toContain(') Workers Failing\n'); // first fail log
-      expect(stdout).toContain(') Workers\n'); // second fail log
+      expect(stdout).toContain(') Workers Failing\n') // first fail log
+      expect(stdout).toContain(') Workers\n') // second fail log
       // We just should be sure numbers are correct
-      expect(stdout).toContain('1) '); // first fail log
-      expect(stdout).toContain('2) '); // second fail log
-      expect(err.code).toEqual(1);
-      done();
-    });
-  });
+      expect(stdout).toContain('1) ') // first fail log
+      expect(stdout).toContain('2) ') // second fail log
+      expect(err.code).toEqual(1)
+      done()
+    })
+  })
 
   it('should print positive or zero failures with same name tests', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run_glob('configs/workers/codecept.workers-negative.conf.js')} 2`, (err, stdout) => {
-      expect(stdout).toContain('Running tests in 2 workers...');
+      expect(stdout).toContain('Running tests in 2 workers...')
       // check negative number without checking specified negative number
-      expect(stdout).not.toContain('FAIL  | 2 passed, -');
+      expect(stdout).not.toContain('FAIL  | 2 passed, -')
       // check we have positive failures
       // TODO: "10 failed" - probably bug, but not in logs.
       //  CodeceptJS starts 12 tests in this case, but now we can see this executions in logs.
-      expect(stdout).toContain('FAIL  | 2 passed, 10 failed');
-      expect(err).not.toBe(null);
-      done();
-    });
-  });
+      expect(stdout).toContain('FAIL  | 2 passed, 10 failed')
+      expect(err).not.toBe(null)
+      done()
+    })
+  })
 
   it('should use grep', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 2 --grep "grep"`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).not.toContain('glob current dir');
-      expect(stdout).toContain('From worker @1_grep print message 1');
-      expect(stdout).toContain('From worker @2_grep print message 2');
-      expect(stdout).toContain('Running tests in 2 workers');
-      expect(stdout).not.toContain('this is running inside worker');
-      expect(stdout).not.toContain('failed');
-      expect(stdout).not.toContain('File notafile not found');
-      expect(err).toEqual(null);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).not.toContain('glob current dir')
+      expect(stdout).toContain('From worker @1_grep print message 1')
+      expect(stdout).toContain('From worker @2_grep print message 2')
+      expect(stdout).toContain('Running tests in 2 workers')
+      expect(stdout).not.toContain('this is running inside worker')
+      expect(stdout).not.toContain('failed')
+      expect(stdout).not.toContain('File notafile not found')
+      expect(err).toEqual(null)
+      done()
+    })
+  })
 
   it('should use suites', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 2 --suites`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('Running tests in 2 workers'); // feature
-      expect(stdout).toContain('glob current dir');
-      expect(stdout).toContain('From worker @1_grep print message 1');
-      expect(stdout).toContain('From worker @2_grep print message 2');
-      expect(stdout).not.toContain('this is running inside worker');
-      expect(err.code).toEqual(1);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('Running tests in 2 workers') // feature
+      expect(stdout).toContain('glob current dir')
+      expect(stdout).toContain('From worker @1_grep print message 1')
+      expect(stdout).toContain('From worker @2_grep print message 2')
+      expect(stdout).not.toContain('this is running inside worker')
+      expect(err.code).toEqual(1)
+      done()
+    })
+  })
 
   it('should show failures when suite is failing', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 2 --grep "Workers Failing"`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('Running tests in 2 workers');
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('Running tests in 2 workers')
       // Test Scenario wasn't executed, but we can see it in logs because Before() hook was executed
-      expect(stdout).not.toContain(' should not be executed ');
-      expect(stdout).toContain('"before each" hook: Before for "should not be executed"');
-      expect(stdout).not.toContain('this is running inside worker');
-      expect(stdout).toContain('failed');
-      expect(stdout).toContain('FAILURES');
-      expect(stdout).toContain('Workers Failing');
+      expect(stdout).not.toContain(' should not be executed ')
+      expect(stdout).toContain('"before each" hook: Before for "should not be executed"')
+      expect(stdout).not.toContain('this is running inside worker')
+      expect(stdout).toContain('failed')
+      expect(stdout).toContain('FAILURES')
+      expect(stdout).toContain('Workers Failing')
       // Only 1 test is executed - Before hook in Workers Failing
-      expect(stdout).toContain('✖ Workers Failing');
-      expect(stdout).toContain('FAIL  | 0 passed, 1 failed');
-      expect(err.code).toEqual(1);
-      done();
-    });
-  });
+      expect(stdout).toContain('✖ Workers Failing')
+      expect(stdout).toContain('FAIL  | 0 passed, 1 failed')
+      expect(err.code).toEqual(1)
+      done()
+    })
+  })
 
   it('should print stdout in debug mode and load bootstrap', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 1 --grep "grep" --debug`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('Running tests in 1 workers');
-      expect(stdout).toContain('bootstrap b1+b2');
-      expect(stdout).toContain('message 1');
-      expect(stdout).toContain('message 2');
-      expect(stdout).toContain('see this is worker');
-      expect(err).toEqual(null);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('Running tests in 1 workers')
+      expect(stdout).toContain('bootstrap b1+b2')
+      expect(stdout).toContain('message 1')
+      expect(stdout).toContain('message 2')
+      expect(stdout).toContain('see this is worker')
+      expect(err).toEqual(null)
+      done()
+    })
+  })
 
   it('should run tests with glob pattern', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run_glob('codecept.workers-glob.conf.js')} 1 --grep "grep" --debug`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('Running tests in 1 workers');
-      expect(stdout).toContain('bootstrap b1+b2');
-      expect(stdout).toContain('message 1');
-      expect(stdout).toContain('message 2');
-      expect(stdout).toContain('see this is worker');
-      expect(err).toEqual(null);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('Running tests in 1 workers')
+      expect(stdout).toContain('bootstrap b1+b2')
+      expect(stdout).toContain('message 1')
+      expect(stdout).toContain('message 2')
+      expect(stdout).toContain('see this is worker')
+      expect(err).toEqual(null)
+      done()
+    })
+  })
 
   it('should print empty results with incorrect glob pattern', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run_glob('codecept.workers-incorrect-glob.conf.js')} 1 --grep "grep" --debug`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('Running tests in 1 workers');
-      expect(stdout).toContain('OK  | 0 passed');
-      expect(err).toEqual(null);
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('Running tests in 1 workers')
+      expect(stdout).toContain('OK  | 0 passed')
+      expect(err).toEqual(null)
+      done()
+    })
+  })
 
   it('should retry test', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run} 2 --grep "retry"`, (err, stdout) => {
-      expect(stdout).toContain('CodeceptJS'); // feature
-      expect(stdout).toContain('OK  | 1 passed');
-      done();
-    });
-  });
+      expect(stdout).toContain('CodeceptJS') // feature
+      expect(stdout).toContain('OK  | 1 passed')
+      done()
+    })
+  })
 
   it('should create output folder with custom name', function (done) {
-    const fs = require('fs');
-    const customName = 'thisIsCustomOutputFolderName';
-    const outputDir = `${codecept_dir}/${customName}`;
-    let createdOutput = false;
+    const fs = require('fs')
+    const customName = 'thisIsCustomOutputFolderName'
+    const outputDir = `${codecept_dir}/${customName}`
+    let createdOutput = false
 
     if (fs.existsSync(outputDir)) {
-      fs.rmdirSync(outputDir, { recursive: true });
+      fs.rmdirSync(outputDir, { recursive: true })
     }
 
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
-    const configFileName = 'codecept.workers-custom-output-folder-name.conf.js';
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
+    const configFileName = 'codecept.workers-custom-output-folder-name.conf.js'
     exec(`${codecept_run_glob(configFileName)} 2 --grep "grep" --debug`, (err, stdout) => {
-      expect(stdout).toContain(customName);
+      expect(stdout).toContain(customName)
       if (fs.existsSync(outputDir)) {
-        createdOutput = true;
+        createdOutput = true
       }
-      expect(createdOutput).toEqual(true);
-      expect(err).toEqual(null);
-      done();
-    });
-  });
+      expect(createdOutput).toEqual(true)
+      expect(err).toEqual(null)
+      done()
+    })
+  })
 
   it('should exit code 1 when error in config', function (done) {
-    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version');
+    if (!semver.satisfies(process.version, '>=11.7.0')) this.skip('not for node version')
     exec(`${codecept_run_glob('configs/codecept-invalid.config.js')} 2`, (err, stdout, stderr) => {
-      expect(stdout).not.toContain('UnhandledPromiseRejectionWarning');
-      expect(stderr).not.toContain('UnhandledPromiseRejectionWarning');
-      expect(stdout).toContain('badFn is not defined');
-      expect(err).not.toBe(null);
-
-      done();
-    });
-  });
-});
+      expect(stdout).not.toContain('UnhandledPromiseRejectionWarning')
+      expect(stderr).not.toContain('UnhandledPromiseRejectionWarning')
+      expect(stdout).toContain('badFn is not defined')
+      expect(err).not.toBe(null)
+
+      done()
+    })
+  })
+})
diff --git a/test/runner/scenario_stale_test.js b/test/runner/scenario_stale_test.js
index 927d92acd..6c149c610 100644
--- a/test/runner/scenario_stale_test.js
+++ b/test/runner/scenario_stale_test.js
@@ -1,22 +1,22 @@
-const { expect } = require('expect');
-const path = require('path');
-const { exec } = require('child_process');
+const { expect } = require('expect')
+const path = require('path')
+const { exec } = require('child_process')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run`;
-const config_run_config = config => `${codecept_run} --config ${codecept_dir}/${config}`;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run`
+const config_run_config = (config) => `${codecept_run} --config ${codecept_dir}/${config}`
 
 describe('Scenario termination check', () => {
   before(() => {
-    process.chdir(codecept_dir);
-  });
+    process.chdir(codecept_dir)
+  })
 
   it('Should always fail and terminate', (done) => {
     exec(config_run_config('codecept.scenario-stale.js'), (err, stdout) => {
-      expect(stdout).toContain('should not stale scenario error'); // feature
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
-});
+      expect(stdout).toContain('should not stale scenario error') // feature
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/session_test.js b/test/runner/session_test.js
index d9e9132f7..9d92ce2f3 100644
--- a/test/runner/session_test.js
+++ b/test/runner/session_test.js
@@ -1,70 +1,76 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const { grepLines } = require('../../lib/utils').test;
+const path = require('path')
+const exec = require('child_process').exec
+const { grepLines } = require('../../lib/utils').test
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.session.json `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.session.json `
 
 describe('CodeceptJS session', function () {
-  this.timeout(40000);
+  this.timeout(40000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should run with 3 sessions', (done) => {
     exec(`${codecept_run} --steps --grep "@1"`, (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const list = grepLines(lines, 'basic session @1');
-      list.pop();
-      testStatus = list.pop();
-      testStatus.should.include('OK');
-      list.should.eql([
-        'I do "writing"',
-        'davert: I do "reading"',
-        'I do "playing"',
-        'john: I do "crying"',
-        'davert: I do "smiling"',
-        'I do "laughing"',
-        'mike: I do "spying"',
-        'john: I do "lying"',
-        'I do "waving"',
-      ], 'check steps execution order');
-      done();
-    });
-  });
+      const list = grepLines(lines, 'basic session @1')
+      list.pop()
+      testStatus = list.pop()
+      testStatus.should.include('OK')
+      list.should.eql(
+        [
+          'I do "writing"',
+          'davert: I do "reading"',
+          'I do "playing"',
+          'john: I do "crying"',
+          'davert: I do "smiling"',
+          'I do "laughing"',
+          'mike: I do "spying"',
+          'john: I do "lying"',
+          'I do "waving"',
+        ],
+        'check steps execution order',
+      )
+      done()
+    })
+  })
 
   it('should run session defined before executing', (done) => {
     exec(`${codecept_run} --steps --grep "@2"`, (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const list = grepLines(lines, 'session defined not used @2');
-      list.pop();
-      testStatus = list.pop();
-      testStatus.should.include('OK');
+      const list = grepLines(lines, 'session defined not used @2')
+      list.pop()
+      testStatus = list.pop()
+      testStatus.should.include('OK')
 
-      list.should.eql([
-        'I do "writing"',
-        'I do "playing"',
-        'john: I do "crying"',
-        'davert: I do "smiling"',
-        'I do "laughing"',
-        'davert: I do "singing"',
-        'I do "waving"',
-      ], 'check steps execution order');
-      done();
-    });
-  });
+      list.should.eql(
+        [
+          'I do "writing"',
+          'I do "playing"',
+          'john: I do "crying"',
+          'davert: I do "smiling"',
+          'I do "laughing"',
+          'davert: I do "singing"',
+          'I do "waving"',
+        ],
+        'check steps execution order',
+      )
+      done()
+    })
+  })
 
   it('should run all session tests', (done) => {
     exec(`${codecept_run} --steps`, (err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
-      const testStatus = lines.pop();
-      testStatus.should.include('passed');
-      testStatus.should.not.include(' 1 ', 'more than 1 test expected');
-      done();
-    });
-  });
-});
+      const lines = stdout.match(/\S.+/g)
+      const testStatus = lines.pop()
+      testStatus.should.include('passed')
+      testStatus.should.not.include(' 1 ', 'more than 1 test expected')
+      done()
+    })
+  })
+})
diff --git a/test/runner/skip_test.js b/test/runner/skip_test.js
index cb63d79b8..5acbd4362 100644
--- a/test/runner/skip_test.js
+++ b/test/runner/skip_test.js
@@ -1,28 +1,28 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const assert = require('assert');
+const path = require('path')
+const exec = require('child_process').exec
+const assert = require('assert')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/skip');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/skip')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `
 
 describe('Skip', () => {
   it('should skip test with skip', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('S @skip');
-      stdout.should.include('S @skip with opts');
-      stdout.should.not.include('skip test not passed');
-      stdout.should.include('✔ @NotSkip in');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('S @skip')
+      stdout.should.include('S @skip with opts')
+      stdout.should.not.include('skip test not passed')
+      stdout.should.include('✔ @NotSkip in')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should correctly pass custom opts for skip test', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('test @skip with opts was marked for skip with customOpts: "Custom options for skip"');
-      assert(!err);
-      done();
-    });
-  });
-});
+      stdout.should.include('test @skip with opts was marked for skip with customOpts: "Custom options for skip"')
+      assert(!err)
+      done()
+    })
+  })
+})
diff --git a/test/runner/step_timeout_test.js b/test/runner/step_timeout_test.js
index 76bf78b2d..649810ab7 100644
--- a/test/runner/step_timeout_test.js
+++ b/test/runner/step_timeout_test.js
@@ -1,66 +1,67 @@
-const { expect } = require('expect');
-const exec = require('child_process').exec;
-const { codecept_dir, codecept_run } = require('./consts');
+const { expect } = require('expect')
+const exec = require('child_process').exec
+const { codecept_dir, codecept_run } = require('./consts')
 
-const debug_this_test = false;
+const debug_this_test = false
 
-const config_run_config = (config, grep, verbose = false) => `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/step_timeout/${config} ${grep ? `--grep "${grep}"` : ''}`;
+const config_run_config = (config, grep, verbose = false) =>
+  `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/step_timeout/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS Steps', function () {
-  this.timeout(5000);
+  this.timeout(5000)
 
   it('should stop test, when step timeout exceeded', (done) => {
     exec(config_run_config('codecept-1000.conf.js', 'Default command timeout'), (err, stdout) => {
-      expect(stdout).toContain('Action exceededByTimeout: 1500 was interrupted on step timeout 1000ms');
-      expect(stdout).toContain('0 passed, 1 failed');
-      expect(stdout).toContain('- I.exceededByTimeout(1500)');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Action exceededByTimeout: 1500 was interrupted on step timeout 1000ms')
+      expect(stdout).toContain('0 passed, 1 failed')
+      expect(stdout).toContain('- I.exceededByTimeout(1500)')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should respect custom timeout with regex', (done) => {
     exec(config_run_config('codecept-1000.conf.js', 'Wait with longer timeout', debug_this_test), (err, stdout) => {
-      expect(stdout).not.toContain('was interrupted on step timeout');
-      expect(stdout).toContain('1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).not.toContain('was interrupted on step timeout')
+      expect(stdout).toContain('1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should respect custom timeout with full step name', (done) => {
     exec(config_run_config('codecept-1000.conf.js', 'Wait with shorter timeout', debug_this_test), (err, stdout) => {
-      expect(stdout).toContain('Action waitTadShorter: 750 was interrupted on step timeout 500ms');
-      expect(stdout).toContain('0 passed, 1 failed');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      expect(stdout).toContain('Action waitTadShorter: 750 was interrupted on step timeout 500ms')
+      expect(stdout).toContain('0 passed, 1 failed')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should not stop test, when step not exceeded', (done) => {
     exec(config_run_config('codecept-2000.conf.js', 'Default command timeout'), (err, stdout) => {
-      expect(stdout).not.toContain('was interrupted on step timeout');
-      expect(stdout).toContain('1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).not.toContain('was interrupted on step timeout')
+      expect(stdout).toContain('1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should ignore timeout for steps with `wait*` prefix', (done) => {
     exec(config_run_config('codecept-1000.conf.js', 'Wait command timeout'), (err, stdout) => {
-      expect(stdout).not.toContain('was interrupted on step timeout');
-      expect(stdout).toContain('1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      expect(stdout).not.toContain('was interrupted on step timeout')
+      expect(stdout).toContain('1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('step timeout should work nicely with step retries', (done) => {
     exec(config_run_config('codecept-1000.conf.js', 'Rerun sleep'), (err, stdout) => {
-      expect(stdout).not.toContain('was interrupted on step timeout');
-      expect(stdout).toContain('1 passed');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
-});
+      expect(stdout).not.toContain('was interrupted on step timeout')
+      expect(stdout).toContain('1 passed')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/timeout_test.js b/test/runner/timeout_test.js
index 8e14efc09..fd79971a9 100644
--- a/test/runner/timeout_test.js
+++ b/test/runner/timeout_test.js
@@ -1,97 +1,98 @@
-const { expect } = require('expect');
-const exec = require('child_process').exec;
-const { codecept_dir, codecept_run } = require('./consts');
+const { expect } = require('expect')
+const exec = require('child_process').exec
+const { codecept_dir, codecept_run } = require('./consts')
 
-const debug_this_test = false;
+const debug_this_test = false
 
-const config_run_config = (config, grep, verbose = false) => `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/timeouts/${config} ${grep ? `--grep "${grep}"` : ''}`;
+const config_run_config = (config, grep, verbose = false) =>
+  `${codecept_run} ${verbose || debug_this_test ? '--verbose' : ''} --config ${codecept_dir}/configs/timeouts/${config} ${grep ? `--grep "${grep}"` : ''}`
 
 describe('CodeceptJS Timeouts', function () {
-  this.timeout(10000);
+  this.timeout(10000)
 
   it('should stop test when timeout exceeded', (done) => {
     exec(config_run_config('codecept.conf.js', 'timed out'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('Timeout 2s exceeded');
-      expect(stdout).toContain('Timeout 1s exceeded');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('Timeout 2s exceeded')
+      expect(stdout).toContain('Timeout 1s exceeded')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should take --no-timeouts option', (done) => {
     exec(`${config_run_config('codecept.conf.js', 'timed out')} --no-timeouts`, (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('Timeouts were disabled');
-      expect(stdout).not.toContain('Timeout 2s exceeded');
-      expect(stdout).not.toContain('Timeout 1s exceeded');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('Timeouts were disabled')
+      expect(stdout).not.toContain('Timeout 2s exceeded')
+      expect(stdout).not.toContain('Timeout 1s exceeded')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should ignore timeouts if no timeout', (done) => {
     exec(config_run_config('codecept.conf.js', 'no timeout test'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).not.toContain('Timeout');
-      expect(err).toBeFalsy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).not.toContain('Timeout')
+      expect(err).toBeFalsy()
+      done()
+    })
+  })
 
   it('should use global timeouts if timeout is set', (done) => {
     exec(config_run_config('codecept.timeout.conf.js', 'no timeout test'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('Timeout 0.1');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('Timeout 0.1')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should prefer step timeout', (done) => {
     exec(config_run_config('codecept.conf.js', 'timeout step', true), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('was interrupted on step timeout 100ms');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('was interrupted on step timeout 100ms')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should keep timeout with steps', (done) => {
     exec(config_run_config('codecept.timeout.conf.js', 'timeout step', true), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('was interrupted on step timeout 100ms');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('was interrupted on step timeout 100ms')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should override timeout config from global object', (done) => {
     exec(config_run_config('codecept.timeout.obj.conf.js', '#first', false), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).toContain('Timeout 0.3s exceeded');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).toContain('Timeout 0.3s exceeded')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should override timeout config from global object but respect local value', (done) => {
     exec(config_run_config('codecept.timeout.obj.conf.js', '#second'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).not.toContain('Timeout 0.3s exceeded');
-      expect(stdout).toContain('Timeout 0.5s exceeded');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
+      debug_this_test && console.log(stdout)
+      expect(stdout).not.toContain('Timeout 0.3s exceeded')
+      expect(stdout).toContain('Timeout 0.5s exceeded')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
 
   it('should respect grep when overriding config from global config', (done) => {
     exec(config_run_config('codecept.timeout.obj.conf.js', '#fourth'), (err, stdout) => {
-      debug_this_test && console.log(stdout);
-      expect(stdout).not.toContain('Timeout 0.3s exceeded');
-      expect(stdout).toContain('Timeout 1s exceeded');
-      expect(err).toBeTruthy();
-      done();
-    });
-  });
-});
+      debug_this_test && console.log(stdout)
+      expect(stdout).not.toContain('Timeout 0.3s exceeded')
+      expect(stdout).toContain('Timeout 1s exceeded')
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
+})
diff --git a/test/runner/todo_test.js b/test/runner/todo_test.js
index 4ca8a4e59..56f286039 100644
--- a/test/runner/todo_test.js
+++ b/test/runner/todo_test.js
@@ -1,38 +1,38 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const assert = require('assert');
+const path = require('path')
+const exec = require('child_process').exec
+const assert = require('assert')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/todo');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/todo')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `
 
 describe('Todo', () => {
   it('should skip test with todo', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('S @todo');
-      stdout.should.include('S @todo without function');
-      stdout.should.not.include('todo test not passed');
-      stdout.should.include('✔ @NotTodo in');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('S @todo')
+      stdout.should.include('S @todo without function')
+      stdout.should.not.include('todo test not passed')
+      stdout.should.include('✔ @NotTodo in')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should skip inject skipinfo to todo test', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('test @todo was marked for todo with message: Test not implemented!');
-      stdout.should.include('test @todo without function was marked for todo with message: Test not implemented!');
-      stdout.should.not.include('test @NotTodo was marked for todo with message: Test not implemented!');
-      assert(!err);
-      done();
-    });
-  });
+      stdout.should.include('test @todo was marked for todo with message: Test not implemented!')
+      stdout.should.include('test @todo without function was marked for todo with message: Test not implemented!')
+      stdout.should.not.include('test @NotTodo was marked for todo with message: Test not implemented!')
+      assert(!err)
+      done()
+    })
+  })
 
   it('should correctly pass custom opts for todo test', (done) => {
     exec(`${codecept_run}`, (err, stdout) => {
-      stdout.should.include('test @todo with opts was marked for todo with customOpts: "Custom options for todo"');
-      assert(!err);
-      done();
-    });
-  });
-});
+      stdout.should.include('test @todo with opts was marked for todo with customOpts: "Custom options for todo"')
+      assert(!err)
+      done()
+    })
+  })
+})
diff --git a/test/runner/translation_test.js b/test/runner/translation_test.js
index ca8e22189..5c5784f40 100644
--- a/test/runner/translation_test.js
+++ b/test/runner/translation_test.js
@@ -1,16 +1,16 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const assert = require('assert');
+const path = require('path')
+const exec = require('child_process').exec
+const assert = require('assert')
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/translation');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/translation')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.js `
 
 describe('Translation', () => {
   it('Should run translated test file', (done) => {
     exec(`${codecept_run}`, (err) => {
-      assert(!err);
-      done();
-    });
-  });
-});
+      assert(!err)
+      done()
+    })
+  })
+})
diff --git a/test/runner/within_test.js b/test/runner/within_test.js
index 430ed77a6..56229b6ae 100644
--- a/test/runner/within_test.js
+++ b/test/runner/within_test.js
@@ -1,87 +1,108 @@
-const path = require('path');
-const exec = require('child_process').exec;
-const { grepLines } = require('../../lib/utils').test;
+const path = require('path')
+const exec = require('child_process').exec
+const { grepLines } = require('../../lib/utils').test
 
-const runner = path.join(__dirname, '/../../bin/codecept.js');
-const codecept_dir = path.join(__dirname, '/../data/sandbox');
-const codecept_run = `${runner} run --config ${codecept_dir}/codecept.within.json `;
+const runner = path.join(__dirname, '/../../bin/codecept.js')
+const codecept_dir = path.join(__dirname, '/../data/sandbox')
+const codecept_run = `${runner} run --config ${codecept_dir}/codecept.within.json `
 
-let testStatus;
+let testStatus
 
 describe('CodeceptJS within', function () {
-  this.timeout(40000);
+  this.timeout(40000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should execute if no generators', (done) => {
     exec(`${codecept_run} --debug`, (_err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const withoutGeneratorList = grepLines(lines, 'Check within without generator', 'Check within with generator. Yield is first in order');
-      testStatus = withoutGeneratorList.pop();
-      testStatus.should.include('OK');
-      withoutGeneratorList.should.eql([
-        'I small promise ',
-        'I small promise was finished ',
-        'I hey! i am within begin. i get blabla ',
-        'Within "blabla" ""',
-        'I small promise ',
-        'I small promise was finished ',
-        'I oh! i am within end( ',
-      ], 'check steps execution order');
-      done();
-    });
-  });
+      const withoutGeneratorList = grepLines(
+        lines,
+        'Check within without generator',
+        'Check within with generator. Yield is first in order',
+      )
+      testStatus = withoutGeneratorList.pop()
+      testStatus.should.include('OK')
+      withoutGeneratorList.should.eql(
+        [
+          'I small promise ',
+          'I small promise was finished ',
+          'I hey! i am within begin. i get blabla ',
+          'Within "blabla" ""',
+          'I small promise ',
+          'I small promise was finished ',
+          'I oh! i am within end( ',
+        ],
+        'check steps execution order',
+      )
+      done()
+    })
+  })
 
   it('should execute with async/await. Await is first in order', (done) => {
     exec(`${codecept_run} --debug`, (_err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const withGeneratorList = grepLines(lines, 'Check within with async/await. Await is first in order', 'Check within with async/await. Await is second in order');
-      testStatus = withGeneratorList.pop();
-      testStatus.should.include('OK');
-      withGeneratorList.should.eql([
-        'I small promise ',
-        'I small promise was finished ',
-        'I small yield ',
-        'I am small yield string await',
-        'I hey! i am within begin. i get blabla ',
-        'Within "blabla" ""',
-        'I small yield ',
-        'I am small yield string await',
-        'I small promise ',
-        'I small promise was finished ',
-        'I oh! i am within end( ',
-      ], 'check steps execution order');
+      const withGeneratorList = grepLines(
+        lines,
+        'Check within with async/await. Await is first in order',
+        'Check within with async/await. Await is second in order',
+      )
+      testStatus = withGeneratorList.pop()
+      testStatus.should.include('OK')
+      withGeneratorList.should.eql(
+        [
+          'I small promise ',
+          'I small promise was finished ',
+          'I small yield ',
+          'I am small yield string await',
+          'I hey! i am within begin. i get blabla ',
+          'Within "blabla" ""',
+          'I small yield ',
+          'I am small yield string await',
+          'I small promise ',
+          'I small promise was finished ',
+          'I oh! i am within end( ',
+        ],
+        'check steps execution order',
+      )
 
-      done();
-    });
-  });
+      done()
+    })
+  })
 
   it('should execute with async/await. Await is second in order', (done) => {
     exec(`${codecept_run} --debug`, (_err, stdout) => {
-      const lines = stdout.match(/\S.+/g);
+      const lines = stdout.match(/\S.+/g)
 
-      const withGeneratorList = grepLines(lines, 'Check within with async/await. Await is second in order', '-- FAILURES:');
-      testStatus = withGeneratorList.pop();
-      testStatus.should.include('OK');
-      withGeneratorList.should.eql([
-        'I small promise ',
-        'I small promise was finished ',
-        'I small yield ',
-        'I am small yield string await',
-        'I hey! i am within begin. i get blabla ',
-        'Within "blabla" ""',
-        'I small promise ',
-        'I small promise was finished ',
-        'I small yield ',
-        'I am small yield string await',
-        'I oh! i am within end( ',
-      ], 'check steps execution order');
+      const withGeneratorList = grepLines(
+        lines,
+        'Check within with async/await. Await is second in order',
+        '-- FAILURES:',
+      )
+      testStatus = withGeneratorList.pop()
+      testStatus.should.include('OK')
+      withGeneratorList.should.eql(
+        [
+          'I small promise ',
+          'I small promise was finished ',
+          'I small yield ',
+          'I am small yield string await',
+          'I hey! i am within begin. i get blabla ',
+          'Within "blabla" ""',
+          'I small promise ',
+          'I small promise was finished ',
+          'I small yield ',
+          'I am small yield string await',
+          'I oh! i am within end( ',
+        ],
+        'check steps execution order',
+      )
 
-      done();
-    });
-  });
-});
+      done()
+    })
+  })
+})
diff --git a/test/support/ScreenshotSessionHelper.js b/test/support/ScreenshotSessionHelper.js
index f7314731d..edc424494 100644
--- a/test/support/ScreenshotSessionHelper.js
+++ b/test/support/ScreenshotSessionHelper.js
@@ -1,31 +1,31 @@
-const Helper = codecept_helper;
+const Helper = codecept_helper
 
-const crypto = require('crypto');
-const fs = require('fs');
+const crypto = require('crypto')
+const fs = require('fs')
 
 class ScreenshotSessionHelper extends Helper {
   constructor(config) {
-    super(config);
-    this.outputPath = output_dir;
+    super(config)
+    this.outputPath = output_dir
   }
 
   getSHA256Digests(files = []) {
-    const digests = [];
+    const digests = []
 
     for (const file of files) {
-      const hash = crypto.createHash('sha256');
-      const data = fs.readFileSync(file);
-      hash.update(data);
+      const hash = crypto.createHash('sha256')
+      const data = fs.readFileSync(file)
+      hash.update(data)
 
-      digests.push(hash.digest('base64'));
+      digests.push(hash.digest('base64'))
     }
 
-    return digests;
+    return digests
   }
 
   getOutputPath() {
-    return this.outputPath;
+    return this.outputPath
   }
 }
 
-module.exports = ScreenshotSessionHelper;
+module.exports = ScreenshotSessionHelper
diff --git a/test/support/TestHelper.js b/test/support/TestHelper.js
index 91ef703d0..7e605fb20 100644
--- a/test/support/TestHelper.js
+++ b/test/support/TestHelper.js
@@ -1,35 +1,35 @@
 class TestHelper {
   static siteUrl() {
-    return (process.env.SITE_URL || 'http://localhost:8000');
+    return process.env.SITE_URL || 'http://localhost:8000'
   }
 
   static angularSiteUrl() {
-    return 'http://davertmik.github.io/angular-demo-app';
+    return 'http://davertmik.github.io/angular-demo-app'
   }
 
   static seleniumAddress() {
-    return `http://${this.seleniumHost()}:${this.seleniumPort()}/wd/hub`;
+    return `http://${this.seleniumHost()}:${this.seleniumPort()}/wd/hub`
   }
 
   static seleniumHost() {
-    return (process.env.SELENIUM_HOST || 'localhost');
+    return process.env.SELENIUM_HOST || 'localhost'
   }
 
   static seleniumPort() {
-    return parseInt(process.env.SELENIUM_PORT || '4444', 10);
+    return parseInt(process.env.SELENIUM_PORT || '4444', 10)
   }
 
   static jsonServerUrl() {
-    return (process.env.JSON_SERVER_URL || 'http://localhost:8010');
+    return process.env.JSON_SERVER_URL || 'http://localhost:8010'
   }
 
   static graphQLServerPort() {
-    return parseInt(process.env.GRAPHQL_SERVER_PORT || '8020', 10);
+    return parseInt(process.env.GRAPHQL_SERVER_PORT || '8020', 10)
   }
 
   static graphQLServerUrl() {
-    return (process.env.GRAPHQL_SERVER_URL || 'http://localhost:8020/graphql');
+    return process.env.GRAPHQL_SERVER_URL || 'http://localhost:8020/graphql'
   }
 }
 
-module.exports = TestHelper;
+module.exports = TestHelper
diff --git a/test/support/setup.js b/test/support/setup.js
index b2fb8495a..20ca8ac8a 100644
--- a/test/support/setup.js
+++ b/test/support/setup.js
@@ -1,3 +1,3 @@
-import('chai').then(chai => {
-  chai.should();
-});
+import('chai').then((chai) => {
+  chai.should()
+})
diff --git a/test/unit/actor_test.js b/test/unit/actor_test.js
index 2ed1557d1..24a1f859c 100644
--- a/test/unit/actor_test.js
+++ b/test/unit/actor_test.js
@@ -1,164 +1,170 @@
-const path = require('path');
-const { expect } = require('expect');
+const path = require('path')
+const { expect } = require('expect')
 
-const actor = require('../../lib/actor');
-const container = require('../../lib/container');
-const recorder = require('../../lib/recorder');
-const event = require('../../lib/event');
+const actor = require('../../lib/actor')
+const container = require('../../lib/container')
+const recorder = require('../../lib/recorder')
+const event = require('../../lib/event')
 
-global.codecept_dir = path.join(__dirname, '/..');
-let I;
-let counter;
+global.codecept_dir = path.join(__dirname, '/..')
+let I
+let counter
 
 describe('Actor', () => {
   beforeEach(() => {
-    counter = 0;
-    container.clear({
-      MyHelper: {
-        hello: () => 'hello world',
-        bye: () => 'bye world',
-        die: () => { throw new Error('ups'); },
-        _hidden: () => 'hidden',
-        failAfter: (i = 1) => {
-          counter++;
-          if (counter <= i) throw new Error('ups');
-          counter = 0;
+    counter = 0
+    container.clear(
+      {
+        MyHelper: {
+          hello: () => 'hello world',
+          bye: () => 'bye world',
+          die: () => {
+            throw new Error('ups')
+          },
+          _hidden: () => 'hidden',
+          failAfter: (i = 1) => {
+            counter++
+            if (counter <= i) throw new Error('ups')
+            counter = 0
+          },
+        },
+        MyHelper2: {
+          greeting: () => 'greetings, world',
         },
       },
-      MyHelper2: {
-        greeting: () => 'greetings, world',
-      },
-    }, undefined, undefined);
-    container.translation().vocabulary.actions.hello = 'привет';
-    I = actor();
-    event.cleanDispatcher();
-  });
+      undefined,
+      undefined,
+    )
+    container.translation().vocabulary.actions.hello = 'привет'
+    I = actor()
+    event.cleanDispatcher()
+  })
 
   it('should init actor on store', () => {
-    const store = require('../../lib/store');
-    expect(store.actor).toBeTruthy();
-  });
+    const store = require('../../lib/store')
+    expect(store.actor).toBeTruthy()
+  })
 
   it('should collect pageobject methods in actor', () => {
     const poI = actor({
       customStep: () => {},
-    });
-    expect(poI).toHaveProperty('customStep');
-    expect(I).toHaveProperty('customStep');
-  });
+    })
+    expect(poI).toHaveProperty('customStep')
+    expect(I).toHaveProperty('customStep')
+  })
 
   it('should correct run step from Helper inside PageObject', () => {
     actor({
       customStep() {
-        return this.hello();
+        return this.hello()
       },
-    });
-    recorder.start();
-    const promise = I.customStep();
-    return promise.then(val => expect(val).toEqual('hello world'));
-  });
+    })
+    recorder.start()
+    const promise = I.customStep()
+    return promise.then((val) => expect(val).toEqual('hello world'))
+  })
 
   it('should init pageobject methods as metastep', () => {
     actor({
       customStep: () => 3,
-    });
-    expect(I.customStep()).toEqual(3);
-  });
+    })
+    expect(I.customStep()).toEqual(3)
+  })
 
   it('should correct add translation for step from Helper', () => {
-    expect(I).toHaveProperty('привет');
-  });
+    expect(I).toHaveProperty('привет')
+  })
 
   it('should correct add translation for step from PageObject', () => {
-    container.translation().vocabulary.actions.customStep = 'кастомный_шаг';
+    container.translation().vocabulary.actions.customStep = 'кастомный_шаг'
     actor({
       customStep: () => 3,
-    });
-    expect(I).toHaveProperty('кастомный_шаг');
-  });
+    })
+    expect(I).toHaveProperty('кастомный_шаг')
+  })
 
   it('should take all methods from helpers and built in', () => {
-    ['hello', 'bye', 'die', 'failAfter', 'say', 'retry', 'greeting'].forEach(key => {
-      expect(I).toHaveProperty(key);
-    });
-  });
+    ;['hello', 'bye', 'die', 'failAfter', 'say', 'retry', 'greeting'].forEach((key) => {
+      expect(I).toHaveProperty(key)
+    })
+  })
 
   it('should return promise', () => {
-    recorder.start();
-    const promise = I.hello();
-    expect(promise).toBeInstanceOf(Promise);
-    return promise.then(val => expect(val).toEqual('hello world'));
-  });
+    recorder.start()
+    const promise = I.hello()
+    expect(promise).toBeInstanceOf(Promise)
+    return promise.then((val) => expect(val).toEqual('hello world'))
+  })
 
   it('should produce step events', () => {
-    recorder.start();
-    let listeners = 0;
-    event.dispatcher.addListener(event.step.before, () => listeners++);
-    event.dispatcher.addListener(event.step.after, () => listeners++);
+    recorder.start()
+    let listeners = 0
+    event.dispatcher.addListener(event.step.before, () => listeners++)
+    event.dispatcher.addListener(event.step.after, () => listeners++)
     event.dispatcher.addListener(event.step.passed, (step) => {
-      listeners++;
-      expect(step.endTime).toBeTruthy();
-      expect(step.startTime).toBeTruthy();
-    });
+      listeners++
+      expect(step.endTime).toBeTruthy()
+      expect(step.startTime).toBeTruthy()
+    })
 
     return I.hello().then(() => {
-      expect(listeners).toEqual(3);
-    });
-  });
+      expect(listeners).toEqual(3)
+    })
+  })
 
   it('should retry failed step with #retry', () => {
-    recorder.start();
-    return I.retry({ retries: 2, minTimeout: 0 }).failAfter(1);
-  });
+    recorder.start()
+    return I.retry({ retries: 2, minTimeout: 0 }).failAfter(1)
+  })
 
   it('should retry once step with #retry', () => {
-    recorder.start();
-    return I.retry().failAfter(1);
-  });
+    recorder.start()
+    return I.retry().failAfter(1)
+  })
 
   it('should alway use the latest global retry options', () => {
-    recorder.start();
+    recorder.start()
     recorder.retry({
       retries: 0,
       minTimeout: 0,
       when: () => true,
-    });
+    })
     recorder.retry({
       retries: 1,
       minTimeout: 0,
       when: () => true,
-    });
-    I.hello(); // before fix: this changed the order of retries
-    return I.failAfter(1);
-  });
+    })
+    I.hello() // before fix: this changed the order of retries
+    return I.failAfter(1)
+  })
 
   it('should not delete a global retry option', () => {
-    recorder.start();
+    recorder.start()
     recorder.retry({
       retries: 2,
       minTimeout: 0,
       when: () => true,
-    });
-    I.retry(1).failAfter(1); // before fix: this changed the order of retries
-    return I.failAfter(2);
-  });
+    })
+    I.retry(1).failAfter(1) // before fix: this changed the order of retries
+    return I.failAfter(2)
+  })
 
   it('should print handle failed steps', () => {
-    recorder.start();
-    let listeners = 0;
-    event.dispatcher.addListener(event.step.before, () => listeners++);
-    event.dispatcher.addListener(event.step.after, () => listeners++);
+    recorder.start()
+    let listeners = 0
+    event.dispatcher.addListener(event.step.before, () => listeners++)
+    event.dispatcher.addListener(event.step.after, () => listeners++)
     event.dispatcher.addListener(event.step.failed, (step) => {
-      listeners++;
-      expect(step.endTime).toBeTruthy();
-      expect(step.startTime).toBeTruthy();
-    });
+      listeners++
+      expect(step.endTime).toBeTruthy()
+      expect(step.startTime).toBeTruthy()
+    })
 
     return I.die()
-      .then(() => listeners = 0)
+      .then(() => (listeners = 0))
       .catch(() => null)
       .then(() => {
-        expect(listeners).toEqual(3);
-      });
-  });
-});
+        expect(listeners).toEqual(3)
+      })
+  })
+})
diff --git a/test/unit/ai_test.js b/test/unit/ai_test.js
index 92dfe3172..a3d1b966f 100644
--- a/test/unit/ai_test.js
+++ b/test/unit/ai_test.js
@@ -1,87 +1,87 @@
-const AiAssistant = require('../../lib/ai');
-const config = require('../../lib/config');
+const AiAssistant = require('../../lib/ai')
+const config = require('../../lib/config')
 
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
 
 describe('AI module', () => {
   beforeEach(() => {
-    AiAssistant.enable({}); // clean up config
-    AiAssistant.reset();
-    config.reset();
-  });
+    AiAssistant.enable({}) // clean up config
+    AiAssistant.reset()
+    config.reset()
+  })
 
   it('should be externally configurable', async () => {
-    const html = '<div><a data-qa="ok">Hey</a></div>';
-    await AiAssistant.setHtmlContext(html);
-    expect(AiAssistant.minifiedHtml).to.include('<a>Hey</a>');
+    const html = '<div><a data-qa="ok">Hey</a></div>'
+    await AiAssistant.setHtmlContext(html)
+    expect(AiAssistant.minifiedHtml).to.include('<a>Hey</a>')
 
     const config = {
       html: {
         allowedAttrs: ['data-qa'],
       },
-    };
+    }
 
-    AiAssistant.enable(config);
-    await AiAssistant.setHtmlContext(html);
-    expect(AiAssistant.minifiedHtml).to.include('<a data-qa="ok">Hey</a>');
-  });
+    AiAssistant.enable(config)
+    await AiAssistant.setHtmlContext(html)
+    expect(AiAssistant.minifiedHtml).to.include('<a data-qa="ok">Hey</a>')
+  })
 
   it('Enabling AI assistant', () => {
-    AiAssistant.enable();
-    expect(AiAssistant.isEnabled).to.be.true;
-  });
+    AiAssistant.enable()
+    expect(AiAssistant.isEnabled).to.be.true
+  })
 
   it('Disabling AI assistant', () => {
-    AiAssistant.enable();
-    AiAssistant.disable();
-    expect(AiAssistant.isEnabled).to.be.false;
-  });
+    AiAssistant.enable()
+    AiAssistant.disable()
+    expect(AiAssistant.isEnabled).to.be.false
+  })
 
   it('Creating completion', async () => {
     AiAssistant.enable({
       request: async () => 'Completed response',
-    });
-    const completion = await AiAssistant.createCompletion(['message 1', 'message 2']);
-    expect(completion).to.equal('Completed response');
-  });
+    })
+    const completion = await AiAssistant.createCompletion(['message 1', 'message 2'])
+    expect(completion).to.equal('Completed response')
+  })
 
   it('Healing failed step', async () => {
     AiAssistant.enable({
       request: async () => 'Thanks you asked, here is the answer:\n```js\nI.click("Hello world");\n```',
-    });
+    })
     const failureContext = {
       html: '<div><a href="#">Hello, world!</a></div>',
       step: { toCode: () => 'Failed step' },
       error: { message: 'Error message' },
       prevSteps: [{ toString: () => 'Previous step' }],
-    };
-    const completion = await AiAssistant.healFailedStep(failureContext);
-    expect(completion).to.deep.equal(['I.click("Hello world");']);
-  });
+    }
+    const completion = await AiAssistant.healFailedStep(failureContext)
+    expect(completion).to.deep.equal(['I.click("Hello world");'])
+  })
 
   it('Calculating tokens', () => {
-    const messages = [{ content: 'Message 1' }, { content: 'Message 2' }];
-    const tokens = AiAssistant.calculateTokens(messages);
-    expect(tokens).to.be.greaterThan(0);
-  });
+    const messages = [{ content: 'Message 1' }, { content: 'Message 2' }]
+    const tokens = AiAssistant.calculateTokens(messages)
+    expect(tokens).to.be.greaterThan(0)
+  })
 
   it('Stopping when reaching tokens limit', () => {
-    AiAssistant.enable({ maxTokens: 100 });
-    AiAssistant.numTokens = 200;
-    AiAssistant.stopWhenReachingTokensLimit();
-    expect(AiAssistant.isEnabled).to.be.false;
-  });
+    AiAssistant.enable({ maxTokens: 100 })
+    AiAssistant.numTokens = 200
+    AiAssistant.stopWhenReachingTokensLimit()
+    expect(AiAssistant.isEnabled).to.be.false
+  })
 
   it('Writing steps', async () => {
     AiAssistant.enable({
       request: async () => 'Well, you can try to ```js\nI.click("Hello world");\n```',
-    });
-    await AiAssistant.setHtmlContext('<div><a href="#">Hello, world!</a></div>');
-    const input = 'Test input';
-    const completion = await AiAssistant.writeSteps(input);
-    expect(completion).to.equal('I.click("Hello world");');
-  });
-});
+    })
+    await AiAssistant.setHtmlContext('<div><a href="#">Hello, world!</a></div>')
+    const input = 'Test input'
+    const completion = await AiAssistant.writeSteps(input)
+    expect(completion).to.equal('I.click("Hello world");')
+  })
+})
diff --git a/test/unit/assert_test.js b/test/unit/assert_test.js
index 4a2b1b677..a6f8da3ff 100644
--- a/test/unit/assert_test.js
+++ b/test/unit/assert_test.js
@@ -1,27 +1,27 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
 
-const Assertion = require('../../lib/assert');
-const AssertionError = require('../../lib/assert/error');
+const Assertion = require('../../lib/assert')
+const AssertionError = require('../../lib/assert/error')
 
-const comparator = (a, b) => a === b;
+const comparator = (a, b) => a === b
 
-let assertion;
+let assertion
 
 describe('Assertion', () => {
   beforeEach(() => {
-    assertion = new Assertion(comparator);
-  });
+    assertion = new Assertion(comparator)
+  })
 
   it('should handle asserts', () => {
-    assertion.assert(1, 1);
-    expect(() => assertion.assert(1, 2)).to.throw(AssertionError);
-  });
+    assertion.assert(1, 1)
+    expect(() => assertion.assert(1, 2)).to.throw(AssertionError)
+  })
 
   it('should handle negative asserts', () => {
-    assertion.negate(1, 2);
-    expect(() => assertion.negate(1, 1)).to.throw(AssertionError);
-  });
-});
+    assertion.negate(1, 2)
+    expect(() => assertion.negate(1, 1)).to.throw(AssertionError)
+  })
+})
diff --git a/test/unit/bdd_test.js b/test/unit/bdd_test.js
index ef61a4876..ec699391d 100644
--- a/test/unit/bdd_test.js
+++ b/test/unit/bdd_test.js
@@ -1,35 +1,27 @@
-const Gherkin = require('@cucumber/gherkin');
-const Messages = require('@cucumber/messages');
-
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-
-const uuidFn = Messages.IdGenerator.uuid();
-const builder = new Gherkin.AstBuilder(uuidFn);
-const matcher = new Gherkin.GherkinClassicTokenMatcher();
-
-const { log } = require('console');
-const Config = require('../../lib/config');
-const {
-  Given,
-  When,
-  And,
-  Then,
-  matchStep,
-  clearSteps,
-  defineParameterType,
-} = require('../../lib/interfaces/bdd');
-const run = require('../../lib/interfaces/gherkin');
-const recorder = require('../../lib/recorder');
-const container = require('../../lib/container');
-const actor = require('../../lib/actor');
-const event = require('../../lib/event');
+const Gherkin = require('@cucumber/gherkin')
+const Messages = require('@cucumber/messages')
+
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+
+const uuidFn = Messages.IdGenerator.uuid()
+const builder = new Gherkin.AstBuilder(uuidFn)
+const matcher = new Gherkin.GherkinClassicTokenMatcher()
+
+const { log } = require('console')
+const Config = require('../../lib/config')
+const { Given, When, And, Then, matchStep, clearSteps, defineParameterType } = require('../../lib/interfaces/bdd')
+const run = require('../../lib/interfaces/gherkin')
+const recorder = require('../../lib/recorder')
+const container = require('../../lib/container')
+const actor = require('../../lib/actor')
+const event = require('../../lib/event')
 
 class Color {
   constructor(name) {
-    this.name = name;
+    this.name = name
   }
 }
 
@@ -44,187 +36,185 @@ const text = `
     Given I have product with 600 price
     And I have product with 1000 price
     When I go to checkout process
-`;
+`
 
 const checkTestForErrors = (test) => {
   return new Promise((resolve, reject) => {
     test.fn((err) => {
       if (err) {
-        return reject(err);
+        return reject(err)
       }
-      resolve();
-    });
-  });
-};
+      resolve()
+    })
+  })
+}
 
 describe('BDD', () => {
   beforeEach(() => {
-    clearSteps();
-    recorder.start();
-    container.create({});
-    Config.reset();
-  });
+    clearSteps()
+    recorder.start()
+    container.create({})
+    Config.reset()
+  })
 
   afterEach(() => {
-    container.clear();
-    recorder.stop();
-  });
+    container.clear()
+    recorder.stop()
+  })
 
   it('should parse gherkin input', () => {
-    const parser = new Gherkin.Parser(builder, matcher);
-    parser.stopAtFirstError = false;
-    const ast = parser.parse(text);
+    const parser = new Gherkin.Parser(builder, matcher)
+    parser.stopAtFirstError = false
+    const ast = parser.parse(text)
     // console.log('Feature', ast.feature);
     // console.log('Scenario', ast.feature.children);
     // console.log('Steps', ast.feature.children[0].steps[0]);
-    expect(ast.feature).is.ok;
-    expect(ast.feature.children).is.ok;
-    expect(ast.feature.children[0].scenario.steps).is.ok;
-  });
+    expect(ast.feature).is.ok
+    expect(ast.feature.children).is.ok
+    expect(ast.feature.children[0].scenario.steps).is.ok
+  })
 
   it('should load step definitions', () => {
-    Given('I am a bird', () => 1);
-    When('I fly over ocean', () => 2);
-    And(/^I fly over land$/i, () => 3);
-    Then(/I see (.*?)/, () => 4);
-    expect(1).is.equal(matchStep('I am a bird')());
-    expect(3).is.equal(matchStep('I Fly oVer Land')());
-    expect(4).is.equal(matchStep('I see ocean')());
-    expect(4).is.equal(matchStep('I see world')());
-  });
+    Given('I am a bird', () => 1)
+    When('I fly over ocean', () => 2)
+    And(/^I fly over land$/i, () => 3)
+    Then(/I see (.*?)/, () => 4)
+    expect(1).is.equal(matchStep('I am a bird')())
+    expect(3).is.equal(matchStep('I Fly oVer Land')())
+    expect(4).is.equal(matchStep('I see ocean')())
+    expect(4).is.equal(matchStep('I see world')())
+  })
 
   it('should fail on duplicate step definitions with option', () => {
     Config.append({
       gherkin: {
         avoidDuplicateSteps: true,
       },
-    });
+    })
 
-    let error = null;
+    let error = null
     try {
-      Given('I am a bird', () => 1);
-      Then('I am a bird', () => 1);
+      Given('I am a bird', () => 1)
+      Then('I am a bird', () => 1)
     } catch (err) {
-      error = err;
+      error = err
     } finally {
-      expect(!!error).is.true;
+      expect(!!error).is.true
     }
-  });
+  })
 
   it('should contain tags', async () => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
-    When('I go to checkout process', () => sum += 10);
-    const suite = run(text);
-    suite.tests[0].fn(() => {});
-    expect(suite.tests[0].tags).is.ok;
-    expect('@super').is.equal(suite.tests[0].tags[0]);
-  });
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
+    When('I go to checkout process', () => (sum += 10))
+    const suite = run(text)
+    suite.tests[0].fn(() => {})
+    expect(suite.tests[0].tags).is.ok
+    expect('@super').is.equal(suite.tests[0].tags[0])
+  })
 
   it('should load step definitions', (done) => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
-    When('I go to checkout process', () => sum += 10);
-    const suite = run(text);
-    expect('checkout process').is.equal(suite.title);
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
+    When('I go to checkout process', () => (sum += 10))
+    const suite = run(text)
+    expect('checkout process').is.equal(suite.title)
     suite.tests[0].fn(() => {
-      expect(suite.tests[0].steps).is.ok;
-      expect(1610).is.equal(sum);
-      done();
-    });
-  });
+      expect(suite.tests[0].steps).is.ok
+      expect(1610).is.equal(sum)
+      done()
+    })
+  })
 
   it('should allow failed steps', async () => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
-    When('I go to checkout process', () => expect(false).is.true);
-    const suite = run(text);
-    expect('checkout process').is.equal(suite.title);
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
+    When('I go to checkout process', () => expect(false).is.true)
+    const suite = run(text)
+    expect('checkout process').is.equal(suite.title)
     try {
-      await checkTestForErrors(suite.tests[0]);
-      return Promise.reject((new Error('Test should have thrown with failed step, but did not')));
+      await checkTestForErrors(suite.tests[0])
+      return Promise.reject(new Error('Test should have thrown with failed step, but did not'))
     } catch (err) {
-      const errored = !!err;
-      expect(errored).is.true;
+      const errored = !!err
+      expect(errored).is.true
     }
-  });
+  })
 
   it('handles errors in steps', async () => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
-    When('I go to checkout process', () => { throw new Error('errored step'); });
-    const suite = run(text);
-    expect('checkout process').is.equal(suite.title);
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
+    When('I go to checkout process', () => {
+      throw new Error('errored step')
+    })
+    const suite = run(text)
+    expect('checkout process').is.equal(suite.title)
     try {
-      await checkTestForErrors(suite.tests[0]);
-      return Promise.reject((new Error('Test should have thrown with error, but did not')));
+      await checkTestForErrors(suite.tests[0])
+      return Promise.reject(new Error('Test should have thrown with error, but did not'))
     } catch (err) {
-      const errored = !!err;
-      expect(errored).is.true;
+      const errored = !!err
+      expect(errored).is.true
     }
-  });
+  })
 
   it('handles async errors in steps', async () => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
-    When('I go to checkout process', () => Promise.reject(new Error('step failed')));
-    const suite = run(text);
-    expect('checkout process').is.equal(suite.title);
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
+    When('I go to checkout process', () => Promise.reject(new Error('step failed')))
+    const suite = run(text)
+    expect('checkout process').is.equal(suite.title)
     try {
-      await checkTestForErrors(suite.tests[0]);
-      return Promise.reject((new Error('Test should have thrown with error, but did not')));
+      await checkTestForErrors(suite.tests[0])
+      return Promise.reject(new Error('Test should have thrown with error, but did not'))
     } catch (err) {
-      const errored = !!err;
-      expect(errored).is.true;
+      const errored = !!err
+      expect(errored).is.true
     }
-  });
+  })
 
   it('should work with async functions', (done) => {
-    let sum = 0;
-    Given(/I have product with (\d+) price/, param => sum += parseInt(param, 10));
+    let sum = 0
+    Given(/I have product with (\d+) price/, (param) => (sum += parseInt(param, 10)))
     When('I go to checkout process', async () => {
       return new Promise((checkoutDone) => {
-        sum += 10;
-        setTimeout(checkoutDone, 0);
-      });
-    });
-    const suite = run(text);
-    expect('checkout process').is.equal(suite.title);
+        sum += 10
+        setTimeout(checkoutDone, 0)
+      })
+    })
+    const suite = run(text)
+    expect('checkout process').is.equal(suite.title)
     suite.tests[0].fn(() => {
-      expect(suite.tests[0].steps).is.ok;
-      expect(1610).is.equal(sum);
-      done();
-    });
-  });
+      expect(suite.tests[0].steps).is.ok
+      expect(1610).is.equal(sum)
+      done()
+    })
+  })
 
   it('should execute scenarios step-by-step ', (done) => {
-    printed = [];
+    printed = []
     container.append({
       helpers: {
         simple: {
           do(...args) {
-            return Promise.resolve().then(() => printed.push(args.join(' ')));
+            return Promise.resolve().then(() => printed.push(args.join(' ')))
           },
         },
       },
-    });
-    I = actor();
-    let sum = 0;
+    })
+    I = actor()
+    let sum = 0
     Given(/I have product with (\d+) price/, (price) => {
-      I.do('add', sum += parseInt(price, 10));
-    });
+      I.do('add', (sum += parseInt(price, 10)))
+    })
     When('I go to checkout process', () => {
-      I.do('add finish checkout');
-    });
-    const suite = run(text);
+      I.do('add finish checkout')
+    })
+    const suite = run(text)
     suite.tests[0].fn(() => {
       recorder.promise().then(() => {
-        printed.should.include.members([
-          'add 600',
-          'add 1600',
-          'add finish checkout',
-        ]);
-        const lines = recorder.scheduled().split('\n');
+        printed.should.include.members(['add 600', 'add 1600', 'add finish checkout'])
+        const lines = recorder.scheduled().split('\n')
         lines.should.include.members([
           'do: "add", 600',
           'step passed',
@@ -237,17 +227,17 @@ describe('BDD', () => {
           'return result',
           'fire test.passed',
           'finish test',
-        ]);
-        done();
-      });
-    });
-  });
+        ])
+        done()
+      })
+    })
+  })
 
   it('should match step with params', () => {
-    Given('I am a {word}', param => param);
-    const fn = matchStep('I am a bird');
-    expect('bird').is.equal(fn.params[0]);
-  });
+    Given('I am a {word}', (param) => param)
+    const fn = matchStep('I am a bird')
+    expect('bird').is.equal(fn.params[0])
+  })
 
   it('should produce step events', (done) => {
     const text = `
@@ -255,34 +245,34 @@ describe('BDD', () => {
 
       Scenario:
         Then I emit step events
-    `;
-    Then('I emit step events', () => {});
-    let listeners = 0;
-    event.dispatcher.addListener(event.bddStep.before, () => listeners++);
-    event.dispatcher.addListener(event.bddStep.after, () => listeners++);
+    `
+    Then('I emit step events', () => {})
+    let listeners = 0
+    event.dispatcher.addListener(event.bddStep.before, () => listeners++)
+    event.dispatcher.addListener(event.bddStep.after, () => listeners++)
 
-    const suite = run(text);
+    const suite = run(text)
     suite.tests[0].fn(() => {
-      listeners.should.eql(2);
-      done();
-    });
-  });
+      listeners.should.eql(2)
+      done()
+    })
+  })
 
   it('should use shortened form for step definitions', () => {
-    let fn;
-    Given('I am a {word}', params => params[0]);
-    When('I have {int} wings and {int} eyes', params => params[0] + params[1]);
-    Given('I have ${int} in my pocket', params => params[0]); // eslint-disable-line no-template-curly-in-string
-    Given('I have also ${float} in my pocket', params => params[0]); // eslint-disable-line no-template-curly-in-string
-    fn = matchStep('I am a bird');
-    expect('bird').is.equal(fn(fn.params));
-    fn = matchStep('I have 2 wings and 2 eyes');
-    expect(4).is.equal(fn(fn.params));
-    fn = matchStep('I have $500 in my pocket');
-    expect(500).is.equal(fn(fn.params));
-    fn = matchStep('I have also $500.30 in my pocket');
-    expect(500.30).is.equal(fn(fn.params));
-  });
+    let fn
+    Given('I am a {word}', (params) => params[0])
+    When('I have {int} wings and {int} eyes', (params) => params[0] + params[1])
+    Given('I have ${int} in my pocket', (params) => params[0]) // eslint-disable-line no-template-curly-in-string
+    Given('I have also ${float} in my pocket', (params) => params[0]) // eslint-disable-line no-template-curly-in-string
+    fn = matchStep('I am a bird')
+    expect('bird').is.equal(fn(fn.params))
+    fn = matchStep('I have 2 wings and 2 eyes')
+    expect(4).is.equal(fn(fn.params))
+    fn = matchStep('I have $500 in my pocket')
+    expect(500).is.equal(fn(fn.params))
+    fn = matchStep('I have also $500.30 in my pocket')
+    expect(500.3).is.equal(fn(fn.params))
+  })
 
   it('should attach before hook for Background', (finish) => {
     const text = `
@@ -293,22 +283,22 @@ describe('BDD', () => {
 
       Scenario:
         Then I am shopping
-    `;
-    let sum = 0;
+    `
+    let sum = 0
     function incrementSum() {
-      sum++;
+      sum++
     }
-    Given('I am logged in as customer', incrementSum);
-    Then('I am shopping', incrementSum);
-    const suite = run(text);
-    const done = () => {};
+    Given('I am logged in as customer', incrementSum)
+    Then('I am shopping', incrementSum)
+    const suite = run(text)
+    const done = () => {}
 
-    suite._beforeEach.forEach(hook => hook.run(done));
+    suite._beforeEach.forEach((hook) => hook.run(done))
     suite.tests[0].fn(() => {
-      expect(sum).is.equal(2);
-      finish();
-    });
-  });
+      expect(sum).is.equal(2)
+      finish()
+    })
+  })
 
   it('should execute scenario outlines', (done) => {
     const text = `
@@ -330,37 +320,37 @@ describe('BDD', () => {
       Examples:
         | price | total |
         | 20    | 18    |
-    `;
-    let cart = 0;
-    let sum = 0;
+    `
+    let cart = 0
+    let sum = 0
     Given('I have product with price {int}$ in my cart', (price) => {
-      cart = price;
-    });
+      cart = price
+    })
     Given('discount is {int} %', (discount) => {
-      cart -= cart * discount / 100;
-    });
+      cart -= (cart * discount) / 100
+    })
     Then('I should see price is {string} $', (total) => {
-      sum = parseInt(total, 10);
-    });
+      sum = parseInt(total, 10)
+    })
 
-    const suite = run(text);
+    const suite = run(text)
 
-    expect(suite.tests[0].tags).is.ok;
-    expect(['@awesome', '@cool', '@super']).is.deep.equal(suite.tests[0].tags);
-    expect(['@awesome', '@cool', '@super', '@exampleTag1', '@exampleTag2']).is.deep.equal(suite.tests[1].tags);
+    expect(suite.tests[0].tags).is.ok
+    expect(['@awesome', '@cool', '@super']).is.deep.equal(suite.tests[0].tags)
+    expect(['@awesome', '@cool', '@super', '@exampleTag1', '@exampleTag2']).is.deep.equal(suite.tests[1].tags)
 
-    expect(2).is.equal(suite.tests.length);
+    expect(2).is.equal(suite.tests.length)
     suite.tests[0].fn(() => {
-      expect(9).is.equal(cart);
-      expect(9).is.equal(sum);
+      expect(9).is.equal(cart)
+      expect(9).is.equal(sum)
 
       suite.tests[1].fn(() => {
-        expect(18).is.equal(cart);
-        expect(18).is.equal(sum);
-        done();
-      });
-    });
-  });
+        expect(18).is.equal(cart)
+        expect(18).is.equal(sum)
+        done()
+      })
+    })
+  })
 
   it('should provide a parsed DataTable', (done) => {
     const text = `
@@ -377,59 +367,59 @@ describe('BDD', () => {
         | label   | price  |
         | beer    | 9      |
         | cookies | 12     |
-    `;
+    `
 
-    let givenParsedRows;
-    let thenParsedRows;
+    let givenParsedRows
+    let thenParsedRows
 
     Given('I have the following products :', (products) => {
-      expect(products.rows.length).to.equal(3);
-      givenParsedRows = products.parse();
-    });
+      expect(products.rows.length).to.equal(3)
+      givenParsedRows = products.parse()
+    })
     Then('I should see the following products :', (products) => {
-      expect(products.rows.length).to.equal(3);
-      thenParsedRows = products.parse();
-    });
+      expect(products.rows.length).to.equal(3)
+      thenParsedRows = products.parse()
+    })
 
-    const suite = run(text);
+    const suite = run(text)
 
     const expectedParsedDataTable = [
       ['label', 'price'],
       ['beer', '9'],
       ['cookies', '12'],
-    ];
+    ]
 
     suite.tests[0].fn(() => {
-      expect(givenParsedRows.rawData).is.deep.equal(expectedParsedDataTable);
-      expect(thenParsedRows.rawData).is.deep.equal(expectedParsedDataTable);
-      done();
-    });
-  });
+      expect(givenParsedRows.rawData).is.deep.equal(expectedParsedDataTable)
+      expect(thenParsedRows.rawData).is.deep.equal(expectedParsedDataTable)
+      done()
+    })
+  })
 
   it('should match step with custom parameter type', (done) => {
     const colorType = {
       name: 'color',
       regexp: /red|blue|yellow/,
       transformer: (s) => new Color(s),
-    };
-    defineParameterType(colorType);
-    Given('I have a {color} label', (color) => color);
-    const fn = matchStep('I have a red label');
-    expect('red').is.equal(fn.params[0].name);
-    done();
-  });
+    }
+    defineParameterType(colorType)
+    Given('I have a {color} label', (color) => color)
+    const fn = matchStep('I have a red label')
+    expect('red').is.equal(fn.params[0].name)
+    done()
+  })
 
   it('should match step with async custom parameter type transformation', async () => {
     const colorType = {
       name: 'async_color',
       regexp: /red|blue|yellow/,
       transformer: async (s) => new Color(s),
-    };
-    defineParameterType(colorType);
-    Given('I have a {async_color} label', (color) => color);
-    const fn = matchStep('I have a blue label');
-    const color = await fn.params[0];
-    expect('blue').is.equal(color.name);
-    await Promise.resolve();
-  });
-});
+    }
+    defineParameterType(colorType)
+    Given('I have a {async_color} label', (color) => color)
+    const fn = matchStep('I have a blue label')
+    const color = await fn.params[0]
+    expect('blue').is.equal(color.name)
+    await Promise.resolve()
+  })
+})
diff --git a/test/unit/config_test.js b/test/unit/config_test.js
index aa1d5faad..44833dfa3 100644
--- a/test/unit/config_test.js
+++ b/test/unit/config_test.js
@@ -1,67 +1,67 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
 
-const config = require('../../lib/config');
+const config = require('../../lib/config')
 
 describe('Config', () => {
-  beforeEach(() => config.reset());
+  beforeEach(() => config.reset())
 
   it('should be created', () => {
     const cfg = config.create({
       output: './report',
-    });
-    expect(cfg).to.contain.keys(['helpers', 'plugins', 'include']);
-    expect(config.get()).to.eql(cfg);
-    expect(cfg.output).to.eql('./report');
-    expect(config.get('output')).to.eql('./report');
-    expect(config.get('output', './other')).to.eql('./report');
-    expect(config.get('tests', '**_test.js')).to.eql('**_test.js');
-  });
+    })
+    expect(cfg).to.contain.keys(['helpers', 'plugins', 'include'])
+    expect(config.get()).to.eql(cfg)
+    expect(cfg.output).to.eql('./report')
+    expect(config.get('output')).to.eql('./report')
+    expect(config.get('output', './other')).to.eql('./report')
+    expect(config.get('tests', '**_test.js')).to.eql('**_test.js')
+  })
 
   it('should be completely reset', () => {
     config.addHook((cfg) => {
-      cfg.helpers.Puppeteer.show = true;
-    });
+      cfg.helpers.Puppeteer.show = true
+    })
     config.create({
       tests: '**tests',
       helpers: {
         Puppeteer: {},
       },
-    });
+    })
     config.append({
       output: './other',
-    });
-    expect(config.get('helpers').Puppeteer.show).to.eql(true);
-    config.reset();
-    expect(config.get().output).to.not.eql('./other');
-    expect(config.get()).to.not.contain.key('tests');
-    expect(config.get('helpers')).to.not.contain.key('Puppeteer');
+    })
+    expect(config.get('helpers').Puppeteer.show).to.eql(true)
+    config.reset()
+    expect(config.get().output).to.not.eql('./other')
+    expect(config.get()).to.not.contain.key('tests')
+    expect(config.get('helpers')).to.not.contain.key('Puppeteer')
     config.create({
       helpers: {
         Puppeteer: {},
       },
-    });
-    expect(config.get('helpers').Puppeteer.show).to.not.eql(true);
-  });
+    })
+    expect(config.get('helpers').Puppeteer.show).to.not.eql(true)
+  })
 
   it('can be updated', () => {
-    config.create();
+    config.create()
     config.append({
       output: './other',
-    });
-    expect(config.get('output')).to.eql('./other');
-  });
+    })
+    expect(config.get('output')).to.eql('./other')
+  })
 
   it('should use config hooks to enhance configs', () => {
     config.addHook((cfg) => {
-      cfg.additionalValue = true;
-    });
+      cfg.additionalValue = true
+    })
     const cfg = config.create({
       additionalValue: false,
-    });
-    expect(cfg).to.contain.key('additionalValue');
-    expect(cfg.additionalValue).to.eql(true);
-  });
-});
+    })
+    expect(cfg).to.contain.key('additionalValue')
+    expect(cfg.additionalValue).to.eql(true)
+  })
+})
diff --git a/test/unit/container_test.js b/test/unit/container_test.js
index c646d5a03..ccb0c5733 100644
--- a/test/unit/container_test.js
+++ b/test/unit/container_test.js
@@ -1,147 +1,154 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
 
-const FileSystem = require('../../lib/helper/FileSystem');
-const actor = require('../../lib/actor');
-const container = require('../../lib/container');
+const FileSystem = require('../../lib/helper/FileSystem')
+const actor = require('../../lib/actor')
+const container = require('../../lib/container')
 
 describe('Container', () => {
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/..');
-    global.inject = container.support;
-    global.actor = actor;
-  });
+    global.codecept_dir = path.join(__dirname, '/..')
+    global.inject = container.support
+    global.actor = actor
+  })
 
   afterEach(() => {
-    container.clear();
-    ['I', 'dummy_page'].forEach((po) => {
-      const name = require.resolve(path.join(__dirname, `../data/${po}`));
-      delete require.cache[name];
-    });
-  });
+    container.clear()
+    ;['I', 'dummy_page'].forEach((po) => {
+      const name = require.resolve(path.join(__dirname, `../data/${po}`))
+      delete require.cache[name]
+    })
+  })
 
   describe('#translation', () => {
-    const Translation = require('../../lib/translation');
+    const Translation = require('../../lib/translation')
 
     it('should create empty translation', () => {
-      container.create({});
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.false;
-      expect(container.translation().actionAliasFor('see')).to.eql('see');
-    });
+      container.create({})
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.false
+      expect(container.translation().actionAliasFor('see')).to.eql('see')
+    })
 
     it('should create Russian translation', () => {
-      container.create({ translation: 'ru-RU' });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-      expect(container.translation().I).to.eql('Я');
-      expect(container.translation().actionAliasFor('see')).to.eql('вижу');
-    });
+      container.create({ translation: 'ru-RU' })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+      expect(container.translation().I).to.eql('Я')
+      expect(container.translation().actionAliasFor('see')).to.eql('вижу')
+    })
 
     it('should create Italian translation', () => {
-      container.create({ translation: 'it-IT' });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-      expect(container.translation().I).to.eql('io');
-      expect(container.translation().value('contexts').Feature).to.eql('Caratteristica');
-    });
+      container.create({ translation: 'it-IT' })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+      expect(container.translation().I).to.eql('io')
+      expect(container.translation().value('contexts').Feature).to.eql('Caratteristica')
+    })
 
     it('should create French translation', () => {
-      container.create({ translation: 'fr-FR' });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-      expect(container.translation().I).to.eql('Je');
-      expect(container.translation().value('contexts').Feature).to.eql('Fonctionnalité');
-    });
+      container.create({ translation: 'fr-FR' })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+      expect(container.translation().I).to.eql('Je')
+      expect(container.translation().value('contexts').Feature).to.eql('Fonctionnalité')
+    })
 
     it('should create Portuguese translation', () => {
-      container.create({ translation: 'pt-BR' });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-      expect(container.translation().I).to.eql('Eu');
-      expect(container.translation().value('contexts').Feature).to.eql('Funcionalidade');
-    });
+      container.create({ translation: 'pt-BR' })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+      expect(container.translation().I).to.eql('Eu')
+      expect(container.translation().value('contexts').Feature).to.eql('Funcionalidade')
+    })
 
     it('should load custom translation', () => {
-      container.create({ translation: 'my' });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-    });
+      container.create({ translation: 'my' })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+    })
 
     it('should load no translation', () => {
-      container.create({});
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.false;
-    });
+      container.create({})
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.false
+    })
 
     it('should load custom translation with vocabularies', () => {
-      container.create({ translation: 'my', vocabularies: ['data/custom_vocabulary.json'] });
-      expect(container.translation()).to.be.instanceOf(Translation);
-      expect(container.translation().loaded).to.be.true;
-      const translation = container.translation();
-      expect(translation.actionAliasFor('say')).to.eql('arr');
-    });
-  });
+      container.create({ translation: 'my', vocabularies: ['data/custom_vocabulary.json'] })
+      expect(container.translation()).to.be.instanceOf(Translation)
+      expect(container.translation().loaded).to.be.true
+      const translation = container.translation()
+      expect(translation.actionAliasFor('say')).to.eql('arr')
+    })
+  })
 
   describe('#helpers', () => {
     beforeEach(() => {
       container.clear({
         helper1: { name: 'hello' },
         helper2: { name: 'world' },
-      });
-    });
+      })
+    })
 
-    it('should return all helper with no args', () => expect(container.helpers()).to.have.keys('helper1', 'helper2'));
+    it('should return all helper with no args', () => expect(container.helpers()).to.have.keys('helper1', 'helper2'))
 
     it('should return helper by name', () => {
-      expect(container.helpers('helper1')).is.ok;
-      expect(container.helpers('helper1').name).to.eql('hello');
-      expect(container.helpers('helper2')).is.ok;
-      expect(container.helpers('helper2').name).to.eql('world');
-      expect(!container.helpers('helper3')).is.ok;
-    });
-  });
+      expect(container.helpers('helper1')).is.ok
+      expect(container.helpers('helper1').name).to.eql('hello')
+      expect(container.helpers('helper2')).is.ok
+      expect(container.helpers('helper2').name).to.eql('world')
+      expect(!container.helpers('helper3')).is.ok
+    })
+  })
 
   describe('#support', () => {
     beforeEach(() => {
-      container.clear({}, {
-        support1: { name: 'hello' },
-        support2: { name: 'world' },
-      });
-    });
+      container.clear(
+        {},
+        {
+          support1: { name: 'hello' },
+          support2: { name: 'world' },
+        },
+      )
+    })
 
-    it('should return all support objects', () => expect(container.support()).to.have.keys('support1', 'support2'));
+    it('should return all support objects', () => expect(container.support()).to.have.keys('support1', 'support2'))
 
     it('should support object by name', () => {
-      expect(container.support('support1')).is.ok;
-      expect(container.support('support1').name).to.eql('hello');
-      expect(container.support('support2')).is.ok;
-      expect(container.support('support2').name).to.eql('world');
-      expect(!container.support('support3')).is.ok;
-    });
-  });
+      expect(container.support('support1')).is.ok
+      expect(container.support('support1').name).to.eql('hello')
+      expect(container.support('support2')).is.ok
+      expect(container.support('support2').name).to.eql('world')
+      expect(!container.support('support3')).is.ok
+    })
+  })
 
   describe('#plugins', () => {
     beforeEach(() => {
-      container.clear({}, {}, {
-        plugin1: { name: 'hello' },
-        plugin2: { name: 'world' },
-      });
-    });
+      container.clear(
+        {},
+        {},
+        {
+          plugin1: { name: 'hello' },
+          plugin2: { name: 'world' },
+        },
+      )
+    })
 
-    it('should return all plugins', () => expect(container.plugins()).to.have.keys('plugin1', 'plugin2'));
+    it('should return all plugins', () => expect(container.plugins()).to.have.keys('plugin1', 'plugin2'))
 
     it('should get plugin by name', () => {
-      expect(container.plugins('plugin1')).is.ok;
-      expect(container.plugins('plugin1').name).is.eql('hello');
-      expect(container.plugins('plugin2')).is.ok;
-      expect(container.plugins('plugin2').name).is.eql('world');
-      expect(!container.plugins('plugin3')).is.ok;
-    });
-  });
+      expect(container.plugins('plugin1')).is.ok
+      expect(container.plugins('plugin1').name).is.eql('hello')
+      expect(container.plugins('plugin2')).is.ok
+      expect(container.plugins('plugin2').name).is.eql('world')
+      expect(!container.plugins('plugin3')).is.ok
+    })
+  })
 
   describe('#create', () => {
     it('should create container with helpers', () => {
@@ -152,64 +159,64 @@ describe('Container', () => {
           },
           FileSystem: {},
         },
-      };
-      container.create(config);
+      }
+      container.create(config)
       // custom helpers
-      expect(container.helpers('MyHelper')).is.ok;
-      expect(container.helpers('MyHelper').method()).to.eql('hello world');
+      expect(container.helpers('MyHelper')).is.ok
+      expect(container.helpers('MyHelper').method()).to.eql('hello world')
 
       // built-in helpers
-      expect(container.helpers('FileSystem')).is.ok;
-      expect(container.helpers('FileSystem')).to.be.instanceOf(FileSystem);
-    });
+      expect(container.helpers('FileSystem')).is.ok
+      expect(container.helpers('FileSystem')).to.be.instanceOf(FileSystem)
+    })
 
     it('should always create I', () => {
-      container.create({});
-      expect(container.support('I')).is.ok;
-    });
+      container.create({})
+      expect(container.support('I')).is.ok
+    })
 
     it('should load DI and return a reference to the module', () => {
       container.create({
         include: {
           dummyPage: './data/dummy_page',
         },
-      });
-      const dummyPage = require('../data/dummy_page');
-      expect(container.support('dummyPage')).is.eql(dummyPage);
-    });
+      })
+      const dummyPage = require('../data/dummy_page')
+      expect(container.support('dummyPage')).is.eql(dummyPage)
+    })
 
     it('should load I from path and execute _init', () => {
       container.create({
         include: {
           I: './data/I',
         },
-      });
-      expect(container.support('I')).is.ok;
-      expect(container.support('I')).to.include.keys('_init', 'doSomething');
-      expect(global.I_initialized).to.be.true;
-    });
+      })
+      expect(container.support('I')).is.ok
+      expect(container.support('I')).to.include.keys('_init', 'doSomething')
+      expect(global.I_initialized).to.be.true
+    })
 
     it('should load DI includes provided as require paths', () => {
       container.create({
         include: {
           dummyPage: './data/dummy_page',
         },
-      });
-      expect(container.support('dummyPage')).is.ok;
-      expect(container.support('dummyPage')).to.include.keys('openDummyPage');
-    });
+      })
+      expect(container.support('dummyPage')).is.ok
+      expect(container.support('dummyPage')).to.include.keys('openDummyPage')
+    })
 
     it('should load DI and inject I into PO', () => {
       container.create({
         include: {
           dummyPage: './data/dummy_page',
         },
-      });
-      expect(container.support('dummyPage')).is.ok;
-      expect(container.support('I')).is.ok;
-      expect(container.support('dummyPage')).to.include.keys('openDummyPage');
-      expect(container.support('dummyPage').getI()).to.have.keys(Object.keys(container.support('I')));
-    });
+      })
+      expect(container.support('dummyPage')).is.ok
+      expect(container.support('I')).is.ok
+      expect(container.support('dummyPage')).to.include.keys('openDummyPage')
+      expect(container.support('dummyPage').getI()).to.have.keys(Object.keys(container.support('I')))
+    })
 
     it('should load DI and inject custom I into PO', () => {
       container.create({
@@ -217,12 +224,12 @@ describe('Container', () => {
           dummyPage: './data/dummy_page',
           I: './data/I',
         },
-      });
-      expect(container.support('dummyPage')).is.ok;
-      expect(container.support('I')).is.ok;
-      expect(container.support('dummyPage')).to.include.keys('openDummyPage');
-      expect(container.support('dummyPage').getI()).to.have.keys(Object.keys(container.support('I')));
-    });
+      })
+      expect(container.support('dummyPage')).is.ok
+      expect(container.support('I')).is.ok
+      expect(container.support('dummyPage')).to.include.keys('openDummyPage')
+      expect(container.support('dummyPage').getI()).to.have.keys(Object.keys(container.support('I')))
+    })
 
     it('should load DI includes provided as objects', () => {
       container.create({
@@ -231,10 +238,10 @@ describe('Container', () => {
             openDummyPage: () => 'dummy page opened',
           },
         },
-      });
-      expect(container.support('dummyPage')).is.ok;
-      expect(container.support('dummyPage')).to.include.keys('openDummyPage');
-    });
+      })
+      expect(container.support('dummyPage')).is.ok
+      expect(container.support('dummyPage')).to.include.keys('openDummyPage')
+    })
 
     it('should load DI includes provided as objects', () => {
       container.create({
@@ -243,11 +250,11 @@ describe('Container', () => {
             openDummyPage: () => 'dummy page opened',
           },
         },
-      });
-      expect(container.support('dummyPage')).is.ok;
-      expect(container.support('dummyPage')).to.include.keys('openDummyPage');
-    });
-  });
+      })
+      expect(container.support('dummyPage')).is.ok
+      expect(container.support('dummyPage')).to.include.keys('openDummyPage')
+    })
+  })
 
   describe('#append', () => {
     it('should be able to add new helper', () => {
@@ -255,26 +262,26 @@ describe('Container', () => {
         helpers: {
           FileSystem: {},
         },
-      };
-      container.create(config);
+      }
+      container.create(config)
       container.append({
         helpers: {
           AnotherHelper: { method: () => 'executed' },
         },
-      });
-      expect(container.helpers('FileSystem')).is.ok;
-      expect(container.helpers('FileSystem')).is.instanceOf(FileSystem);
+      })
+      expect(container.helpers('FileSystem')).is.ok
+      expect(container.helpers('FileSystem')).is.instanceOf(FileSystem)
 
-      expect(container.helpers('AnotherHelper')).is.ok;
-      expect(container.helpers('AnotherHelper').method()).is.eql('executed');
-    });
+      expect(container.helpers('AnotherHelper')).is.ok
+      expect(container.helpers('AnotherHelper').method()).is.eql('executed')
+    })
 
     it('should be able to add new support object', () => {
-      container.create({});
-      container.append({ support: { userPage: { login: '#login' } } });
-      expect(container.support('I')).is.ok;
-      expect(container.support('userPage')).is.ok;
-      expect(container.support('userPage').login).is.eql('#login');
-    });
-  });
-});
+      container.create({})
+      container.append({ support: { userPage: { login: '#login' } } })
+      expect(container.support('I')).is.ok
+      expect(container.support('userPage')).is.ok
+      expect(container.support('userPage').login).is.eql('#login')
+    })
+  })
+})
diff --git a/test/unit/heal_test.js b/test/unit/heal_test.js
index 03121f4f9..9c8eb8e35 100644
--- a/test/unit/heal_test.js
+++ b/test/unit/heal_test.js
@@ -1,16 +1,16 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const heal = require('../../lib/heal');
-const recorder = require('../../lib/recorder');
-const Step = require('../../lib/step');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const heal = require('../../lib/heal')
+const recorder = require('../../lib/recorder')
+const Step = require('../../lib/step')
 
 describe('heal', () => {
   beforeEach(() => {
-    heal.clear();
-    recorder.reset();
-  });
+    heal.clear()
+    recorder.reset()
+  })
 
   it('should collect recipes', () => {
     heal.addRecipe('reload', {
@@ -18,13 +18,13 @@ describe('heal', () => {
       steps: ['click'],
       fn: async () => {
         return ({ I }) => {
-          I.refreshPage();
-        };
+          I.refreshPage()
+        }
       },
-    });
+    })
 
-    expect(heal.hasCorrespondingRecipes({ name: 'click' })).to.be.true;
-  });
+    expect(heal.hasCorrespondingRecipes({ name: 'click' })).to.be.true
+  })
 
   it('should respect the priority of recipes', async () => {
     heal.addRecipe('secondPrior', {
@@ -32,56 +32,56 @@ describe('heal', () => {
       steps: ['click'],
       fn: async () => {
         return ({ I }) => {
-          I.refreshPage();
-        };
+          I.refreshPage()
+        }
       },
-    });
+    })
 
     heal.addRecipe('firstPrior', {
       priority: 1,
       steps: ['refresh'],
       fn: async () => {
         return ({ I }) => {
-          I.refreshPage();
-          I.refreshPage();
-        };
+          I.refreshPage()
+          I.refreshPage()
+        }
       },
-    });
+    })
 
-    expect((await heal.getCodeSuggestions({}))[0].name).to.equal('firstPrior');
-    expect((await heal.getCodeSuggestions({}))[1].name).to.equal('secondPrior');
-  });
+    expect((await heal.getCodeSuggestions({}))[0].name).to.equal('firstPrior')
+    expect((await heal.getCodeSuggestions({}))[1].name).to.equal('secondPrior')
+  })
 
   it('should have corresponding recipes', () => {
-    heal.recipes = { test: { steps: ['step1', 'step2'], fn: () => {} } };
-    heal.contextName = 'TestSuite';
-    const result = heal.hasCorrespondingRecipes({ name: 'step1' });
-    expect(result).to.be.true;
-  });
+    heal.recipes = { test: { steps: ['step1', 'step2'], fn: () => {} } }
+    heal.contextName = 'TestSuite'
+    const result = heal.hasCorrespondingRecipes({ name: 'step1' })
+    expect(result).to.be.true
+  })
 
   it('should get code suggestions', async () => {
-    heal.recipes = { test: { prepare: { prop: () => 'value' }, fn: () => 'snippet' } };
-    heal.contextName = 'TestSuite';
-    const suggestions = await heal.getCodeSuggestions({});
-    expect(suggestions).to.deep.equal([{ name: 'test', snippets: ['snippet'] }]);
-  });
+    heal.recipes = { test: { prepare: { prop: () => 'value' }, fn: () => 'snippet' } }
+    heal.contextName = 'TestSuite'
+    const suggestions = await heal.getCodeSuggestions({})
+    expect(suggestions).to.deep.equal([{ name: 'test', snippets: ['snippet'] }])
+  })
 
   it('should heal failed steps', async () => {
-    let isHealed = false;
+    let isHealed = false
     heal.addRecipe('reload', {
       priority: 10,
       steps: ['click'],
       fn: async () => {
         return () => {
-          isHealed = true;
-        };
+          isHealed = true
+        }
       },
-    });
+    })
 
-    await heal.healStep(new Step(null, 'click'));
+    await heal.healStep(new Step(null, 'click'))
 
-    expect(isHealed).to.be.true;
-  });
+    expect(isHealed).to.be.true
+  })
 
   it('should match tests by grep', () => {
     heal.addRecipe('reload', {
@@ -89,35 +89,35 @@ describe('heal', () => {
       grep: '@slow',
       steps: ['step1'],
       fn: () => {},
-    });
+    })
 
-    heal.contextName = 'TestSuite @slow';
-    expect(heal.hasCorrespondingRecipes({ name: 'step1' })).to.be.true;
-    heal.contextName = 'TestSuite @fast';
-    expect(heal.hasCorrespondingRecipes({ name: 'step1' })).not.to.be.true;
-  });
+    heal.contextName = 'TestSuite @slow'
+    expect(heal.hasCorrespondingRecipes({ name: 'step1' })).to.be.true
+    heal.contextName = 'TestSuite @fast'
+    expect(heal.hasCorrespondingRecipes({ name: 'step1' })).not.to.be.true
+  })
 
   it('should contain info', async () => {
-    let isHealed = false;
-    let passedOpts = null;
+    let isHealed = false
+    let passedOpts = null
     heal.addRecipe('reload', {
       priority: 10,
       steps: ['click'],
       fn: async (opts) => {
-        passedOpts = opts;
+        passedOpts = opts
         return () => {
-          isHealed = true;
-        };
+          isHealed = true
+        }
       },
-    });
-
-    await heal.healStep(new Step(null, 'click'), new Error('Ups'), { test: { title: 'test' } });
-
-    expect(isHealed).to.be.true;
-    expect(passedOpts).to.haveOwnProperty('test');
-    expect(passedOpts).to.haveOwnProperty('error');
-    expect(passedOpts).to.haveOwnProperty('step');
-    expect(passedOpts).to.haveOwnProperty('prevSteps');
-    expect(passedOpts.error.message).to.eql('Ups');
-  });
-});
+    })
+
+    await heal.healStep(new Step(null, 'click'), new Error('Ups'), { test: { title: 'test' } })
+
+    expect(isHealed).to.be.true
+    expect(passedOpts).to.haveOwnProperty('test')
+    expect(passedOpts).to.haveOwnProperty('error')
+    expect(passedOpts).to.haveOwnProperty('step')
+    expect(passedOpts).to.haveOwnProperty('prevSteps')
+    expect(passedOpts.error.message).to.eql('Ups')
+  })
+})
diff --git a/test/unit/html_test.js b/test/unit/html_test.js
index 046d49076..66049ecfd 100644
--- a/test/unit/html_test.js
+++ b/test/unit/html_test.js
@@ -1,57 +1,70 @@
-const fs = require('fs');
-const path = require('path');
-
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const xpath = require('xpath');
-const Dom = require('@xmldom/xmldom').DOMParser;
-const {
-  scanForErrorMessages, removeNonInteractiveElements, minifyHtml, splitByChunks,
-} = require('../../lib/html');
+const fs = require('fs')
+const path = require('path')
+
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const xpath = require('xpath')
+const Dom = require('@xmldom/xmldom').DOMParser
+const { scanForErrorMessages, removeNonInteractiveElements, minifyHtml, splitByChunks } = require('../../lib/html')
 
 const opts = {
   interactiveElements: ['a', 'input', 'button', 'select', 'textarea', 'label', 'option'],
-  allowedAttrs: ['id', 'for', 'class', 'name', 'type', 'value', 'aria-labelledby', 'aria-label', 'label', 'placeholder', 'title', 'alt', 'src', 'role'],
+  allowedAttrs: [
+    'id',
+    'for',
+    'class',
+    'name',
+    'type',
+    'value',
+    'aria-labelledby',
+    'aria-label',
+    'label',
+    'placeholder',
+    'title',
+    'alt',
+    'src',
+    'role',
+  ],
   allowedRoles: ['button', 'checkbox', 'search', 'textbox', 'tab'],
   textElements: ['label'],
-};
+}
 
 describe('HTML module', () => {
-  let html;
+  let html
 
   before(() => {
     // Load HTML from a file
-  });
+  })
 
   describe('scanForErrorMessages', () => {
     xit('should scan HTML for error messages', () => {
       // Call the function with the loaded HTML
-      const errorMessages = scanForErrorMessages(html);
+      const errorMessages = scanForErrorMessages(html)
 
       // Add your assertions here
       // For example:
       // expect(errorMessages).to.have.lengthOf(3);
       // expect(errorMessages).to.include('Error 1');
       // expect(errorMessages).to.include('Error 2');
-    });
-  });
+    })
+  })
 
   describe('#removeNonInteractiveElements', () => {
     it('should cut out all non-interactive elements from GitHub HTML', async () => {
       // Call the function with the loaded HTML
-      html = fs.readFileSync(path.join(__dirname, '../data/github.html'), 'utf8');
-      const result = removeNonInteractiveElements(html, opts);
-      let doc = new Dom().parseFromString(result);
-      const nodes = xpath.select('//input[@name="q"]', doc);
-      expect(nodes).to.have.length(1);
-      expect(result).not.to.include('Let’s build from here');
-      const minified = await minifyHtml(result);
-      doc = new Dom().parseFromString(minified);
-      const nodes2 = xpath.select('//input[@name="q"]', doc);
-      expect(nodes2).to.have.length(1);
-    });
+      html = fs.readFileSync(path.join(__dirname, '../data/github.html'), 'utf8')
+      const result = removeNonInteractiveElements(html, opts)
+      let doc = new Dom().parseFromString(result)
+      const nodes = xpath.select('//input[@name="q"]', doc)
+      expect(nodes).to.have.length(1)
+      expect(result).not.to.include('Let’s build from here')
+      const minified = await minifyHtml(result)
+      doc = new Dom().parseFromString(minified)
+      const nodes2 = xpath.select('//input[@name="q"]', doc)
+      expect(nodes2).to.have.length(1)
+    })
 
     it('should keep interactive html elements', () => {
       html = `
@@ -65,10 +78,10 @@ describe('HTML module', () => {
         </button>
         </div>
         </div>
-        </div>`;
-      const result = removeNonInteractiveElements(html, opts);
-      expect(result).to.include('<button');
-    });
+        </div>`
+      const result = removeNonInteractiveElements(html, opts)
+      expect(result).to.include('<button')
+    })
 
     it('should keep menu bar', async () => {
       html = `<div class="mainnav-menu-body">
@@ -91,67 +104,67 @@ describe('HTML module', () => {
 </a>
       </li>
       </ul>
-    </div>`;
-      const result = await minifyHtml(removeNonInteractiveElements(html, opts));
-      expect(result).to.include('<button');
-      expect(result).to.include('<a');
-      expect(result).to.include('<svg');
-      expect(result).not.to.include('<path');
-    });
+    </div>`
+      const result = await minifyHtml(removeNonInteractiveElements(html, opts))
+      expect(result).to.include('<button')
+      expect(result).to.include('<a')
+      expect(result).to.include('<svg')
+      expect(result).not.to.include('<path')
+    })
 
     it('should cut out all non-interactive elements from HTML', () => {
       // Call the function with the loaded HTML
-      html = fs.readFileSync(path.join(__dirname, '../data/checkout.html'), 'utf8');
-      const result = removeNonInteractiveElements(html, opts);
-      expect(result).to.include('Name on card');
-      expect(result).to.not.include('<script');
-    });
+      html = fs.readFileSync(path.join(__dirname, '../data/checkout.html'), 'utf8')
+      const result = removeNonInteractiveElements(html, opts)
+      expect(result).to.include('Name on card')
+      expect(result).to.not.include('<script')
+    })
 
     it('should allow adding new elements', () => {
-      const html = '<div><h6>Hey</h6></div>';
+      const html = '<div><h6>Hey</h6></div>'
 
       const result = removeNonInteractiveElements(html, {
         textElements: ['h6'],
-      });
+      })
 
-      expect(result).to.include('<h6>Hey</h6>');
-    });
+      expect(result).to.include('<h6>Hey</h6>')
+    })
 
     it('should cut out all non-interactive elements from GitLab HTML', () => {
       // Call the function with the loaded HTML
-      html = fs.readFileSync(path.join(__dirname, '../data/gitlab.html'), 'utf8');
+      html = fs.readFileSync(path.join(__dirname, '../data/gitlab.html'), 'utf8')
       // console.log(html);
-      const result = removeNonInteractiveElements(html, opts);
+      const result = removeNonInteractiveElements(html, opts)
 
-      result.should.include('Get free trial');
-      result.should.include('Sign in');
-      result.should.include('<button');
-      const doc = new Dom().parseFromString(result);
-      const nodes = xpath.select('//input[@placeholder="Search"]', doc);
-      expect(nodes).to.have.length(1);
-    });
+      result.should.include('Get free trial')
+      result.should.include('Sign in')
+      result.should.include('<button')
+      const doc = new Dom().parseFromString(result)
+      const nodes = xpath.select('//input[@placeholder="Search"]', doc)
+      expect(nodes).to.have.length(1)
+    })
 
     it('should cut out and minify Testomatio HTML', () => {
       // Call the function with the loaded HTML
-      html = fs.readFileSync(path.join(__dirname, '../data/testomat.html'), 'utf8');
+      html = fs.readFileSync(path.join(__dirname, '../data/testomat.html'), 'utf8')
       // console.log(html);
-      const result = removeNonInteractiveElements(html, opts);
-      result.should.include('<svg class="md-icon md-icon-check-bold');
+      const result = removeNonInteractiveElements(html, opts)
+      result.should.include('<svg class="md-icon md-icon-check-bold')
       // console.log(await minifyHtml(result));
-    });
-  });
+    })
+  })
 
   describe('#splitByChunks', () => {
     it('should cut long htmls into chunks and add paths into them', () => {
       // Call the function with the loaded HTML
-      html = fs.readFileSync(path.join(__dirname, '../data/github.html'), 'utf8');
-      const result = splitByChunks(html, 10000);
-      expect(result).to.have.length(21);
+      html = fs.readFileSync(path.join(__dirname, '../data/github.html'), 'utf8')
+      const result = splitByChunks(html, 10000)
+      expect(result).to.have.length(21)
       // console.log(result[10])
       // expect(result[10].startsWith('<div data-turbo-body=""')).to.be.true;
       for (const chunk of result) {
-        expect(chunk.startsWith('<')).to.be.true;
+        expect(chunk.startsWith('<')).to.be.true
       }
-    });
-  });
-});
+    })
+  })
+})
diff --git a/test/unit/locator_test.js b/test/unit/locator_test.js
index dc21a19bf..41680548f 100644
--- a/test/unit/locator_test.js
+++ b/test/unit/locator_test.js
@@ -1,13 +1,13 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const { DOMParser } = require('@xmldom/xmldom');
-const xpath = require('xpath');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const { DOMParser } = require('@xmldom/xmldom')
+const xpath = require('xpath')
 
-const Locator = require('../../lib/locator');
+const Locator = require('../../lib/locator')
 
-let doc;
+let doc
 const xml = `<body>
   <span>Hey boy</span>
   <p>
@@ -193,277 +193,266 @@ const xml = `<body>
     </li>
   </ul>
 
-</body>`;
+</body>`
 
 describe('Locator', () => {
   beforeEach(() => {
-    doc = new DOMParser().parseFromString(xml, 'application/xhtml+xml');
-  });
+    doc = new DOMParser().parseFromString(xml, 'application/xhtml+xml')
+  })
 
   describe('constructor', () => {
     describe('with string argument', () => {
       it('should create css locator', () => {
-        const l = new Locator('#foo');
-        expect(l.type).to.equal('css');
-        expect(l.value).to.equal('#foo');
-        expect(l.toString()).to.equal('#foo');
-      });
+        const l = new Locator('#foo')
+        expect(l.type).to.equal('css')
+        expect(l.value).to.equal('#foo')
+        expect(l.toString()).to.equal('#foo')
+      })
 
       it('should create xpath locator', () => {
-        const l = new Locator('//foo[@bar="baz"]/*');
-        expect(l.type).to.equal('xpath');
-        expect(l.value).to.equal('//foo[@bar="baz"]/*');
-        expect(l.toString()).to.equal('//foo[@bar="baz"]/*');
-      });
+        const l = new Locator('//foo[@bar="baz"]/*')
+        expect(l.type).to.equal('xpath')
+        expect(l.value).to.equal('//foo[@bar="baz"]/*')
+        expect(l.toString()).to.equal('//foo[@bar="baz"]/*')
+      })
 
       it('should create fuzzy locator', () => {
-        const l = new Locator('foo');
-        expect(l.type).to.equal('fuzzy');
-        expect(l.value).to.equal('foo');
-        expect(l.toString()).to.equal('foo');
-      });
+        const l = new Locator('foo')
+        expect(l.type).to.equal('fuzzy')
+        expect(l.value).to.equal('foo')
+        expect(l.toString()).to.equal('foo')
+      })
 
       it('should create custom locator', () => {
-        const l = new Locator({ custom: 'foo' });
-        expect(l.type).to.equal('custom');
-        expect(l.value).to.equal('foo');
-        expect(l.toString()).to.equal('{custom: foo}');
-      });
+        const l = new Locator({ custom: 'foo' })
+        expect(l.type).to.equal('custom')
+        expect(l.value).to.equal('foo')
+        expect(l.toString()).to.equal('{custom: foo}')
+      })
 
       it('should create shadow locator', () => {
-        const l = new Locator({ shadow: ['my-app', 'recipe-hello-binding', 'ui-input', 'input.input'] });
-        expect(l.type).to.equal('shadow');
-        expect(l.value).to.deep.equal(['my-app', 'recipe-hello-binding', 'ui-input', 'input.input']);
-        expect(l.toString()).to.equal('{shadow: my-app,recipe-hello-binding,ui-input,input.input}');
-      });
+        const l = new Locator({ shadow: ['my-app', 'recipe-hello-binding', 'ui-input', 'input.input'] })
+        expect(l.type).to.equal('shadow')
+        expect(l.value).to.deep.equal(['my-app', 'recipe-hello-binding', 'ui-input', 'input.input'])
+        expect(l.toString()).to.equal('{shadow: my-app,recipe-hello-binding,ui-input,input.input}')
+      })
 
       it('should create described custom default type locator', () => {
-        const l = new Locator('foo', 'defaultLocator');
-        expect(l.type).to.equal('defaultLocator');
-        expect(l.value).to.equal('foo');
-        expect(l.toString()).to.equal('foo');
-      });
+        const l = new Locator('foo', 'defaultLocator')
+        expect(l.type).to.equal('defaultLocator')
+        expect(l.value).to.equal('foo')
+        expect(l.toString()).to.equal('foo')
+      })
 
       it('should create playwright locator - _react', () => {
-        const l = new Locator({ pw: '_react=button' });
-        expect(l.type).to.equal('pw');
-        expect(l.value).to.equal('_react=button');
-        expect(l.toString()).to.equal('{pw: _react=button}');
-      });
+        const l = new Locator({ pw: '_react=button' })
+        expect(l.type).to.equal('pw')
+        expect(l.value).to.equal('_react=button')
+        expect(l.toString()).to.equal('{pw: _react=button}')
+      })
 
       it('should create playwright locator - _vue', () => {
-        const l = new Locator({ pw: '_vue=button' });
-        expect(l.type).to.equal('pw');
-        expect(l.value).to.equal('_vue=button');
-        expect(l.toString()).to.equal('{pw: _vue=button}');
-      });
+        const l = new Locator({ pw: '_vue=button' })
+        expect(l.type).to.equal('pw')
+        expect(l.value).to.equal('_vue=button')
+        expect(l.toString()).to.equal('{pw: _vue=button}')
+      })
 
       it('should create playwright locator - data-testid', () => {
-        const l = new Locator({ pw: '[data-testid="directions"]' });
-        expect(l.type).to.equal('pw');
-        expect(l.value).to.equal('[data-testid="directions"]');
-        expect(l.toString()).to.equal('{pw: [data-testid="directions"]}');
-      });
-    });
+        const l = new Locator({ pw: '[data-testid="directions"]' })
+        expect(l.type).to.equal('pw')
+        expect(l.value).to.equal('[data-testid="directions"]')
+        expect(l.toString()).to.equal('{pw: [data-testid="directions"]}')
+      })
+    })
 
     describe('with object argument', () => {
       it('should create id locator', () => {
-        const l = new Locator({ id: 'foo' });
-        expect(l.type).to.equal('id');
-        expect(l.value).to.equal('foo');
-        expect(l.toString()).to.equal('{id: foo}');
-      });
+        const l = new Locator({ id: 'foo' })
+        expect(l.type).to.equal('id')
+        expect(l.value).to.equal('foo')
+        expect(l.toString()).to.equal('{id: foo}')
+      })
 
       it('should create described custom locator', () => {
-        const l = new Locator({ customLocator: '=foo' });
-        expect(l.type).to.equal('customLocator');
-        expect(l.value).to.equal('=foo');
-        expect(l.toString()).to.equal('{customLocator: =foo}');
-      });
-    });
+        const l = new Locator({ customLocator: '=foo' })
+        expect(l.type).to.equal('customLocator')
+        expect(l.value).to.equal('=foo')
+        expect(l.toString()).to.equal('{customLocator: =foo}')
+      })
+    })
 
     describe('with Locator object argument', () => {
       it('should create id locator', () => {
-        const l = new Locator(new Locator({ id: 'foo' }));
-        expect(l).to.eql(new Locator({ id: 'foo' }));
-        expect(l.type).to.equal('id');
-        expect(l.value).to.equal('foo');
-        expect(l.toString()).to.equal('{id: foo}');
-      });
-    });
-  });
+        const l = new Locator(new Locator({ id: 'foo' }))
+        expect(l).to.eql(new Locator({ id: 'foo' }))
+        expect(l.type).to.equal('id')
+        expect(l.value).to.equal('foo')
+        expect(l.toString()).to.equal('{id: foo}')
+      })
+    })
+  })
 
   it('should transform CSS to xpath', () => {
-    const l = new Locator('p > #user', 'css');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1);
-    expect(nodes[0].firstChild.data).to.eql('davert');
-  });
+    const l = new Locator('p > #user', 'css')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1)
+    expect(nodes[0].firstChild.data).to.eql('davert')
+  })
+
+  it('should transform CSS having has pseudo to xpath', () => {
+    const l = new Locator('#submit-element:has(button)', 'css')
+    const convertedXpath = l.toXPath()
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(convertedXpath).to.equal(".//*[(./@id = 'submit-element' and .//button)]")
+    expect(nodes).to.have.length(1)
+    expect(nodes[0].firstChild.data.trim()).to.eql('')
+  })
 
   it('should build locator to match element by attr', () => {
-    const l = Locator.build('input').withAttr({ 'data-value': 'yes' });
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1);
-  });
+    const l = Locator.build('input').withAttr({ 'data-value': 'yes' })
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1)
+  })
 
   it('should build locator to match element by class', () => {
-    const l = Locator.build('div').withClassAttr('form-');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(9);
-  });
+    const l = Locator.build('div').withClassAttr('form-')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(9)
+  })
 
   it('should build locator to match element containing a text', () => {
-    const l = Locator.build('span').withText('Hey');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1);
-  });
+    const l = Locator.build('span').withText('Hey')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1)
+  })
 
   it('should build locator to match element by exact text', () => {
-    const l = Locator.build('span').withTextEquals('Hey boy');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1);
-  });
+    const l = Locator.build('span').withTextEquals('Hey boy')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1)
+  })
 
   it('should build locator to match element by position', () => {
-    const l = Locator.build('#fieldset-buttons')
-      .find('//tr')
-      .first()
-      .find('td')
-      .at(2);
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('Edit');
-  });
+    const l = Locator.build('#fieldset-buttons').find('//tr').first().find('td').at(2)
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('Edit')
+  })
 
   it('should build complex locator', () => {
-    const l = Locator.build('#fieldset-buttons')
-      .find('tr')
-      .last()
-      .find('td')
-      .first();
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('Show');
-  });
+    const l = Locator.build('#fieldset-buttons').find('tr').last().find('td').first()
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('Show')
+  })
 
   it('should select a by label', () => {
-    const l = Locator.build('a')
-      .withAttr({ href: '#' })
-      .inside(Locator.build('label').withText('Hello'));
+    const l = Locator.build('a').withAttr({ href: '#' }).inside(Locator.build('label').withText('Hello'))
 
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(2, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('Please click', l.toXPath());
-  });
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(2, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('Please click', l.toXPath())
+  })
 
   it('should select child element by name', () => {
-    const l = Locator.build('.form-field')
-      .withDescendant(Locator.build('//input[@name="name1"]'));
-    const nodes = xpath.select(l.toXPath(), doc);
+    const l = Locator.build('.form-field').withDescendant(Locator.build('//input[@name="name1"]'))
+    const nodes = xpath.select(l.toXPath(), doc)
 
-    expect(nodes).to.have.length(1, l.toXPath());
-  });
+    expect(nodes).to.have.length(1, l.toXPath())
+  })
 
   it('should select element by siblings', () => {
-    const l = Locator.build('//table')
-      .withChild(Locator.build('tr')
-        .withChild('td')
-        .withText('Also Edit'));
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-  });
+    const l = Locator.build('//table').withChild(Locator.build('tr').withChild('td').withText('Also Edit'))
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+  })
 
   it('should throw an error when xpath with round brackets is nested', () => {
     expect(() => {
-      Locator.build('tr').find('(./td)[@id="id"]');
-    }).to.throw('round brackets');
-  });
+      Locator.build('tr').find('(./td)[@id="id"]')
+    }).to.throw('round brackets')
+  })
 
   it('should find element with class name contains hyphen', () => {
-    const l = Locator.build('').find('.n-1').first();
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-  });
+    const l = Locator.build('').find('.n-1').first()
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+  })
 
   it('should throw an error when locator with specific position is nested', () => {
     expect(() => {
-      Locator.build('tr').withChild(Locator.build('td').first());
-    }).to.throw('round brackets');
-  });
+      Locator.build('tr').withChild(Locator.build('td').first())
+    }).to.throw('round brackets')
+  })
 
   it('should not select element by deep nested siblings', () => {
-    const l = Locator.build('//table')
-      .withChild('td');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(0, l.toXPath());
-  });
+    const l = Locator.build('//table').withChild('td')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(0, l.toXPath())
+  })
 
   it('should select element by siblings', () => {
-    const l = Locator.build('//table')
-      .find('td')
-      .after(Locator.build('td').withText('Also Edit'))
-      .first();
+    const l = Locator.build('//table').find('td').after(Locator.build('td').withText('Also Edit')).first()
 
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('Also Delete', l.toXPath());
-  });
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('Also Delete', l.toXPath())
+  })
 
   it('should translate locator to string', () => {
-    const l = Locator.build('//table')
-      .find('td')
-      .as('cell');
-    expect(l.toString()).to.eql('cell');
-  });
+    const l = Locator.build('//table').find('td').as('cell')
+    expect(l.toString()).to.eql('cell')
+  })
 
   it('should be able to add custom locator strategy', () => {
     Locator.addFilter((selector, locator) => {
       if (selector.data) {
-        locator.type = 'css';
-        locator.value = `[data-element=${locator.value}]`;
+        locator.type = 'css'
+        locator.value = `[data-element=${locator.value}]`
       }
-    });
-    const l = Locator.build({ data: 'name' });
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('davert', l.toXPath());
-    Locator.filters = [];
-  });
+    })
+    const l = Locator.build({ data: 'name' })
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('davert', l.toXPath())
+    Locator.filters = []
+  })
 
   it('should be able to add custom locator strategy', () => {
     Locator.addFilter((providedLocator, locator) => {
       if (typeof providedLocator === 'string') {
         // this is a string
         if (providedLocator[0] === '=') {
-          locator.value = `.//*[text()='${providedLocator.substring(1)}']`;
-          locator.type = 'xpath';
+          locator.value = `.//*[text()='${providedLocator.substring(1)}']`
+          locator.type = 'xpath'
         }
       }
-    });
-    const l = Locator.build('=Sign In');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.data).to.eql('Sign In', l.toXPath());
-    Locator.filters = [];
-  });
+    })
+    const l = Locator.build('=Sign In')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.data).to.eql('Sign In', l.toXPath())
+    Locator.filters = []
+  })
 
   it('should be able to locate complicated locator', () => {
-    const l = Locator.build('.ps-menu-button').withText('Authoring').inside('.ps-submenu-root:nth-child(3)');
+    const l = Locator.build('.ps-menu-button').withText('Authoring').inside('.ps-submenu-root:nth-child(3)')
 
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(1, l.toXPath());
-    expect(nodes[0].firstChild.nextSibling.firstChild.data).to.eql('Authoring', l.toXPath());
-  });
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(1, l.toXPath())
+    expect(nodes[0].firstChild.nextSibling.firstChild.data).to.eql('Authoring', l.toXPath())
+  })
 
   it('should find element with last of type with text', () => {
-    const l = Locator.build('.p-confirm-popup:last-of-type button').withText('delete');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(0, l.toXPath());
-  });
+    const l = Locator.build('.p-confirm-popup:last-of-type button').withText('delete')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(0, l.toXPath())
+  })
 
   it('should find element with last of type without text', () => {
-    const l = Locator.build('.p-confirm-popup:last-of-type button');
-    const nodes = xpath.select(l.toXPath(), doc);
-    expect(nodes).to.have.length(0, l.toXPath());
-  });
-});
+    const l = Locator.build('.p-confirm-popup:last-of-type button')
+    const nodes = xpath.select(l.toXPath(), doc)
+    expect(nodes).to.have.length(0, l.toXPath())
+  })
+})
diff --git a/test/unit/output_test.js b/test/unit/output_test.js
index aa988af40..1f964d815 100644
--- a/test/unit/output_test.js
+++ b/test/unit/output_test.js
@@ -1,67 +1,67 @@
-let chai;
-let expect;
-import('chai').then(_chai => {
-  chai = _chai;
-  expect = chai.expect;
-  chai.use(sinonChai);
-});
-const sinonChai = require('sinon-chai');
+let chai
+let expect
+import('chai').then((_chai) => {
+  chai = _chai
+  expect = chai.expect
+  chai.use(sinonChai)
+})
+const sinonChai = require('sinon-chai')
 
-const sinon = require('sinon');
+const sinon = require('sinon')
 
-const originalOutput = require('../../lib/output');
+const originalOutput = require('../../lib/output')
 
-let output;
+let output
 
 describe('Output', () => {
   beforeEach(() => {
-    sinon.spy(console, 'log');
-    output = originalOutput;
-  });
+    sinon.spy(console, 'log')
+    output = originalOutput
+  })
 
   it('should allow the output level to be set', () => {
-    const expectedLevel = 2;
-    output.level(expectedLevel);
-    expect(output.level()).to.equal(expectedLevel);
-  });
+    const expectedLevel = 2
+    output.level(expectedLevel)
+    expect(output.level()).to.equal(expectedLevel)
+  })
 
   it('should allow the process to be set', () => {
     const expectedProcess = {
       profile: 'firefox',
-    };
+    }
 
-    output.process(expectedProcess);
-    expect(output.process()).to.equal(`[${expectedProcess}]`);
-  });
+    output.process(expectedProcess)
+    expect(output.process()).to.equal(`[${expectedProcess}]`)
+  })
 
   it('should allow debug messages when output level >= 2', () => {
-    const debugMsg = 'Dear Henrietta';
+    const debugMsg = 'Dear Henrietta'
 
-    output.level(0);
-    output.debug(debugMsg);
-    expect(console.log).not.to.be.called;
+    output.level(0)
+    output.debug(debugMsg)
+    expect(console.log).not.to.be.called
 
-    output.level(1);
-    output.debug(debugMsg);
-    expect(console.log).not.to.be.called;
+    output.level(1)
+    output.debug(debugMsg)
+    expect(console.log).not.to.be.called
 
-    output.level(2);
-    output.debug(debugMsg);
-    expect(console.log).to.have.been.called;
+    output.level(2)
+    output.debug(debugMsg)
+    expect(console.log).to.have.been.called
 
-    output.level(3);
-    output.debug(debugMsg);
-    expect(console.log).to.have.been.calledTwice;
-  });
+    output.level(3)
+    output.debug(debugMsg)
+    expect(console.log).to.have.been.calledTwice
+  })
 
   it('should not throwing error when using non predefined system color for say function', () => {
-    const debugMsg = 'Dear Henrietta';
+    const debugMsg = 'Dear Henrietta'
 
-    output.say(debugMsg, 'orange');
-    expect(console.log).to.have.been.called;
-  });
+    output.say(debugMsg, 'orange')
+    expect(console.log).to.have.been.called
+  })
 
   afterEach(() => {
-    console.log.restore();
-  });
-});
+    console.log.restore()
+  })
+})
diff --git a/test/unit/parser_test.js b/test/unit/parser_test.js
index 1f7179956..331d3b50e 100644
--- a/test/unit/parser_test.js
+++ b/test/unit/parser_test.js
@@ -1,8 +1,8 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const parser = require('../../lib/parser');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const parser = require('../../lib/parser')
 
 /* eslint-disable no-unused-vars */
 class Obj {
@@ -13,7 +13,7 @@ class Obj {
   method3(locator, context) {}
 
   async method4(locator, context) {
-    return false;
+    return false
   }
 
   method5({ locator, sec }) {}
@@ -23,31 +23,36 @@ const fixturesDestructuredArgs = [
   'function * namedFn({locator, sec}) {}',
   '({locator, sec}) => {}',
   '({locator, sec}) => {}',
-];
+]
 
 describe('parser', () => {
-  const obj = new Obj();
+  const obj = new Obj()
 
   describe('#getParamsToString', () => {
     it('should get params for normal function', () => {
-      expect(parser.getParamsToString(obj.method1)).to.eql('locator, sec');
-    });
+      expect(parser.getParamsToString(obj.method1)).to.eql('locator, sec')
+    })
 
     it('should get params for async function', () => {
-      expect(parser.getParamsToString(obj.method4)).to.eql('locator, context');
-    });
-    fixturesDestructuredArgs.forEach(arg => {
+      expect(parser.getParamsToString(obj.method4)).to.eql('locator, context')
+    })
+    fixturesDestructuredArgs.forEach((arg) => {
       it(`should get params for anonymous function with destructured args | ${arg}`, () => {
-        expect(parser.getParams(arg)).to.eql(['locator', 'sec']);
-      });
-    });
+        expect(parser.getParams(arg)).to.eql(['locator', 'sec'])
+      })
+    })
 
     it('should get params for anonymous function with destructured args', () => {
-      expect(parser.getParams(({ locator, sec }, { first, second }) => {})).to.eql(['locator', 'sec', 'first', 'second']);
-    });
+      expect(parser.getParams(({ locator, sec }, { first, second }) => {})).to.eql([
+        'locator',
+        'sec',
+        'first',
+        'second',
+      ])
+    })
 
     it('should get params for class method with destructured args', () => {
-      expect(parser.getParams(obj.method5)).to.eql(['locator', 'sec']);
-    });
-  });
-});
+      expect(parser.getParams(obj.method5)).to.eql(['locator', 'sec'])
+    })
+  })
+})
diff --git a/test/unit/recorder_test.js b/test/unit/recorder_test.js
index 580bacc60..e0c0b0939 100644
--- a/test/unit/recorder_test.js
+++ b/test/unit/recorder_test.js
@@ -1,99 +1,127 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
 
-const recorder = require('../../lib/recorder');
+const recorder = require('../../lib/recorder')
 
 describe('Recorder', () => {
-  beforeEach(() => recorder.start());
+  beforeEach(() => recorder.start())
 
   it('should create a promise', () => {
-    expect(recorder.promise()).to.be.instanceof(Promise);
-  });
+    expect(recorder.promise()).to.be.instanceof(Promise)
+  })
 
   it('should execute error handler on error', (done) => {
-    recorder.errHandler(() => done());
-    recorder.throw(new Error('err'));
-    recorder.catch();
-  });
+    recorder.errHandler(() => done())
+    recorder.throw(new Error('err'))
+    recorder.catch()
+  })
 
   describe('#session', () => {
     it('can be started saving previous promise chain', () => {
-      let order = '';
-      recorder.add(() => order += 'a');
+      let order = ''
+      recorder.add(() => (order += 'a'))
       recorder.add(() => {
-        recorder.session.start();
-        recorder.add(() => order += 'c');
-        recorder.add(() => order += 'd');
-      });
-      recorder.add(() => recorder.session.restore());
-      recorder.add(() => order += 'b');
-      return recorder.promise()
-        .then(() => expect(order).is.equal('acdb'));
-    });
-  });
+        recorder.session.start()
+        recorder.add(() => (order += 'c'))
+        recorder.add(() => (order += 'd'))
+      })
+      recorder.add(() => recorder.session.restore())
+      recorder.add(() => (order += 'b'))
+      return recorder.promise().then(() => expect(order).is.equal('acdb'))
+    })
+  })
 
   describe('#add', () => {
     it('should add steps to promise', () => {
-      let counter = 0;
-      recorder.add(() => counter++);
-      recorder.add(() => counter++);
-      recorder.add(() => expect(counter).eql(2));
-      return recorder.promise();
-    });
+      let counter = 0
+      recorder.add(() => counter++)
+      recorder.add(() => counter++)
+      recorder.add(() => expect(counter).eql(2))
+      return recorder.promise()
+    })
 
     it('should not add steps when stopped', () => {
-      let counter = 0;
-      recorder.add(() => counter++);
-      recorder.stop();
-      recorder.add(() => counter++);
-      return recorder.promise()
-        .then(() => expect(counter).eql(1));
-    });
-  });
+      let counter = 0
+      recorder.add(() => counter++)
+      recorder.stop()
+      recorder.add(() => counter++)
+      return recorder.promise().then(() => expect(counter).eql(1))
+    })
+  })
 
   describe('#retry', () => {
     it('should retry failed steps when asked', () => {
-      let counter = 0;
-      recorder.retry(2);
-      recorder.add(() => {
-        counter++;
-        if (counter < 3) {
-          throw new Error('ups');
-        }
-      }, undefined, undefined, true);
-      return recorder.promise();
-    });
+      let counter = 0
+      recorder.retry(2)
+      recorder.add(
+        () => {
+          counter++
+          if (counter < 3) {
+            throw new Error('ups')
+          }
+        },
+        undefined,
+        undefined,
+        true,
+      )
+      return recorder.promise()
+    })
 
     it('should create a chain of retries', () => {
-      let counter = 0;
-      const errorText = 'noerror';
-      recorder.retry({ retries: 2, when: (err) => { return err.message === errorText; } });
-      recorder.retry({ retries: 2, when: (err) => { return err.message === 'othererror'; } });
+      let counter = 0
+      const errorText = 'noerror'
+      recorder.retry({
+        retries: 2,
+        when: (err) => {
+          return err.message === errorText
+        },
+      })
+      recorder.retry({
+        retries: 2,
+        when: (err) => {
+          return err.message === 'othererror'
+        },
+      })
 
-      recorder.add(() => {
-        counter++;
-        if (counter < 3) {
-          throw new Error(errorText);
-        }
-      }, undefined, undefined, true);
-      return recorder.promise();
-    });
+      recorder.add(
+        () => {
+          counter++
+          if (counter < 3) {
+            throw new Error(errorText)
+          }
+        },
+        undefined,
+        undefined,
+        true,
+      )
+      return recorder.promise()
+    })
 
     it('should prefer opts for non-when retry when possible', () => {
-      let counter = 0;
-      const errorText = 'noerror';
-      recorder.retry({ retries: 2 });
-      recorder.retry({ retries: 100, when: (err) => { return err.message === errorText; } });
+      let counter = 0
+      const errorText = 'noerror'
+      recorder.retry({ retries: 2 })
+      recorder.retry({
+        retries: 100,
+        when: (err) => {
+          return err.message === errorText
+        },
+      })
 
-      recorder.add(() => {
-        counter++;
-        if (counter < 3) {
-          throw new Error(errorText);
-        }
-      }, undefined, undefined, true);
-      return recorder.promise();
-    });
-  });
-});
+      recorder.add(
+        () => {
+          counter++
+          if (counter < 3) {
+            throw new Error(errorText)
+          }
+        },
+        undefined,
+        undefined,
+        true,
+      )
+      return recorder.promise()
+    })
+  })
+})
diff --git a/test/unit/scenario_test.js b/test/unit/scenario_test.js
index 73047a93c..c9f5c4af7 100644
--- a/test/unit/scenario_test.js
+++ b/test/unit/scenario_test.js
@@ -1,96 +1,99 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const sinon = require('sinon');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const sinon = require('sinon')
 
-const scenario = require('../../lib/scenario');
-const recorder = require('../../lib/recorder');
-const event = require('../../lib/event');
+const scenario = require('../../lib/scenario')
+const recorder = require('../../lib/recorder')
+const event = require('../../lib/event')
 
-let test;
-let fn;
-let before;
-let after;
-let beforeSuite;
-let afterSuite;
-let failed;
-let started;
+let test
+let fn
+let before
+let after
+let beforeSuite
+let afterSuite
+let failed
+let started
 
 describe('Scenario', () => {
   beforeEach(() => {
-    test = { timeout: () => { } };
-    fn = sinon.spy();
-    test.fn = fn;
-  });
-  beforeEach(() => recorder.reset());
-  afterEach(() => event.cleanDispatcher());
+    test = { timeout: () => {} }
+    fn = sinon.spy()
+    test.fn = fn
+  })
+  beforeEach(() => recorder.reset())
+  afterEach(() => event.cleanDispatcher())
 
   it('should wrap test function', () => {
-    scenario.test(test).fn(() => {});
-    expect(fn.called).is.ok;
-  });
+    scenario.test(test).fn(() => {})
+    expect(fn.called).is.ok
+  })
 
   it('should work with async func', () => {
-    let counter = 0;
+    let counter = 0
     test.fn = () => {
       recorder.add('test', async () => {
-        await counter++;
-        await counter++;
-        await counter++;
-        counter++;
-      });
-    };
+        await counter++
+        await counter++
+        await counter++
+        counter++
+      })
+    }
 
-    scenario.setup();
-    scenario.test(test).fn(() => null);
-    recorder.add('validation', () => expect(counter).to.eq(4));
-    return recorder.promise();
-  });
+    scenario.setup()
+    scenario.test(test).fn(() => null)
+    recorder.add('validation', () => expect(counter).to.eq(4))
+    return recorder.promise()
+  })
 
   describe('events', () => {
     beforeEach(() => {
-      event.dispatcher.on(event.test.before, before = sinon.spy());
-      event.dispatcher.on(event.test.after, after = sinon.spy());
-      event.dispatcher.on(event.test.started, started = sinon.spy());
-      event.dispatcher.on(event.suite.before, beforeSuite = sinon.spy());
-      event.dispatcher.on(event.suite.after, afterSuite = sinon.spy());
-      scenario.suiteSetup();
-      scenario.setup();
-    });
+      event.dispatcher.on(event.test.before, (before = sinon.spy()))
+      event.dispatcher.on(event.test.after, (after = sinon.spy()))
+      event.dispatcher.on(event.test.started, (started = sinon.spy()))
+      event.dispatcher.on(event.suite.before, (beforeSuite = sinon.spy()))
+      event.dispatcher.on(event.suite.after, (afterSuite = sinon.spy()))
+      scenario.suiteSetup()
+      scenario.setup()
+    })
 
     it('should fire events', () => {
-      scenario.test(test).fn(() => null);
-      expect(started.called).is.ok;
-      scenario.teardown();
-      scenario.suiteTeardown();
-      return recorder.promise()
+      scenario.test(test).fn(() => null)
+      expect(started.called).is.ok
+      scenario.teardown()
+      scenario.suiteTeardown()
+      return recorder
+        .promise()
         .then(() => expect(beforeSuite.called).is.ok)
         .then(() => expect(afterSuite.called).is.ok)
         .then(() => expect(before.called).is.ok)
-        .then(() => expect(after.called).is.ok);
-    });
+        .then(() => expect(after.called).is.ok)
+    })
 
     it('should fire failed event on error', () => {
-      event.dispatcher.on(event.test.failed, failed = sinon.spy());
-      scenario.setup();
+      event.dispatcher.on(event.test.failed, (failed = sinon.spy()))
+      scenario.setup()
       test.fn = () => {
-        throw new Error('ups');
-      };
-      scenario.test(test).fn(() => {});
-      return recorder.promise()
+        throw new Error('ups')
+      }
+      scenario.test(test).fn(() => {})
+      return recorder
+        .promise()
         .then(() => expect(failed.called).is.ok)
-        .catch(() => null);
-    });
+        .catch(() => null)
+    })
 
     it('should fire failed event on async error', () => {
       test.fn = () => {
-        recorder.throw(new Error('ups'));
-      };
-      scenario.test(test).fn(() => {});
-      return recorder.promise()
+        recorder.throw(new Error('ups'))
+      }
+      scenario.test(test).fn(() => {})
+      return recorder
+        .promise()
         .then(() => expect(failed.called).is.ok)
-        .catch(() => null);
-    });
-  });
-});
+        .catch(() => null)
+    })
+  })
+})
diff --git a/test/unit/secret_test.js b/test/unit/secret_test.js
index ab251dd11..6396b90cb 100644
--- a/test/unit/secret_test.js
+++ b/test/unit/secret_test.js
@@ -1,19 +1,19 @@
-const { expect } = require('expect');
-const Secret = require('../../lib/secret');
+const { expect } = require('expect')
+const Secret = require('../../lib/secret')
 
 describe('Secret tests', () => {
   it('should be the Secret instance', () => {
-    const string = Secret.secret('hello');
-    expect(string).toBeInstanceOf(Secret);
-  });
+    const string = Secret.secret('hello')
+    expect(string).toBeInstanceOf(Secret)
+  })
 
   it('should be the Secret instance when using as object', () => {
-    const obj = Secret.secret({ password: 'world' }, 'password');
-    expect(obj.password).toBeInstanceOf(Secret);
-  });
+    const obj = Secret.secret({ password: 'world' }, 'password')
+    expect(obj.password).toBeInstanceOf(Secret)
+  })
 
   it('should mask the field when provided', () => {
-    const obj = Secret.secret({ password: 'world' }, 'password');
-    expect(obj.password.getMasked()).toBe('*****');
-  });
-});
+    const obj = Secret.secret({ password: 'world' }, 'password')
+    expect(obj.password.getMasked()).toBe('*****')
+  })
+})
diff --git a/test/unit/steps_test.js b/test/unit/steps_test.js
index e1ebb7561..3fbcec6f1 100644
--- a/test/unit/steps_test.js
+++ b/test/unit/steps_test.js
@@ -1,256 +1,256 @@
-const sinon = require('sinon');
+const sinon = require('sinon')
 
-const Step = require('../../lib/step');
-const { MetaStep } = require('../../lib/step');
-const event = require('../../lib/event');
-const { secret } = require('../../lib/secret');
+const Step = require('../../lib/step')
+const { MetaStep } = require('../../lib/step')
+const event = require('../../lib/event')
+const { secret } = require('../../lib/secret')
 
-let expect;
+let expect
 
-import('chai').then(chai => {
-  expect = chai.expect;
-  chai.use(require('chai-as-promised'));
-});
+import('chai').then((chai) => {
+  expect = chai.expect
+  chai.use(require('chai-as-promised'))
+})
 
-let step;
-let action;
+let step
+let action
 
 describe('Steps', () => {
   describe('Step', () => {
     beforeEach(() => {
-      action = sinon.spy(() => 'done');
-      step = new Step({ doSomething: action }, 'doSomething');
-    });
+      action = sinon.spy(() => 'done')
+      step = new Step({ doSomething: action }, 'doSomething')
+    })
 
     it('has name', () => {
-      expect(step.name).eql('doSomething');
-    });
+      expect(step.name).eql('doSomething')
+    })
 
     it('should convert method names for output', () => {
-      expect(step.humanize()).eql('do something');
-    });
+      expect(step.humanize()).eql('do something')
+    })
 
     it('should convert arguments for output', () => {
-      step.args = ['word', 1];
-      expect(step.humanizeArgs()).eql('"word", 1');
+      step.args = ['word', 1]
+      expect(step.humanizeArgs()).eql('"word", 1')
 
-      step.args = [['some', 'data'], 1];
-      expect(step.humanizeArgs()).eql('["some","data"], 1');
+      step.args = [['some', 'data'], 1]
+      expect(step.humanizeArgs()).eql('["some","data"], 1')
 
-      step.args = [{ css: '.class' }];
-      expect(step.humanizeArgs()).eql('{"css":".class"}');
+      step.args = [{ css: '.class' }]
+      expect(step.humanizeArgs()).eql('{"css":".class"}')
 
-      let testUndefined;
-      step.args = [testUndefined, 'undefined'];
-      expect(step.humanizeArgs()).eql(', "undefined"');
+      let testUndefined
+      step.args = [testUndefined, 'undefined']
+      expect(step.humanizeArgs()).eql(', "undefined"')
 
-      step.args = [secret('word'), 1];
-      expect(step.humanizeArgs()).eql('*****, 1');
-    });
+      step.args = [secret('word'), 1]
+      expect(step.humanizeArgs()).eql('*****, 1')
+    })
 
     it('should provide nice output', () => {
-      step.args = [1, 'yo'];
-      expect(step.toString()).eql('I do something 1, "yo"');
-    });
+      step.args = [1, 'yo']
+      expect(step.toString()).eql('I do something 1, "yo"')
+    })
 
     it('should provide code output', () => {
-      step.args = [1, 'yo'];
-      expect(step.toCode()).eql('I.doSomething(1, "yo")');
-    });
+      step.args = [1, 'yo']
+      expect(step.toCode()).eql('I.doSomething(1, "yo")')
+    })
 
     it('should set status for Step and MetaStep if exist', () => {
-      const metaStep = new MetaStep({ doSomethingMS: action }, 'doSomethingMS');
-      step.metaStep = metaStep;
-      step.run();
-      expect(step.metaStep.status).eq('success');
-    });
+      const metaStep = new MetaStep({ doSomethingMS: action }, 'doSomethingMS')
+      step.metaStep = metaStep
+      step.run()
+      expect(step.metaStep.status).eq('success')
+    })
 
     it('should set status only for Step when MetaStep not exist', () => {
-      step.run();
-      expect(step.metaStep);
-    });
+      step.run()
+      expect(step.metaStep)
+    })
 
     describe('#run', () => {
-      afterEach(() => event.cleanDispatcher());
+      afterEach(() => event.cleanDispatcher())
 
       it('should run step', () => {
-        expect(step.status).is.equal('pending');
-        const res = step.run();
-        expect(res).is.equal('done');
-        expect(action.called);
-        expect(step.status).is.equal('success');
-      });
-    });
-  });
+        expect(step.status).is.equal('pending')
+        const res = step.run()
+        expect(res).is.equal('done')
+        expect(action.called)
+        expect(step.status).is.equal('success')
+      })
+    })
+  })
 
   describe('MetaStep', () => {
     // let metaStep;
     beforeEach(() => {
-      action = sinon.spy(() => 'done');
-      asyncAction = sinon.spy(async () => 'done');
+      action = sinon.spy(() => 'done')
+      asyncAction = sinon.spy(async () => 'done')
       // metaStep = new MetaStep({ doSomething: action }, 'doSomething');
-    });
+    })
 
     describe('#isBDD', () => {
-      ['Given', 'When', 'Then', 'And'].forEach(key => {
+      ;['Given', 'When', 'Then', 'And'].forEach((key) => {
         it(`[${key}] #isBdd should return true if it BDD style`, () => {
-          const metaStep = new MetaStep(key, 'I need to open Google');
-          expect(metaStep.isBDD()).to.be.true;
-        });
-      });
-    });
+          const metaStep = new MetaStep(key, 'I need to open Google')
+          expect(metaStep.isBDD()).to.be.true
+        })
+      })
+    })
 
     it('#isWithin should return true if it Within step', () => {
-      const metaStep = new MetaStep('Within', 'clickByName');
-      expect(metaStep.isWithin()).to.be.true;
-    });
+      const metaStep = new MetaStep('Within', 'clickByName')
+      expect(metaStep.isWithin()).to.be.true
+    })
 
     describe('#toString', () => {
-      ['Given', 'When', 'Then', 'And'].forEach(key => {
+      ;['Given', 'When', 'Then', 'And'].forEach((key) => {
         it(`[${key}] should correct print BDD step`, () => {
-          const metaStep = new MetaStep(key, 'I need to open Google');
-          expect(metaStep.toString()).to.include(`${key} I need to open Google`);
-        });
-      });
+          const metaStep = new MetaStep(key, 'I need to open Google')
+          expect(metaStep.toString()).to.include(`${key} I need to open Google`)
+        })
+      })
 
       it('should correct print step info for simple PageObject', () => {
-        const metaStep = new MetaStep('MyPage', 'clickByName');
-        expect(metaStep.toString()).to.include('On MyPage: click by name');
-      });
+        const metaStep = new MetaStep('MyPage', 'clickByName')
+        expect(metaStep.toString()).to.include('On MyPage: click by name')
+      })
 
       it('should correct print step info for custom step', () => {
-        const metaStep = new MetaStep('I', 'clickByName');
-        expect(metaStep.toString()).to.include('I click by name');
-      });
+        const metaStep = new MetaStep('I', 'clickByName')
+        expect(metaStep.toString()).to.include('I click by name')
+      })
 
       it('should correct print step with args', () => {
-        const metaStep = new MetaStep('MyPage', 'clickByName');
-        const msg = 'first message';
-        const msg2 = 'second message';
-        const fn = (msg) => `result from callback = ${msg}`;
-        metaStep.run.bind(metaStep, fn)(msg, msg2);
-        expect(metaStep.toString()).eql(`On MyPage: click by name "${msg}", "${msg2}"`);
-      });
-    });
+        const metaStep = new MetaStep('MyPage', 'clickByName')
+        const msg = 'first message'
+        const msg2 = 'second message'
+        const fn = (msg) => `result from callback = ${msg}`
+        metaStep.run.bind(metaStep, fn)(msg, msg2)
+        expect(metaStep.toString()).eql(`On MyPage: click by name "${msg}", "${msg2}"`)
+      })
+    })
 
     it('#setContext should correct init context variable', () => {
-      const context = { prop: 'prop' };
-      const metaStep = new MetaStep('MyPage', 'clickByName');
-      metaStep.setContext(context);
-      expect(metaStep.context).eql(context);
-    });
+      const context = { prop: 'prop' }
+      const metaStep = new MetaStep('MyPage', 'clickByName')
+      metaStep.setContext(context)
+      expect(metaStep.context).eql(context)
+    })
 
     describe('#run', () => {
-      let metaStep;
-      let fn;
-      let boundedRun;
-      let boundedAsyncRun;
+      let metaStep
+      let fn
+      let boundedRun
+      let boundedAsyncRun
       beforeEach(() => {
-        metaStep = new MetaStep({ metaStepDoSomething: action }, 'metaStepDoSomething');
-        asyncMetaStep = new MetaStep({ metaStepDoSomething: asyncAction }, 'metaStepDoSomething');
-        fn = (msg) => `result from callback = ${msg}`;
-        asyncFn = async (msg) => `result from callback = ${msg}`;
-        boundedRun = metaStep.run.bind(metaStep, fn);
-        boundedAsyncRun = metaStep.run.bind(metaStep, asyncFn);
-      });
+        metaStep = new MetaStep({ metaStepDoSomething: action }, 'metaStepDoSomething')
+        asyncMetaStep = new MetaStep({ metaStepDoSomething: asyncAction }, 'metaStepDoSomething')
+        fn = (msg) => `result from callback = ${msg}`
+        asyncFn = async (msg) => `result from callback = ${msg}`
+        boundedRun = metaStep.run.bind(metaStep, fn)
+        boundedAsyncRun = metaStep.run.bind(metaStep, asyncFn)
+      })
 
       it('should return result from run callback function', () => {
-        const fn = () => 'result from callback';
-        expect(metaStep.run(fn)).eql('result from callback');
-      });
+        const fn = () => 'result from callback'
+        expect(metaStep.run(fn)).eql('result from callback')
+      })
 
       it('should return result from run async callback function', async () => {
-        const fn = async () => 'result from callback';
-        expect(await metaStep.run(fn)).eql('result from callback');
-      });
+        const fn = async () => 'result from callback'
+        expect(await metaStep.run(fn)).eql('result from callback')
+      })
 
       it('should return result when run is bound', () => {
-        const fn = () => 'result from callback';
-        const boundedRun = metaStep.run.bind(metaStep, fn);
-        expect(boundedRun()).eql('result from callback');
-      });
+        const fn = () => 'result from callback'
+        const boundedRun = metaStep.run.bind(metaStep, fn)
+        expect(boundedRun()).eql('result from callback')
+      })
 
       it('should return result when async run is bound', async () => {
-        const fn = async () => 'result from callback';
-        const boundedRun = metaStep.run.bind(metaStep, fn);
-        expect(await boundedRun()).eql('result from callback');
-      });
+        const fn = async () => 'result from callback'
+        const boundedRun = metaStep.run.bind(metaStep, fn)
+        expect(await boundedRun()).eql('result from callback')
+      })
 
       it('should correct init args when run is bound', () => {
-        const msg = 'arg message';
-        expect(boundedRun(msg)).eql(`result from callback = ${msg}`);
-      });
+        const msg = 'arg message'
+        expect(boundedRun(msg)).eql(`result from callback = ${msg}`)
+      })
 
       it('should correct init args when async run is bound', async () => {
-        const msg = 'arg message';
-        expect(await boundedAsyncRun(msg)).eql(`result from callback = ${msg}`);
-      });
+        const msg = 'arg message'
+        expect(await boundedAsyncRun(msg)).eql(`result from callback = ${msg}`)
+      })
 
       it('should init as metaStep in step', () => {
-        let step1;
-        let step2;
-        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1));
-        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2));
-        step1 = new Step({ doSomething: stepAction1 }, 'doSomething');
-        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2');
+        let step1
+        let step2
+        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1))
+        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2))
+        step1 = new Step({ doSomething: stepAction1 }, 'doSomething')
+        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2')
         boundedRun = metaStep.run.bind(metaStep, () => {
-          step1.run();
-          step2.run();
-        });
-        boundedRun();
-        expect(step1.metaStep).eql(metaStep);
-        expect(step2.metaStep).eql(metaStep);
-      });
+          step1.run()
+          step2.run()
+        })
+        boundedRun()
+        expect(step1.metaStep).eql(metaStep)
+        expect(step2.metaStep).eql(metaStep)
+      })
 
       it('should init as metaStep in step with async metaStep', async () => {
-        let step1;
-        let step2;
-        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1));
-        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2));
-        step1 = new Step({ doSomething: stepAction1 }, 'doSomething');
-        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2');
+        let step1
+        let step2
+        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1))
+        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2))
+        step1 = new Step({ doSomething: stepAction1 }, 'doSomething')
+        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2')
         boundedRun = asyncMetaStep.run.bind(asyncMetaStep, async () => {
-          step1.run();
-          await Promise.resolve('Oh wait, need to do something async stuff!!');
-          step2.run();
-          return Promise.resolve('Give me some promised return value');
-        });
-
-        const result = await boundedRun();
-        expect(step1.metaStep).eql(asyncMetaStep);
-        expect(step2.metaStep).eql(asyncMetaStep);
-        expect(result).eql('Give me some promised return value');
-      });
+          step1.run()
+          await Promise.resolve('Oh wait, need to do something async stuff!!')
+          step2.run()
+          return Promise.resolve('Give me some promised return value')
+        })
+
+        const result = await boundedRun()
+        expect(step1.metaStep).eql(asyncMetaStep)
+        expect(step2.metaStep).eql(asyncMetaStep)
+        expect(result).eql('Give me some promised return value')
+      })
 
       it('should fail if async method fails inside async metaStep', async () => {
-        let step1;
-        let step2;
-        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1));
-        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2));
-        step1 = new Step({ doSomething: stepAction1 }, 'doSomething');
-        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2');
+        let step1
+        let step2
+        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1))
+        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2))
+        step1 = new Step({ doSomething: stepAction1 }, 'doSomething')
+        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2')
         boundedRun = asyncMetaStep.run.bind(asyncMetaStep, async () => {
-          step1.run();
-          await Promise.reject(new Error('FAILED INSIDE ASYNC METHOD OF METASTEP'));
-          throw new Error('FAILED INSIDE METASTEP');
-        });
-        await expect(boundedRun()).to.be.rejectedWith('FAILED INSIDE ASYNC METHOD OF METASTEP');
-      });
+          step1.run()
+          await Promise.reject(new Error('FAILED INSIDE ASYNC METHOD OF METASTEP'))
+          throw new Error('FAILED INSIDE METASTEP')
+        })
+        await expect(boundedRun()).to.be.rejectedWith('FAILED INSIDE ASYNC METHOD OF METASTEP')
+      })
 
       it('should fail if async method fails', async () => {
-        let step1;
-        let step2;
-        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1));
-        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2));
-        step1 = new Step({ doSomething: stepAction1 }, 'doSomething');
-        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2');
+        let step1
+        let step2
+        const stepAction1 = sinon.spy(() => event.emit(event.step.before, step1))
+        const stepAction2 = sinon.spy(() => event.emit(event.step.before, step2))
+        step1 = new Step({ doSomething: stepAction1 }, 'doSomething')
+        step2 = new Step({ doSomething2: stepAction2 }, 'doSomething2')
         boundedRun = asyncMetaStep.run.bind(asyncMetaStep, async () => {
-          step1.run();
-          await Promise.resolve('Oh wait, need to do something async stuff!!');
-          throw new Error('FAILED INSIDE METASTEP');
-        });
-        await expect(boundedRun()).to.be.rejectedWith('FAILED INSIDE METASTEP');
-      });
-    });
-  });
-});
+          step1.run()
+          await Promise.resolve('Oh wait, need to do something async stuff!!')
+          throw new Error('FAILED INSIDE METASTEP')
+        })
+        await expect(boundedRun()).to.be.rejectedWith('FAILED INSIDE METASTEP')
+      })
+    })
+  })
+})
diff --git a/test/unit/ui_test.js b/test/unit/ui_test.js
index 338e65c83..5d3e0989e 100644
--- a/test/unit/ui_test.js
+++ b/test/unit/ui_test.js
@@ -1,234 +1,240 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const Mocha = require('mocha/lib/mocha');
-const Suite = require('mocha/lib/suite');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const Mocha = require('mocha/lib/mocha')
+const Suite = require('mocha/lib/suite')
 
-global.codeceptjs = require('../../lib');
-const makeUI = require('../../lib/ui');
+global.codeceptjs = require('../../lib')
+const makeUI = require('../../lib/ui')
 
 describe('ui', () => {
-  let suite;
-  let context;
+  let suite
+  let context
 
   beforeEach(() => {
-    context = {};
-    suite = new Suite('empty');
-    makeUI(suite);
-    suite.emit('pre-require', context, {}, new Mocha());
-  });
+    context = {}
+    suite = new Suite('empty')
+    makeUI(suite)
+    suite.emit('pre-require', context, {}, new Mocha())
+  })
 
   describe('basic constants', () => {
-    const constants = ['Before', 'Background', 'BeforeAll', 'After', 'AfterAll', 'Scenario', 'xScenario'];
+    const constants = ['Before', 'Background', 'BeforeAll', 'After', 'AfterAll', 'Scenario', 'xScenario']
 
     constants.forEach((c) => {
-      it(`context should contain ${c}`, () => expect(context[c]).is.ok);
-    });
-  });
+      it(`context should contain ${c}`, () => expect(context[c]).is.ok)
+    })
+  })
 
   describe('Feature', () => {
-    let suiteConfig;
+    let suiteConfig
 
     it('Feature should return featureConfig', () => {
-      suiteConfig = context.Feature('basic suite');
-      expect(suiteConfig.suite).is.ok;
-    });
+      suiteConfig = context.Feature('basic suite')
+      expect(suiteConfig.suite).is.ok
+    })
 
     it('should contain title', () => {
-      suiteConfig = context.Feature('basic suite');
-      expect(suiteConfig.suite).is.ok;
-      expect(suiteConfig.suite.title).eq('basic suite');
-      expect(suiteConfig.suite.fullTitle()).eq('basic suite:');
-    });
+      suiteConfig = context.Feature('basic suite')
+      expect(suiteConfig.suite).is.ok
+      expect(suiteConfig.suite.title).eq('basic suite')
+      expect(suiteConfig.suite.fullTitle()).eq('basic suite:')
+    })
 
     it('should contain tags', () => {
-      suiteConfig = context.Feature('basic suite');
-      expect(0).eq(suiteConfig.suite.tags.length);
+      suiteConfig = context.Feature('basic suite')
+      expect(0).eq(suiteConfig.suite.tags.length)
 
-      suiteConfig = context.Feature('basic suite @very @important');
-      expect(suiteConfig.suite).is.ok;
+      suiteConfig = context.Feature('basic suite @very @important')
+      expect(suiteConfig.suite).is.ok
 
-      suiteConfig.suite.tags.should.include('@very');
-      suiteConfig.suite.tags.should.include('@important');
+      suiteConfig.suite.tags.should.include('@very')
+      suiteConfig.suite.tags.should.include('@important')
 
-      suiteConfig.tag('@user');
-      suiteConfig.suite.tags.should.include('@user');
+      suiteConfig.tag('@user')
+      suiteConfig.suite.tags.should.include('@user')
 
-      suiteConfig.suite.tags.should.not.include('@slow');
-      suiteConfig.tag('slow');
-      suiteConfig.suite.tags.should.include('@slow');
-    });
+      suiteConfig.suite.tags.should.not.include('@slow')
+      suiteConfig.tag('slow')
+      suiteConfig.suite.tags.should.include('@slow')
+    })
 
     it('retries can be set', () => {
-      suiteConfig = context.Feature('basic suite');
-      suiteConfig.retry(3);
-      expect(3).eq(suiteConfig.suite.retries());
-    });
+      suiteConfig = context.Feature('basic suite')
+      suiteConfig.retry(3)
+      expect(3).eq(suiteConfig.suite.retries())
+    })
 
     it('timeout can be set', () => {
-      suiteConfig = context.Feature('basic suite');
-      expect(0).eq(suiteConfig.suite.timeout());
-      suiteConfig.timeout(3);
-      expect(3).eq(suiteConfig.suite.timeout());
-    });
+      suiteConfig = context.Feature('basic suite')
+      expect(0).eq(suiteConfig.suite.timeout())
+      suiteConfig.timeout(3)
+      expect(3).eq(suiteConfig.suite.timeout())
+    })
 
     it('helpers can be configured', () => {
-      suiteConfig = context.Feature('basic suite');
-      expect(!suiteConfig.suite.config);
-      suiteConfig.config('WebDriver', { browser: 'chrome' });
-      expect('chrome').eq(suiteConfig.suite.config.WebDriver.browser);
-      suiteConfig.config({ browser: 'firefox' });
-      expect('firefox').eq(suiteConfig.suite.config[0].browser);
+      suiteConfig = context.Feature('basic suite')
+      expect(!suiteConfig.suite.config)
+      suiteConfig.config('WebDriver', { browser: 'chrome' })
+      expect('chrome').eq(suiteConfig.suite.config.WebDriver.browser)
+      suiteConfig.config({ browser: 'firefox' })
+      expect('firefox').eq(suiteConfig.suite.config[0].browser)
       suiteConfig.config('WebDriver', () => {
-        return { browser: 'edge' };
-      });
-      expect('edge').eq(suiteConfig.suite.config.WebDriver.browser);
-    });
+        return { browser: 'edge' }
+      })
+      expect('edge').eq(suiteConfig.suite.config.WebDriver.browser)
+    })
 
     it('Feature can be skipped', () => {
-      suiteConfig = context.Feature.skip('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.Feature.skip('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature can be skipped via xFeature', () => {
-      suiteConfig = context.xFeature('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.xFeature('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature are not skipped by default', () => {
-      suiteConfig = context.Feature('not skipped suite');
-      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true');
+      suiteConfig = context.Feature('not skipped suite')
+      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true')
       // expect(suiteConfig.suite.opts, undefined, 'Features should have no skip info');
-    });
+    })
 
     it('Feature can be skipped', () => {
-      suiteConfig = context.Feature.skip('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.Feature.skip('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature can be skipped via xFeature', () => {
-      suiteConfig = context.xFeature('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.xFeature('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature are not skipped by default', () => {
-      suiteConfig = context.Feature('not skipped suite');
-      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true');
+      suiteConfig = context.Feature('not skipped suite')
+      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true')
       // expect(suiteConfig.suite.opts, undefined, 'Features should have no skip info');
-    });
+    })
 
     it('Feature can be skipped', () => {
-      suiteConfig = context.Feature.skip('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.Feature.skip('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature can be skipped via xFeature', () => {
-      suiteConfig = context.xFeature('skipped suite');
-      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true');
-      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.');
-      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo');
-    });
+      suiteConfig = context.xFeature('skipped suite')
+      expect(suiteConfig.suite.pending).eq(true, 'Skipped Feature must be contain pending === true')
+      expect(suiteConfig.suite.opts.skipInfo.message).eq('Skipped due to "skip" on Feature.')
+      expect(suiteConfig.suite.opts.skipInfo.skipped).eq(true, 'Skip should be set on skipInfo')
+    })
 
     it('Feature are not skipped by default', () => {
-      suiteConfig = context.Feature('not skipped suite');
-      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true');
-      expect(suiteConfig.suite.opts).to.deep.eq({}, 'Features should have no skip info');
-    });
+      suiteConfig = context.Feature('not skipped suite')
+      expect(suiteConfig.suite.pending).eq(false, 'Feature must not contain pending === true')
+      expect(suiteConfig.suite.opts).to.deep.eq({}, 'Features should have no skip info')
+    })
 
     it('Feature should correctly pass options to suite context', () => {
-      suiteConfig = context.Feature('not skipped suite', { key: 'value' });
-      expect(suiteConfig.suite.opts).to.deep.eq({ key: 'value' }, 'Features should have passed options');
-    });
-  });
+      suiteConfig = context.Feature('not skipped suite', { key: 'value' })
+      expect(suiteConfig.suite.opts).to.deep.eq({ key: 'value' }, 'Features should have passed options')
+    })
+  })
 
   describe('Scenario', () => {
-    let scenarioConfig;
+    let scenarioConfig
 
     it('Scenario should return scenarioConfig', () => {
-      scenarioConfig = context.Scenario('basic scenario');
-      expect(scenarioConfig.test).is.ok;
-    });
+      scenarioConfig = context.Scenario('basic scenario')
+      expect(scenarioConfig.test).is.ok
+    })
 
     it('should contain title', () => {
-      context.Feature('suite');
-      scenarioConfig = context.Scenario('scenario');
-      expect(scenarioConfig.test.title).eq('scenario');
-      expect(scenarioConfig.test.fullTitle()).eq('suite: scenario');
-      expect(scenarioConfig.test.tags.length).eq(0);
-    });
+      context.Feature('suite')
+      scenarioConfig = context.Scenario('scenario')
+      expect(scenarioConfig.test.title).eq('scenario')
+      expect(scenarioConfig.test.fullTitle()).eq('suite: scenario')
+      expect(scenarioConfig.test.tags.length).eq(0)
+    })
 
     it('should contain tags', () => {
-      context.Feature('basic suite @cool');
+      context.Feature('basic suite @cool')
 
-      scenarioConfig = context.Scenario('scenario @very @important');
+      scenarioConfig = context.Scenario('scenario @very @important')
 
-      scenarioConfig.test.tags.should.include('@cool');
-      scenarioConfig.test.tags.should.include('@very');
-      scenarioConfig.test.tags.should.include('@important');
+      scenarioConfig.test.tags.should.include('@cool')
+      scenarioConfig.test.tags.should.include('@very')
+      scenarioConfig.test.tags.should.include('@important')
 
-      scenarioConfig.tag('@user');
-      scenarioConfig.test.tags.should.include('@user');
-    });
+      scenarioConfig.tag('@user')
+      scenarioConfig.test.tags.should.include('@user')
+    })
 
     it('should dynamically inject dependencies', () => {
-      scenarioConfig = context.Scenario('scenario');
-      scenarioConfig.injectDependencies({ Data: 'data' });
-      expect(scenarioConfig.test.inject.Data).eq('data');
-    });
+      scenarioConfig = context.Scenario('scenario')
+      scenarioConfig.injectDependencies({ Data: 'data' })
+      expect(scenarioConfig.test.inject.Data).eq('data')
+    })
 
     describe('todo', () => {
       it('should inject skipInfo to opts', () => {
-        scenarioConfig = context.Scenario.todo('scenario', () => { console.log('Scenario Body'); });
+        scenarioConfig = context.Scenario.todo('scenario', () => {
+          console.log('Scenario Body')
+        })
 
-        expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true');
-        expect(scenarioConfig.test.opts.skipInfo.message).eq('Test not implemented!');
-        expect(scenarioConfig.test.opts.skipInfo.description).eq("() => { console.log('Scenario Body'); }");
-      });
+        expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true')
+        expect(scenarioConfig.test.opts.skipInfo.message).eq('Test not implemented!')
+        expect(scenarioConfig.test.opts.skipInfo.description).to.include("console.log('Scenario Body')")
+      })
 
       it('should contain empty description in skipInfo and empty body', () => {
-        scenarioConfig = context.Scenario.todo('scenario');
+        scenarioConfig = context.Scenario.todo('scenario')
 
-        expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true');
-        expect(scenarioConfig.test.opts.skipInfo.description).eq('');
-        expect(scenarioConfig.test.body).eq('');
-      });
+        expect(scenarioConfig.test.pending).eq(true, 'Todo Scenario must be contain pending === true')
+        expect(scenarioConfig.test.opts.skipInfo.description).eq('')
+        expect(scenarioConfig.test.body).eq('')
+      })
 
       it('should inject custom opts to opts and without callback', () => {
-        scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' });
+        scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' })
 
-        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts');
-      });
+        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts')
+      })
 
       it('should inject custom opts to opts and with callback', () => {
-        scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' }, () => { console.log('Scenario Body'); });
+        scenarioConfig = context.Scenario.todo('scenario', { customOpts: 'Custom Opts' }, () => {
+          console.log('Scenario Body')
+        })
 
-        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts');
-      });
-    });
+        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts')
+      })
+    })
 
     describe('skip', () => {
       it('should inject custom opts to opts and without callback', () => {
-        scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' });
+        scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' })
 
-        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts');
-      });
+        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts')
+      })
 
       it('should inject custom opts to opts and with callback', () => {
-        scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' }, () => { console.log('Scenario Body'); });
-
-        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts');
-      });
-    });
-  });
-});
+        scenarioConfig = context.Scenario.skip('scenario', { customOpts: 'Custom Opts' }, () => {
+          console.log('Scenario Body')
+        })
+
+        expect(scenarioConfig.test.opts.customOpts).eq('Custom Opts')
+      })
+    })
+  })
+})
diff --git a/test/unit/utils_test.js b/test/unit/utils_test.js
index c44f81f68..1a4aef63f 100644
--- a/test/unit/utils_test.js
+++ b/test/unit/utils_test.js
@@ -1,73 +1,73 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const os = require('os');
-const path = require('path');
-const sinon = require('sinon');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const os = require('os')
+const path = require('path')
+const sinon = require('sinon')
 
-const utils = require('../../lib/utils');
+const utils = require('../../lib/utils')
 
 describe('utils', () => {
   describe('#fileExists', () => {
-    it('exists', () => expect(utils.fileExists(__filename)).to.be.true);
-    it('not exists', () => expect(utils.fileExists('not_utils.js')).to.be.false);
-    it('not exists if file used as directory', () => expect(utils.fileExists(`${__filename}/not_utils.js`)).to.be.false);
-  });
+    it('exists', () => expect(utils.fileExists(__filename)).to.be.true)
+    it('not exists', () => expect(utils.fileExists('not_utils.js')).to.be.false)
+    it('not exists if file used as directory', () => expect(utils.fileExists(`${__filename}/not_utils.js`)).to.be.false)
+  })
   /* eslint-disable no-unused-vars */
   describe('#getParamNames', () => {
-    it('fn#1', () => expect(utils.getParamNames((a, b) => { })).eql(['a', 'b']));
-    it('fn#2', () => expect(utils.getParamNames((I, userPage) => { })).eql(['I', 'userPage']));
-    it('should handle single-param arrow functions with omitted parens', () => expect(utils.getParamNames((I) => { })).eql(['I']));
-    it('should handle trailing comma', () => expect(utils.getParamNames((
-      I,
-      trailing,
-      comma,
-    ) => { })).eql(['I', 'trailing', 'comma']));
-  });
+    it('fn#1', () => expect(utils.getParamNames((a, b) => {})).eql(['a', 'b']))
+    it('fn#2', () => expect(utils.getParamNames((I, userPage) => {})).eql(['I', 'userPage']))
+    it('should handle single-param arrow functions with omitted parens', () =>
+      expect(utils.getParamNames((I) => {})).eql(['I']))
+    it('should handle trailing comma', () =>
+      expect(utils.getParamNames((I, trailing, comma) => {})).eql(['I', 'trailing', 'comma']))
+  })
   /* eslint-enable no-unused-vars */
 
   describe('#methodsOfObject', () => {
     it('should get methods', () => {
-      expect(utils.methodsOfObject({
-        a: 1,
-        hello: () => { },
-        world: () => { },
-      })).eql(['hello', 'world']);
-    });
-  });
+      expect(
+        utils.methodsOfObject({
+          a: 1,
+          hello: () => {},
+          world: () => {},
+        }),
+      ).eql(['hello', 'world'])
+    })
+  })
 
   describe('#ucfirst', () => {
     it('should capitalize first letter', () => {
-      expect(utils.ucfirst('hello')).equal('Hello');
-    });
-  });
+      expect(utils.ucfirst('hello')).equal('Hello')
+    })
+  })
 
   describe('#beautify', () => {
     it('should beautify JS code', () => {
-      expect(utils
-        .beautify('module.exports = function(a, b) { a++; b = a; if (a == b) { return 2 }};')).eql(`module.exports = function(a, b) {
+      expect(utils.beautify('module.exports = function(a, b) { a++; b = a; if (a == b) { return 2 }};'))
+        .eql(`module.exports = function(a, b) {
   a++;
   b = a;
   if (a == b) {
     return 2
   }
-};`);
-    });
-  });
+};`)
+    })
+  })
 
   describe('#xpathLocator', () => {
     it('combines xpaths', () => {
-      expect(utils.xpathLocator.combine(['//a', '//button'])).eql('//a | //button');
-    });
+      expect(utils.xpathLocator.combine(['//a', '//button'])).eql('//a | //button')
+    })
 
     it('converts string to xpath literal', () => {
-      expect(utils.xpathLocator.literal("can't find thing")).eql('concat(\'can\',"\'",\'t find thing\')');
-    });
-  });
+      expect(utils.xpathLocator.literal("can't find thing")).eql("concat('can',\"'\",'t find thing')")
+    })
+  })
 
   describe('#replaceValueDeep', () => {
-    let target;
+    let target
 
     it('returns updated object', () => {
       target = {
@@ -75,16 +75,16 @@ describe('utils', () => {
         helpers: {
           something: 2,
         },
-      };
+      }
 
-      expect(utils.replaceValueDeep(target.helpers, 'something', 1234)).eql({ something: 1234 });
+      expect(utils.replaceValueDeep(target.helpers, 'something', 1234)).eql({ something: 1234 })
       expect(target).eql({
         timeout: 1,
         helpers: {
           something: 1234,
         },
-      });
-    });
+      })
+    })
 
     it('do not replace unexisting value', () => {
       target = {
@@ -92,16 +92,16 @@ describe('utils', () => {
         helpers: {
           something: 2,
         },
-      };
+      }
 
-      utils.replaceValueDeep(target, 'unexisting', 1234);
+      utils.replaceValueDeep(target, 'unexisting', 1234)
       expect(target).eql({
         timeout: 1,
         helpers: {
           something: 2,
         },
-      });
-    });
+      })
+    })
 
     it('replace simple value', () => {
       target = {
@@ -109,16 +109,16 @@ describe('utils', () => {
         helpers: {
           something: 2,
         },
-      };
+      }
 
-      utils.replaceValueDeep(target, 'timeout', 1234);
+      utils.replaceValueDeep(target, 'timeout', 1234)
       expect(target).eql({
         timeout: 1234,
         helpers: {
           something: 2,
         },
-      });
-    });
+      })
+    })
 
     it('replace simple falsy value', () => {
       target = {
@@ -137,9 +137,9 @@ describe('utils', () => {
         nullValue: {
           timeout: null,
         },
-      };
+      }
 
-      utils.replaceValueDeep(target, 'timeout', 1234);
+      utils.replaceValueDeep(target, 'timeout', 1234)
       expect(target).eql({
         zeroValue: {
           timeout: 1234,
@@ -156,37 +156,43 @@ describe('utils', () => {
         nullValue: {
           timeout: 1234,
         },
-      });
-    });
+      })
+    })
 
     it('replace value in array of objects', () => {
       target = {
         timeout: 1,
-        something: [{
-          a: 1,
-          b: 2,
-        }, {
-          a: 3,
-        },
-        123,
-        0,
-        [{ a: 1 }, 123]],
-      };
+        something: [
+          {
+            a: 1,
+            b: 2,
+          },
+          {
+            a: 3,
+          },
+          123,
+          0,
+          [{ a: 1 }, 123],
+        ],
+      }
 
-      utils.replaceValueDeep(target, 'a', 1234);
+      utils.replaceValueDeep(target, 'a', 1234)
       expect(target).eql({
         timeout: 1,
-        something: [{
-          a: 1234,
-          b: 2,
-        }, {
-          a: 1234,
-        },
-        123,
-        0,
-        [{ a: 1234 }, 123]],
-      });
-    });
+        something: [
+          {
+            a: 1234,
+            b: 2,
+          },
+          {
+            a: 1234,
+          },
+          123,
+          0,
+          [{ a: 1234 }, 123],
+        ],
+      })
+    })
 
     it('replace simple value deep in object', () => {
       target = {
@@ -196,9 +202,9 @@ describe('utils', () => {
             otherthing: 2,
           },
         },
-      };
+      }
 
-      utils.replaceValueDeep(target, 'otherthing', 1234);
+      utils.replaceValueDeep(target, 'otherthing', 1234)
       expect(target).eql({
         timeout: 1,
         helpers: {
@@ -206,8 +212,8 @@ describe('utils', () => {
             otherthing: 1234,
           },
         },
-      });
-    });
+      })
+    })
 
     it('replace object value', () => {
       target = {
@@ -221,9 +227,9 @@ describe('utils', () => {
             timeouts: 3,
           },
         },
-      };
+      }
 
-      utils.replaceValueDeep(target.helpers, 'WebDriver', { timeouts: 1234 });
+      utils.replaceValueDeep(target.helpers, 'WebDriver', { timeouts: 1234 })
       expect(target).eql({
         timeout: 1,
         helpers: {
@@ -235,118 +241,111 @@ describe('utils', () => {
             timeouts: 3,
           },
         },
-      });
-    });
-  });
+      })
+    })
+  })
 
   describe('#getNormalizedKeyAttributeValue', () => {
     it('should normalize key (alias) to key attribute value', () => {
-      expect(utils.getNormalizedKeyAttributeValue('Arrow down')).equal('ArrowDown');
-      expect(utils.getNormalizedKeyAttributeValue('RIGHT_ARROW')).equal('ArrowRight');
-      expect(utils.getNormalizedKeyAttributeValue('leftarrow')).equal('ArrowLeft');
-      expect(utils.getNormalizedKeyAttributeValue('Up arrow')).equal('ArrowUp');
-
-      expect(utils.getNormalizedKeyAttributeValue('Left Alt')).equal('AltLeft');
-      expect(utils.getNormalizedKeyAttributeValue('RIGHT_ALT')).equal('AltRight');
-      expect(utils.getNormalizedKeyAttributeValue('alt')).equal('Alt');
-
-      expect(utils.getNormalizedKeyAttributeValue('oPTION left')).equal('AltLeft');
-      expect(utils.getNormalizedKeyAttributeValue('ALTGR')).equal('AltGraph');
-      expect(utils.getNormalizedKeyAttributeValue('alt graph')).equal('AltGraph');
-
-      expect(utils.getNormalizedKeyAttributeValue('Control Left')).equal('ControlLeft');
-      expect(utils.getNormalizedKeyAttributeValue('RIGHT_CTRL')).equal('ControlRight');
-      expect(utils.getNormalizedKeyAttributeValue('Ctrl')).equal('Control');
-
-      expect(utils.getNormalizedKeyAttributeValue('Cmd')).equal('Meta');
-      expect(utils.getNormalizedKeyAttributeValue('LeftCommand')).equal('MetaLeft');
-      expect(utils.getNormalizedKeyAttributeValue('os right')).equal('MetaRight');
-      expect(utils.getNormalizedKeyAttributeValue('SUPER')).equal('Meta');
-
-      expect(utils.getNormalizedKeyAttributeValue('NumpadComma')).equal('Comma');
-      expect(utils.getNormalizedKeyAttributeValue('Separator')).equal('Comma');
-
-      expect(utils.getNormalizedKeyAttributeValue('Add')).equal('NumpadAdd');
-      expect(utils.getNormalizedKeyAttributeValue('Decimal')).equal('NumpadDecimal');
-      expect(utils.getNormalizedKeyAttributeValue('Divide')).equal('NumpadDivide');
-      expect(utils.getNormalizedKeyAttributeValue('Multiply')).equal('NumpadMultiply');
-      expect(utils.getNormalizedKeyAttributeValue('Subtract')).equal('NumpadSubtract');
-    });
+      expect(utils.getNormalizedKeyAttributeValue('Arrow down')).equal('ArrowDown')
+      expect(utils.getNormalizedKeyAttributeValue('RIGHT_ARROW')).equal('ArrowRight')
+      expect(utils.getNormalizedKeyAttributeValue('leftarrow')).equal('ArrowLeft')
+      expect(utils.getNormalizedKeyAttributeValue('Up arrow')).equal('ArrowUp')
+
+      expect(utils.getNormalizedKeyAttributeValue('Left Alt')).equal('AltLeft')
+      expect(utils.getNormalizedKeyAttributeValue('RIGHT_ALT')).equal('AltRight')
+      expect(utils.getNormalizedKeyAttributeValue('alt')).equal('Alt')
+
+      expect(utils.getNormalizedKeyAttributeValue('oPTION left')).equal('AltLeft')
+      expect(utils.getNormalizedKeyAttributeValue('ALTGR')).equal('AltGraph')
+      expect(utils.getNormalizedKeyAttributeValue('alt graph')).equal('AltGraph')
+
+      expect(utils.getNormalizedKeyAttributeValue('Control Left')).equal('ControlLeft')
+      expect(utils.getNormalizedKeyAttributeValue('RIGHT_CTRL')).equal('ControlRight')
+      expect(utils.getNormalizedKeyAttributeValue('Ctrl')).equal('Control')
+
+      expect(utils.getNormalizedKeyAttributeValue('Cmd')).equal('Meta')
+      expect(utils.getNormalizedKeyAttributeValue('LeftCommand')).equal('MetaLeft')
+      expect(utils.getNormalizedKeyAttributeValue('os right')).equal('MetaRight')
+      expect(utils.getNormalizedKeyAttributeValue('SUPER')).equal('Meta')
+
+      expect(utils.getNormalizedKeyAttributeValue('NumpadComma')).equal('Comma')
+      expect(utils.getNormalizedKeyAttributeValue('Separator')).equal('Comma')
+
+      expect(utils.getNormalizedKeyAttributeValue('Add')).equal('NumpadAdd')
+      expect(utils.getNormalizedKeyAttributeValue('Decimal')).equal('NumpadDecimal')
+      expect(utils.getNormalizedKeyAttributeValue('Divide')).equal('NumpadDivide')
+      expect(utils.getNormalizedKeyAttributeValue('Multiply')).equal('NumpadMultiply')
+      expect(utils.getNormalizedKeyAttributeValue('Subtract')).equal('NumpadSubtract')
+    })
 
     it('should normalize modifier key based on operating system', () => {
-      sinon.stub(os, 'platform').callsFake(() => { return 'notdarwin'; });
-      utils.getNormalizedKeyAttributeValue('CmdOrCtrl').should.equal('Control');
-      utils.getNormalizedKeyAttributeValue('COMMANDORCONTROL').should.equal('Control');
-      utils.getNormalizedKeyAttributeValue('ControlOrCommand').should.equal('Control');
-      utils.getNormalizedKeyAttributeValue('left ctrl or command').should.equal('ControlLeft');
-      os.platform.restore();
-
-      sinon.stub(os, 'platform').callsFake(() => { return 'darwin'; });
-      utils.getNormalizedKeyAttributeValue('CtrlOrCmd').should.equal('Meta');
-      utils.getNormalizedKeyAttributeValue('CONTROLORCOMMAND').should.equal('Meta');
-      utils.getNormalizedKeyAttributeValue('CommandOrControl').should.equal('Meta');
-      utils.getNormalizedKeyAttributeValue('right command or ctrl').should.equal('MetaRight');
-      os.platform.restore();
-    });
-  });
+      sinon.stub(os, 'platform').callsFake(() => {
+        return 'notdarwin'
+      })
+      utils.getNormalizedKeyAttributeValue('CmdOrCtrl').should.equal('Control')
+      utils.getNormalizedKeyAttributeValue('COMMANDORCONTROL').should.equal('Control')
+      utils.getNormalizedKeyAttributeValue('ControlOrCommand').should.equal('Control')
+      utils.getNormalizedKeyAttributeValue('left ctrl or command').should.equal('ControlLeft')
+      os.platform.restore()
+
+      sinon.stub(os, 'platform').callsFake(() => {
+        return 'darwin'
+      })
+      utils.getNormalizedKeyAttributeValue('CtrlOrCmd').should.equal('Meta')
+      utils.getNormalizedKeyAttributeValue('CONTROLORCOMMAND').should.equal('Meta')
+      utils.getNormalizedKeyAttributeValue('CommandOrControl').should.equal('Meta')
+      utils.getNormalizedKeyAttributeValue('right command or ctrl').should.equal('MetaRight')
+      os.platform.restore()
+    })
+  })
 
   describe('#screenshotOutputFolder', () => {
-    let _oldGlobalOutputDir;
-    let _oldGlobalCodeceptDir;
+    let _oldGlobalOutputDir
+    let _oldGlobalCodeceptDir
 
     before(() => {
-      _oldGlobalOutputDir = global.output_dir;
-      _oldGlobalCodeceptDir = global.codecept_dir;
+      _oldGlobalOutputDir = global.output_dir
+      _oldGlobalCodeceptDir = global.codecept_dir
 
-      global.output_dir = '/Users/someuser/workbase/project1/test_output';
-      global.codecept_dir = '/Users/someuser/workbase/project1/tests/e2e';
-    });
+      global.output_dir = '/Users/someuser/workbase/project1/test_output'
+      global.codecept_dir = '/Users/someuser/workbase/project1/tests/e2e'
+    })
 
     after(() => {
-      global.output_dir = _oldGlobalOutputDir;
-      global.codecept_dir = _oldGlobalCodeceptDir;
-    });
+      global.output_dir = _oldGlobalOutputDir
+      global.codecept_dir = _oldGlobalCodeceptDir
+    })
 
     it('returns the joined filename for filename only', () => {
-      const _path = utils.screenshotOutputFolder('screenshot1.failed.png');
-      expect(_path).eql(
-        '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png'.replace(
-          /\//g,
-          path.sep,
-        ),
-      );
-    });
+      const _path = utils.screenshotOutputFolder('screenshot1.failed.png')
+      expect(_path).eql('/Users/someuser/workbase/project1/test_output/screenshot1.failed.png'.replace(/\//g, path.sep))
+    })
 
     it('returns the given filename for absolute one', () => {
       const _path = utils.screenshotOutputFolder(
-        '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png'.replace(
-          /\//g,
-          path.sep,
-        ),
-      );
+        '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png'.replace(/\//g, path.sep),
+      )
       if (os.platform() === 'win32') {
         expect(_path).eql(
-          path.resolve(
-            global.codecept_dir,
-            '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png',
-          ),
-        );
+          path.resolve(global.codecept_dir, '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png'),
+        )
       } else {
-        expect(_path).eql(
-          '/Users/someuser/workbase/project1/test_output/screenshot1.failed.png',
-        );
+        expect(_path).eql('/Users/someuser/workbase/project1/test_output/screenshot1.failed.png')
       }
-    });
-  });
+    })
+  })
 
   describe('#requireWithFallback', () => {
     it('returns the fallback package', () => {
-      expect(utils.requireWithFallback('unexisting-package', 'playwright')).eql(require('playwright'));
-    });
+      expect(utils.requireWithFallback('unexisting-package', 'playwright')).eql(require('playwright'))
+    })
 
     it('returns provide default require not found message', () => {
-      expect(() => utils.requireWithFallback('unexisting-package', 'unexisting-package2'))
-        .to.throw(Error, 'Cannot find modules unexisting-package,unexisting-package2');
-    });
-  });
-});
+      expect(() => utils.requireWithFallback('unexisting-package', 'unexisting-package2')).to.throw(
+        Error,
+        'Cannot find modules unexisting-package,unexisting-package2',
+      )
+    })
+  })
+})
diff --git a/test/unit/worker_test.js b/test/unit/worker_test.js
index 16ec83d84..bf4fb086f 100644
--- a/test/unit/worker_test.js
+++ b/test/unit/worker_test.js
@@ -1,59 +1,59 @@
-let expect;
-import('chai').then(chai => {
-  expect = chai.expect;
-});
-const path = require('path');
-const { Workers, event, recorder } = require('../../lib/index');
+let expect
+import('chai').then((chai) => {
+  expect = chai.expect
+})
+const path = require('path')
+const { Workers, event, recorder } = require('../../lib/index')
 
 describe('Workers', function () {
-  this.timeout(40000);
+  this.timeout(40000)
 
   before(() => {
-    global.codecept_dir = path.join(__dirname, '/../data/sandbox');
-  });
+    global.codecept_dir = path.join(__dirname, '/../data/sandbox')
+  })
 
   it('should run simple worker', (done) => {
     const workerConfig = {
       by: 'test',
       testConfig: './test/data/sandbox/codecept.workers.conf.js',
-    };
-    let passedCount = 0;
-    let failedCount = 0;
-    const workers = new Workers(2, workerConfig);
+    }
+    let passedCount = 0
+    let failedCount = 0
+    const workers = new Workers(2, workerConfig)
 
     workers.on(event.test.failed, () => {
-      failedCount += 1;
-    });
+      failedCount += 1
+    })
     workers.on(event.test.passed, () => {
-      passedCount += 1;
-    });
+      passedCount += 1
+    })
 
-    workers.run();
+    workers.run()
 
     workers.on(event.all.result, (status) => {
-      expect(status).equal(false);
-      expect(passedCount).equal(5);
-      expect(failedCount).equal(3);
-      done();
-    });
-  });
+      expect(status).equal(false)
+      expect(passedCount).equal(5)
+      expect(failedCount).equal(3)
+      done()
+    })
+  })
 
   it('should create worker by function', (done) => {
     const createTestGroups = () => {
       const files = [
         [path.join(codecept_dir, '/custom-worker/base_test.worker.js')],
         [path.join(codecept_dir, '/custom-worker/custom_test.worker.js')],
-      ];
+      ]
 
-      return files;
-    };
+      return files
+    }
 
     const workerConfig = {
       by: createTestGroups,
       testConfig: './test/data/sandbox/codecept.customworker.js',
-    };
+    }
 
-    const workers = new Workers(-1, workerConfig);
+    const workers = new Workers(-1, workerConfig)
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -63,27 +63,27 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
+    workers.run()
 
     workers.on(event.all.result, (status) => {
-      expect(workers.getWorkers().length).equal(2);
-      expect(status).equal(true);
-      done();
-    });
-  });
+      expect(workers.getWorkers().length).equal(2)
+      expect(status).equal(true)
+      done()
+    })
+  })
 
   it('should run worker with custom config', (done) => {
     const workerConfig = {
       by: 'test',
       testConfig: './test/data/sandbox/codecept.customworker.js',
-    };
-    let passedCount = 0;
-    let failedCount = 0;
+    }
+    let passedCount = 0
+    let failedCount = 0
 
-    const workers = new Workers(2, workerConfig);
+    const workers = new Workers(2, workerConfig)
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -93,43 +93,39 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
+    workers.run()
 
     workers.on(event.test.failed, (test) => {
-      failedCount += 1;
-    });
+      failedCount += 1
+    })
     workers.on(event.test.passed, (test) => {
-      passedCount += 1;
-    });
+      passedCount += 1
+    })
 
     workers.on(event.all.result, (status) => {
-      expect(status).equal(false);
-      expect(passedCount).equal(4);
-      expect(failedCount).equal(1);
-      done();
-    });
-  });
+      expect(status).equal(false)
+      expect(passedCount).equal(4)
+      expect(failedCount).equal(1)
+      done()
+    })
+  })
 
   it('should able to add tests to each worker', (done) => {
     const workerConfig = {
       by: 'test',
       testConfig: './test/data/sandbox/codecept.customworker.js',
-    };
+    }
 
-    const workers = new Workers(-1, workerConfig);
+    const workers = new Workers(-1, workerConfig)
 
-    const workerOne = workers.spawn();
-    workerOne.addTestFiles([
-      path.join(codecept_dir, '/custom-worker/base_test.worker.js'),
-    ]);
+    const workerOne = workers.spawn()
+    workerOne.addTestFiles([path.join(codecept_dir, '/custom-worker/base_test.worker.js')])
 
-    const workerTwo = workers.spawn();
-    workerTwo.addTestFiles([
-      path.join(codecept_dir, '/custom-worker/custom_test.worker.js'),
-    ]);
+    const workerTwo = workers.spawn()
+    workerTwo.addTestFiles([path.join(codecept_dir, '/custom-worker/custom_test.worker.js')])
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -139,32 +135,32 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
+    workers.run()
 
     workers.on(event.all.result, (status) => {
-      expect(workers.getWorkers().length).equal(2);
-      expect(status).equal(true);
-      done();
-    });
-  });
+      expect(workers.getWorkers().length).equal(2)
+      expect(status).equal(true)
+      done()
+    })
+  })
 
   it('should able to add tests to using createGroupsOfTests', (done) => {
     const workerConfig = {
       by: 'test',
       testConfig: './test/data/sandbox/codecept.customworker.js',
-    };
+    }
 
-    const workers = new Workers(-1, workerConfig);
-    const testGroups = workers.createGroupsOfSuites(2);
+    const workers = new Workers(-1, workerConfig)
+    const testGroups = workers.createGroupsOfSuites(2)
 
-    const workerOne = workers.spawn();
-    workerOne.addTests(testGroups[0]);
+    const workerOne = workers.spawn()
+    workerOne.addTests(testGroups[0])
 
-    const workerTwo = workers.spawn();
-    workerTwo.addTests(testGroups[1]);
+    const workerTwo = workers.spawn()
+    workerTwo.addTests(testGroups[1])
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -174,25 +170,25 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
+    workers.run()
 
     workers.on(event.all.result, (status) => {
-      expect(workers.getWorkers().length).equal(2);
-      expect(status).equal(true);
-      done();
-    });
-  });
+      expect(workers.getWorkers().length).equal(2)
+      expect(status).equal(true)
+      done()
+    })
+  })
 
   it('Should able to pass data from workers to main thread and vice versa', (done) => {
     const workerConfig = {
       by: 'test',
       testConfig: './test/data/sandbox/codecept.customworker.js',
-    };
+    }
 
-    const workers = new Workers(2, workerConfig);
+    const workers = new Workers(2, workerConfig)
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -202,49 +198,47 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
-    recorder.add(() => share({ fromMain: true }));
+    workers.run()
+    recorder.add(() => share({ fromMain: true }))
 
     workers.on(event.all.result, (status) => {
-      expect(status).equal(true);
-      done();
-    });
-  });
+      expect(status).equal(true)
+      done()
+    })
+  })
 
   it('should propagate non test events', (done) => {
-    const messages = [];
+    const messages = []
 
     const createTestGroups = () => {
-      const files = [
-        [path.join(codecept_dir, '/non-test-events-worker/non_test_event.worker.js')],
-      ];
+      const files = [[path.join(codecept_dir, '/non-test-events-worker/non_test_event.worker.js')]]
 
-      return files;
-    };
+      return files
+    }
 
     const workerConfig = {
       by: createTestGroups,
       testConfig: './test/data/sandbox/codecept.non-test-events-worker.js',
-    };
+    }
 
-    workers = new Workers(2, workerConfig);
+    workers = new Workers(2, workerConfig)
 
-    workers.run();
+    workers.run()
 
     workers.on('message', (data) => {
-      messages.push(data);
-    });
+      messages.push(data)
+    })
 
     workers.on(event.all.result, () => {
-      expect(messages.length).equal(2);
-      expect(messages[0]).equal('message 1');
-      expect(messages[1]).equal('message 2');
-      done();
-    });
-  });
+      expect(messages.length).equal(2)
+      expect(messages[0]).equal('message 1')
+      expect(messages[1]).equal('message 2')
+      done()
+    })
+  })
 
   it('should run worker with multiple config', (done) => {
     const workerConfig = {
@@ -252,9 +246,9 @@ describe('Workers', function () {
       testConfig: './test/data/sandbox/codecept.multiple.js',
       options: {},
       selectedRuns: ['mobile'],
-    };
+    }
 
-    const workers = new Workers(2, workerConfig);
+    const workers = new Workers(2, workerConfig)
 
     for (const worker of workers.getWorkers()) {
       worker.addConfig({
@@ -264,15 +258,15 @@ describe('Workers', function () {
             require: './custom_worker_helper',
           },
         },
-      });
+      })
     }
 
-    workers.run();
+    workers.run()
 
     workers.on(event.all.result, (status) => {
-      expect(workers.getWorkers().length).equal(8);
-      expect(status).equal(true);
-      done();
-    });
-  });
-});
+      expect(workers.getWorkers().length).equal(8)
+      expect(status).equal(true)
+      done()
+    })
+  })
+})
diff --git a/translations/de-DE.js b/translations/de-DE.js
index 8d2da5be0..aee1be9b2 100644
--- a/translations/de-DE.js
+++ b/translations/de-DE.js
@@ -71,4 +71,4 @@ module.exports = {
     sendPostRequest: 'mache_einen_post_request',
     switchTo: 'wechlse_in_iframe',
   },
-};
+}
diff --git a/translations/fr-FR.js b/translations/fr-FR.js
index 0e3eadb00..6cb6a7a14 100644
--- a/translations/fr-FR.js
+++ b/translations/fr-FR.js
@@ -73,4 +73,4 @@ module.exports = {
     sendDeleteRequest: 'envoieLaRequêteDelete',
     sendPostRequest: 'envoieLaRequêtePost',
   },
-};
+}
diff --git a/translations/index.js b/translations/index.js
index c0349bde4..7767e717b 100644
--- a/translations/index.js
+++ b/translations/index.js
@@ -1,9 +1,9 @@
-exports['de-DE'] = require('./de-DE');
-exports['it-IT'] = require('./it-IT');
-exports['fr-FR'] = require('./fr-FR');
-exports['ja-JP'] = require('./ja-JP');
-exports['pl-PL'] = require('./pl-PL');
-exports['pt-BR'] = require('./pt-BR');
-exports['ru-RU'] = require('./ru-RU');
-exports['zh-CN'] = require('./zh-CN');
-exports['zh-TW'] = require('./zh-TW');
+exports['de-DE'] = require('./de-DE')
+exports['it-IT'] = require('./it-IT')
+exports['fr-FR'] = require('./fr-FR')
+exports['ja-JP'] = require('./ja-JP')
+exports['pl-PL'] = require('./pl-PL')
+exports['pt-BR'] = require('./pt-BR')
+exports['ru-RU'] = require('./ru-RU')
+exports['zh-CN'] = require('./zh-CN')
+exports['zh-TW'] = require('./zh-TW')
diff --git a/translations/it-IT.js b/translations/it-IT.js
index f0c84a303..2dd161467 100644
--- a/translations/it-IT.js
+++ b/translations/it-IT.js
@@ -61,4 +61,4 @@ module.exports = {
     resizeWindow: 'ridimesiono_la_finestra',
     wait: 'aspetto',
   },
-};
+}
diff --git a/translations/ja-JP.js b/translations/ja-JP.js
index 03e948ebf..acbcfca13 100644
--- a/translations/ja-JP.js
+++ b/translations/ja-JP.js
@@ -57,4 +57,4 @@ module.exports = {
     resizeWindow: 'ウィンドウをリサイズする',
     wait: '待つ',
   },
-};
+}
diff --git a/translations/pl-PL.js b/translations/pl-PL.js
index e64a15844..4e3c21813 100644
--- a/translations/pl-PL.js
+++ b/translations/pl-PL.js
@@ -62,4 +62,4 @@ module.exports = {
     moveCursorTo: 'przesuwam_kursor_do',
     scrollTo: 'skroluję_do',
   },
-};
+}
diff --git a/translations/pt-BR.js b/translations/pt-BR.js
index 5f54fdb8b..20b783994 100644
--- a/translations/pt-BR.js
+++ b/translations/pt-BR.js
@@ -62,4 +62,4 @@ module.exports = {
     resizeWindow: 'redimensionaJanela',
     wait: 'aguardo',
   },
-};
+}
diff --git a/translations/ru-RU.js b/translations/ru-RU.js
index f08d1103b..21de4f9db 100644
--- a/translations/ru-RU.js
+++ b/translations/ru-RU.js
@@ -55,4 +55,4 @@ module.exports = {
     resizeWindow: 'растягиваю_окно',
     wait: 'жду',
   },
-};
+}
diff --git a/translations/zh-CN.js b/translations/zh-CN.js
index 30aef2636..f2a4ae1af 100644
--- a/translations/zh-CN.js
+++ b/translations/zh-CN.js
@@ -57,4 +57,4 @@ module.exports = {
     resizeWindow: '调整窗口尺寸',
     wait: '等',
   },
-};
+}
diff --git a/translations/zh-TW.js b/translations/zh-TW.js
index bb13b4bf4..908dcb38f 100644
--- a/translations/zh-TW.js
+++ b/translations/zh-TW.js
@@ -57,4 +57,4 @@ module.exports = {
     resizeWindow: '調整窗口尺寸',
     wait: '等',
   },
-};
+}
diff --git a/typings/fixDefFiles.js b/typings/fixDefFiles.js
index f0e1e0d97..8d70d8460 100644
--- a/typings/fixDefFiles.js
+++ b/typings/fixDefFiles.js
@@ -25,9 +25,13 @@ filePath.forEach(file => {
 });
 
 function modifyContent(content) {
-  const modifiedContent = content.replace(/    class MockServer {/g, '    // @ts-ignore\n'
-    + '    class MockServer {').replace(/    type MockServerConfig = {/g, '    // @ts-ignore\n'
+  const modifiedContent = content.replace(/    class MockServer {/, '    // @ts-ignore\n'
+    + '    class MockServer {').replace(/    type MockServerConfig = {/, '    // @ts-ignore\n'
     + '    type MockServerConfig = {').replace(/    class ExpectHelper {/g, '    // @ts-ignore\n'
-    + '    class ExpectHelper {');
+    + '    class ExpectHelper {').replace(/    type PlaywrightConfig = {/, '    // @ts-ignore\n'
+    + '    type PlaywrightConfig = {').replace(/    type PuppeteerConfig = {/, '    // @ts-ignore\n'
+    + '    type PuppeteerConfig = {').replace(/    type RESTConfig = {/, '    // @ts-ignore\n'
+    + '    type RESTConfig = {').replace(/    type WebDriverConfig = {/, '    // @ts-ignore\n'
+    + '    type WebDriverConfig = {')
   return modifiedContent;
 }