@axe-core/webdriverjs 4.6.2-alpha.379 → 4.7.0

package/dist/index.js

@@ -1,356 +1,520 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_axe_core2 = __toESM(require("axe-core"));
+
+// src/utils/index.ts
+var normalizeContext = (include, exclude) => {
+  const base = {
+    exclude: []
+  };
+  if (exclude.length && Array.isArray(base.exclude)) {
+    base.exclude.push(...exclude);
+  }
+  if (include.length) {
+    base.include = include;
+  }
+  return base;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-var axe_core_1 = require("axe-core");
-var index_1 = require("./utils/index");
-var axe_injector_1 = __importDefault(require("./axe-injector"));
-var browser_1 = require("./browser");
-var assert_1 = __importDefault(require("assert"));
-var AxeBuilder = /** @class */ (function () {
-    function AxeBuilder(driver, axeSource, builderOptions) {
-        this.legacyMode = false;
-        this.driver = driver;
-        this.axeSource = axeSource || axe_core_1.source;
-        this.includes = [];
-        this.excludes = [];
-        this.option = {};
-        this.config = null;
-        this.builderOptions = builderOptions || {};
-        this.errorUrl =
-            'https://github.com/dequelabs/axe-core-npm/blob/develop/packages/webdriverjs/error-handling.md';
+
+// src/axe-injector.ts
+var import_selenium_webdriver = require("selenium-webdriver");
+var import_axe_core = __toESM(require("axe-core"));
+var { source } = import_axe_core.default;
+var { StaleElementReferenceError } = import_selenium_webdriver.error;
+var AxeInjectorLegacy = class {
+  driver;
+  axeSource;
+  options;
+  config;
+  didLogError;
+  constructor({
+    driver,
+    axeSource,
+    builderOptions,
+    config
+  }) {
+    this.driver = driver;
+    this.axeSource = axeSource || source;
+    this.config = config ? JSON.stringify(config) : "";
+    this.options = builderOptions || {};
+    this.didLogError = false;
+    this.options.noSandbox = typeof this.options.noSandbox === "boolean" ? this.options.noSandbox : false;
+    this.options.logIframeErrors = typeof this.options.logIframeErrors === "boolean" ? this.options.logIframeErrors : false;
+  }
+  /**
+   * Checks to make sure that the error thrown was not a stale iframe
+   * @param {Error} error
+   * @returns {void}
+   */
+  errorHandler(err) {
+    if (this.didLogError) {
+      return;
     }
-    /**
-     * Selector to include in analysis.
-     * This may be called any number of times.
-     */
-    AxeBuilder.prototype.include = function (selector) {
-        this.includes.push(selector);
-        return this;
-    };
-    /**
-     * Selector to exclude in analysis.
-     * This may be called any number of times.
-     */
-    AxeBuilder.prototype.exclude = function (selector) {
-        this.excludes.push(selector);
-        return this;
-    };
-    /**
-     * Set options to be passed into axe-core
-     */
-    AxeBuilder.prototype.options = function (options) {
-        this.option = options;
-        return this;
-    };
-    /**
-     * Limit analysis to only the specified rules.
-     * Cannot be used with `AxeBuilder#withTags`
-     */
-    AxeBuilder.prototype.withRules = function (rules) {
-        rules = Array.isArray(rules) ? rules : [rules];
-        this.option.runOnly = {
-            type: 'rule',
-            values: rules
-        };
-        return this;
+    this.didLogError = true;
+    let msg;
+    if (err instanceof StaleElementReferenceError) {
+      msg = "Tried to inject into a removed iframe. This will not affect the analysis of the rest of the page but you might want to ensure the page has finished updating before starting the analysis.";
+    } else {
+      msg = "Failed to inject axe-core into one of the iframes!";
+    }
+    if (this.options.logIframeErrors) {
+      console.error(msg);
+      return;
+    }
+    throw new Error(msg);
+  }
+  /**
+   * Get axe-core source and configurations
+   * @returns {String}
+   */
+  get script() {
+    return `
+    ${this.axeSource}
+    ${this.config ? `axe.configure(${this.config})` : ""}
+    axe.configure({
+      branding: { application: 'webdriverjs' }
+    })
+    `;
+  }
+  /**
+   * Removes the `sandbox` attribute from iFrames
+   * @returns {Promise<void>}
+   */
+  async sandboxBuster() {
+    return new Promise((resolve, reject) => {
+      this.driver.executeAsyncScript(
+        `
+          var callback = arguments[arguments.length - 1];
+          var iframes = Array.from(
+            document.querySelectorAll('iframe[sandbox]')
+          );
+          var removeSandboxAttr = clone => attr => {
+            if (attr.name === 'sandbox') return;
+            clone.setAttribute(attr.name, attr.value);
+          };
+          var replaceSandboxedIframe = iframe => {
+            var clone = document.createElement('iframe');
+            var promise = new Promise(
+              iframeLoaded => (clone.onload = iframeLoaded)
+            );
+            Array.from(iframe.attributes).forEach(removeSandboxAttr(clone));
+            iframe.parentElement.replaceChild(clone, iframe);
+            return promise;
+          };
+          Promise.all(iframes.map(replaceSandboxedIframe)).then(callback);
+        `
+      ).then(() => resolve()).catch((e) => reject(e));
+    });
+  }
+  /**
+   * Injects into the provided `frame` and its child `frames`
+   * @param {WebElement[]} framePath
+   * @returns {Promise<void>}
+   */
+  async handleFrame(framePath) {
+    await this.driver.switchTo().defaultContent();
+    for (const frame of framePath) {
+      await this.driver.switchTo().frame(frame);
+    }
+    if (this.options.noSandbox) {
+      await this.sandboxBuster();
+    }
+    await this.driver.executeScript(this.script);
+    const ifs = await this.driver.findElements({ tagName: "iframe" });
+    const fs = await this.driver.findElements({ tagName: "frame" });
+    const frames = ifs.concat(fs);
+    for (const childFrames of frames) {
+      framePath.push(childFrames);
+      try {
+        await this.handleFrame(framePath);
+      } catch (error2) {
+        this.errorHandler(error2);
+      } finally {
+        framePath.pop();
+      }
+    }
+  }
+  /**
+   * Injects into all frames
+   * @returns {Promise<void>}
+   */
+  async injectIntoAllFrames() {
+    await this.driver.switchTo().defaultContent();
+    if (this.options.noSandbox) {
+      await this.sandboxBuster();
+    }
+    await this.driver.executeScript(this.script);
+    const ifs = await this.driver.findElements({ tagName: "iframe" });
+    const fs = await this.driver.findElements({ tagName: "frame" });
+    const frames = ifs.concat(fs);
+    for (const childFrame of frames) {
+      try {
+        await this.handleFrame([childFrame]);
+      } catch (err) {
+        this.errorHandler(err);
+      }
+    }
+    return this.driver.switchTo().defaultContent();
+  }
+};
+
+// src/browser.ts
+function axeSourceInject(driver, axeSource, config) {
+  return promisify(
+    driver.executeScript(`
+      ${axeSource};
+      window.axe.configure({
+        branding: { application: 'webdriverjs' }
+      });
+      var config = ${JSON.stringify(config)};
+      if (config) {
+        window.axe.configure(config);
+      }
+      var runPartial = typeof window.axe.runPartial === 'function';
+      return { runPartialSupported: runPartial };
+    `)
+  );
+}
+function axeRunPartial(driver, context, options) {
+  return promisify(
+    driver.executeAsyncScript(`
+      var callback = arguments[arguments.length - 1];
+      var context = ${JSON.stringify(context)} || document;
+      var options = ${JSON.stringify(options)} || {};
+      window.axe.runPartial(context, options).then(res => JSON.stringify(res)).then(callback);
+    `)
+  );
+}
+function axeFinishRun(driver, axeSource, config, partialResults, options) {
+  const sizeLimit = 15e6;
+  const partialString = JSON.stringify(partialResults);
+  function chunkResults(result) {
+    const chunk = JSON.stringify(result.substring(0, sizeLimit));
+    return promisify(
+      driver.executeScript(
+        `
+        window.partialResults ??= '';
+        window.partialResults += ${chunk};
+          `
+      )
+    ).then(() => {
+      if (result.length > sizeLimit) {
+        return chunkResults(result.substr(sizeLimit));
+      }
+    });
+  }
+  return chunkResults(partialString).then(() => {
+    return promisify(
+      driver.executeAsyncScript(
+        `
+          var callback = arguments[arguments.length - 1];
+
+          ${axeSource};
+          window.axe.configure({
+            branding: { application: 'webdriverjs' }
+          });
+          var config = ${JSON.stringify(config)};
+          if (config) {
+            window.axe.configure(config);
+          }
+
+          var partialResults = JSON.parse(window.partialResults).map(res => JSON.parse(res));
+          var options = ${JSON.stringify(options || {})};
+          window.axe.finishRun(partialResults, options).then(res => JSON.stringify(res)).then(callback);
+        `
+      )
+    );
+  }).then((res) => JSON.parse(res));
+}
+function axeGetFrameContext(driver, context) {
+  return promisify(
+    driver.executeScript(`
+      var context = ${JSON.stringify(context)}
+      var frameContexts = window.axe.utils.getFrameContexts(context);
+      return frameContexts.map(function (frameContext) {
+        return Object.assign(frameContext, {
+          href: window.location.href, // For debugging
+          frame: axe.utils.shadowSelect(frameContext.frameSelector)
+        });
+      });
+    `)
+  );
+}
+function axeRunLegacy(driver, context, options, config) {
+  return promisify(
+    driver.executeAsyncScript(
+      `
+      var callback = arguments[arguments.length - 1];
+      var context = ${JSON.stringify(context)} || document;
+      var options = ${JSON.stringify(options)} || {};
+      var config = ${JSON.stringify(config)} || null;
+      if (config) {
+        window.axe.configure(config);
+      }
+      window.axe.run(context, options).then(res => JSON.stringify(res)).then(callback);
+    `
+    ).then((res) => JSON.parse(res))
+  );
+}
+function promisify(thenable) {
+  return new Promise((resolve, reject) => {
+    thenable.then(resolve, reject);
+  });
+}
+
+// src/index.ts
+var import_assert = __toESM(require("assert"));
+var { source: source2 } = import_axe_core2.default;
+var AxeBuilder = class {
+  driver;
+  axeSource;
+  includes;
+  excludes;
+  option;
+  config;
+  builderOptions;
+  legacyMode = false;
+  errorUrl;
+  constructor(driver, axeSource, builderOptions) {
+    this.driver = driver;
+    this.axeSource = axeSource || source2;
+    this.includes = [];
+    this.excludes = [];
+    this.option = {};
+    this.config = null;
+    this.builderOptions = builderOptions || {};
+    this.errorUrl = "https://github.com/dequelabs/axe-core-npm/blob/develop/packages/webdriverjs/error-handling.md";
+  }
+  /**
+   * Selector to include in analysis.
+   * This may be called any number of times.
+   */
+  include(selector) {
+    this.includes.push(selector);
+    return this;
+  }
+  /**
+   * Selector to exclude in analysis.
+   * This may be called any number of times.
+   */
+  exclude(selector) {
+    this.excludes.push(selector);
+    return this;
+  }
+  /**
+   * Set options to be passed into axe-core
+   */
+  options(options) {
+    this.option = options;
+    return this;
+  }
+  /**
+   * Limit analysis to only the specified rules.
+   * Cannot be used with `AxeBuilder#withTags`
+   */
+  withRules(rules) {
+    rules = Array.isArray(rules) ? rules : [rules];
+    this.option.runOnly = {
+      type: "rule",
+      values: rules
     };
-    /**
-     * Limit analysis to only specified tags.
-     * Cannot be used with `AxeBuilder#withRules`
-     */
-    AxeBuilder.prototype.withTags = function (tags) {
-        tags = Array.isArray(tags) ? tags : [tags];
-        this.option.runOnly = {
-            type: 'tag',
-            values: tags
-        };
-        return this;
+    return this;
+  }
+  /**
+   * Limit analysis to only specified tags.
+   * Cannot be used with `AxeBuilder#withRules`
+   */
+  withTags(tags) {
+    tags = Array.isArray(tags) ? tags : [tags];
+    this.option.runOnly = {
+      type: "tag",
+      values: tags
     };
-    /**
-     * Set the list of rules to skip when running an analysis.
-     */
-    AxeBuilder.prototype.disableRules = function (rules) {
-        rules = Array.isArray(rules) ? rules : [rules];
-        this.option.rules = {};
-        for (var _i = 0, rules_1 = rules; _i < rules_1.length; _i++) {
-            var rule = rules_1[_i];
-            this.option.rules[rule] = { enabled: false };
+    return this;
+  }
+  /**
+   * Set the list of rules to skip when running an analysis.
+   */
+  disableRules(rules) {
+    rules = Array.isArray(rules) ? rules : [rules];
+    this.option.rules = {};
+    for (const rule of rules) {
+      this.option.rules[rule] = { enabled: false };
+    }
+    return this;
+  }
+  /**
+   * Set configuration for `axe-core`.
+   * This value is passed directly to `axe.configure()`
+   */
+  configure(config) {
+    if (typeof config !== "object") {
+      throw new Error(
+        "AxeBuilder needs an object to configure. See axe-core configure API."
+      );
+    }
+    this.config = config;
+    return this;
+  }
+  /**
+   * Performs an analysis and retrieves results.
+   */
+  async analyze(callback) {
+    return new Promise((resolve, reject) => {
+      return this.analyzePromise().then((results) => {
+        callback?.(null, results);
+        resolve(results);
+      }).catch((err) => {
+        if (callback) {
+          callback(err, null);
+        } else {
+          reject(err);
         }
-        return this;
-    };
-    /**
-     * Set configuration for `axe-core`.
-     * This value is passed directly to `axe.configure()`
-     */
-    AxeBuilder.prototype.configure = function (config) {
-        if (typeof config !== 'object') {
-            throw new Error('AxeBuilder needs an object to configure. See axe-core configure API.');
+      });
+    });
+  }
+  /**
+   * Use frameMessenger with <same_origin_only>
+   *
+   * This disables use of axe.runPartial() which is called in each frame, and
+   * axe.finishRun() which is called in a blank page. This uses axe.run() instead,
+   * but with the restriction that cross-origin frames will not be tested.
+   */
+  setLegacyMode(legacyMode = true) {
+    this.legacyMode = legacyMode;
+    return this;
+  }
+  /**
+   * Analyzes the page, returning a promise
+   */
+  async analyzePromise() {
+    const context = normalizeContext(this.includes, this.excludes);
+    await this.driver.switchTo().defaultContent();
+    const { runPartialSupported } = await axeSourceInject(
+      this.driver,
+      this.axeSource,
+      this.config
+    );
+    if (runPartialSupported !== true || this.legacyMode) {
+      return this.runLegacy(context);
+    }
+    const partials = await this.runPartialRecursive(context, true);
+    try {
+      return await this.finishRun(partials);
+    } catch (error2) {
+      throw new Error(
+        `${error2.message}
+ Please check out ${this.errorUrl}`
+      );
+    }
+  }
+  /**
+   * Use axe.run() to get results from the page
+   */
+  async runLegacy(context) {
+    const { driver, axeSource, builderOptions } = this;
+    let config = this.config;
+    if (!this.legacyMode) {
+      config = {
+        ...config || {},
+        allowedOrigins: ["<unsafe_all_origins>"]
+      };
+    }
+    const injector = new AxeInjectorLegacy({
+      driver,
+      axeSource,
+      config,
+      builderOptions
+    });
+    await injector.injectIntoAllFrames();
+    return axeRunLegacy(this.driver, context, this.option, this.config);
+  }
+  /**
+   * Get partial results from the current context and its child frames
+   */
+  async runPartialRecursive(context, initiator = false) {
+    if (!initiator) {
+      await axeSourceInject(this.driver, this.axeSource, this.config);
+    }
+    const frameContexts = await axeGetFrameContext(this.driver, context);
+    const partials = [
+      await axeRunPartial(this.driver, context, this.option)
+    ];
+    for (const { frameContext, frameSelector, frame } of frameContexts) {
+      let switchedFrame = false;
+      try {
+        (0, import_assert.default)(frame, `Expect frame of "${frameSelector}" to be defined`);
+        await this.driver.switchTo().frame(frame);
+        switchedFrame = true;
+        partials.push(...await this.runPartialRecursive(frameContext));
+        await this.driver.switchTo().parentFrame();
+      } catch {
+        if (switchedFrame) {
+          await this.driver.switchTo().parentFrame();
         }
-        this.config = config;
-        return this;
-    };
-    /**
-     * Performs an analysis and retrieves results.
-     */
-    AxeBuilder.prototype.analyze = function (callback) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        return _this.analyzePromise()
-                            .then(function (results) {
-                            callback === null || callback === void 0 ? void 0 : callback(null, results);
-                            resolve(results);
-                        })
-                            .catch(function (err) {
-                            // When using a callback, do *not* reject the wrapping Promise. This prevents having to handle the same error twice.
-                            if (callback) {
-                                callback(err, null);
-                            }
-                            else {
-                                reject(err);
-                            }
-                        });
-                    })];
-            });
-        });
-    };
-    /**
-     * Use frameMessenger with <same_origin_only>
-     *
-     * This disables use of axe.runPartial() which is called in each frame, and
-     * axe.finishRun() which is called in a blank page. This uses axe.run() instead,
-     * but with the restriction that cross-origin frames will not be tested.
-     */
-    AxeBuilder.prototype.setLegacyMode = function (legacyMode) {
-        if (legacyMode === void 0) { legacyMode = true; }
-        this.legacyMode = legacyMode;
-        return this;
-    };
-    /**
-     * Analyzes the page, returning a promise
-     */
-    AxeBuilder.prototype.analyzePromise = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var context, runPartialSupported, partials, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        context = (0, index_1.normalizeContext)(this.includes, this.excludes);
-                        return [4 /*yield*/, this.driver.switchTo().defaultContent()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, (0, browser_1.axeSourceInject)(this.driver, this.axeSource, this.config)];
-                    case 2:
-                        runPartialSupported = (_a.sent()).runPartialSupported;
-                        if (runPartialSupported !== true || this.legacyMode) {
-                            return [2 /*return*/, this.runLegacy(context)];
-                        }
-                        return [4 /*yield*/, this.runPartialRecursive(context, true)];
-                    case 3:
-                        partials = _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        _a.trys.push([4, 6, , 7]);
-                        return [4 /*yield*/, this.finishRun(partials)];
-                    case 5: return [2 /*return*/, _a.sent()];
-                    case 6:
-                        error_1 = _a.sent();
-                        throw new Error("".concat(error_1.message, "\n Please check out ").concat(this.errorUrl));
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Use axe.run() to get results from the page
-     */
-    AxeBuilder.prototype.runLegacy = function (context) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, driver, axeSource, builderOptions, config, injector;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this, driver = _a.driver, axeSource = _a.axeSource, builderOptions = _a.builderOptions;
-                        config = this.config;
-                        if (!this.legacyMode) {
-                            config = __assign(__assign({}, (config || {})), { allowedOrigins: ['<unsafe_all_origins>'] });
-                        }
-                        injector = new axe_injector_1.default({
-                            driver: driver,
-                            axeSource: axeSource,
-                            config: config,
-                            builderOptions: builderOptions
-                        });
-                        return [4 /*yield*/, injector.injectIntoAllFrames()];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/, (0, browser_1.axeRunLegacy)(this.driver, context, this.option, this.config)];
-                }
-            });
-        });
-    };
-    /**
-     * Get partial results from the current context and its child frames
-     */
-    AxeBuilder.prototype.runPartialRecursive = function (context, initiator) {
-        if (initiator === void 0) { initiator = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var frameContexts, partials, _i, frameContexts_1, _a, frameContext, frameSelector, frame, switchedFrame, _b, _c, _d, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!!initiator) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (0, browser_1.axeSourceInject)(this.driver, this.axeSource, this.config)];
-                    case 1:
-                        _f.sent();
-                        _f.label = 2;
-                    case 2: return [4 /*yield*/, (0, browser_1.axeGetFrameContext)(this.driver, context)];
-                    case 3:
-                        frameContexts = _f.sent();
-                        return [4 /*yield*/, (0, browser_1.axeRunPartial)(this.driver, context, this.option)];
-                    case 4:
-                        partials = [
-                            _f.sent()
-                        ];
-                        _i = 0, frameContexts_1 = frameContexts;
-                        _f.label = 5;
-                    case 5:
-                        if (!(_i < frameContexts_1.length)) return [3 /*break*/, 14];
-                        _a = frameContexts_1[_i], frameContext = _a.frameContext, frameSelector = _a.frameSelector, frame = _a.frame;
-                        switchedFrame = false;
-                        _f.label = 6;
-                    case 6:
-                        _f.trys.push([6, 10, , 13]);
-                        (0, assert_1.default)(frame, "Expect frame of \"".concat(frameSelector, "\" to be defined"));
-                        return [4 /*yield*/, this.driver.switchTo().frame(frame)];
-                    case 7:
-                        _f.sent();
-                        switchedFrame = true;
-                        _c = (_b = partials.push).apply;
-                        _d = [partials];
-                        return [4 /*yield*/, this.runPartialRecursive(frameContext)];
-                    case 8:
-                        _c.apply(_b, _d.concat([(_f.sent())]));
-                        return [4 /*yield*/, this.driver.switchTo().parentFrame()];
-                    case 9:
-                        _f.sent();
-                        return [3 /*break*/, 13];
-                    case 10:
-                        _e = _f.sent();
-                        if (!switchedFrame) return [3 /*break*/, 12];
-                        return [4 /*yield*/, this.driver.switchTo().parentFrame()];
-                    case 11:
-                        _f.sent();
-                        _f.label = 12;
-                    case 12:
-                        partials.push('null');
-                        return [3 /*break*/, 13];
-                    case 13:
-                        _i++;
-                        return [3 /*break*/, 5];
-                    case 14: return [2 /*return*/, partials];
-                }
-            });
-        });
-    };
-    /**
-     * Use axe.finishRun() to turn partial results into actual results
-     */
-    AxeBuilder.prototype.finishRun = function (partials) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, driver, axeSource, config, option, win, handlers, error_2, res;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this, driver = _a.driver, axeSource = _a.axeSource, config = _a.config, option = _a.option;
-                        return [4 /*yield*/, driver.getWindowHandle()];
-                    case 1:
-                        win = _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 7, , 8]);
-                        return [4 /*yield*/, driver.executeScript("window.open('about:blank')")];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, driver.getAllWindowHandles()];
-                    case 4:
-                        handlers = _b.sent();
-                        return [4 /*yield*/, driver.switchTo().window(handlers[handlers.length - 1])];
-                    case 5:
-                        _b.sent();
-                        return [4 /*yield*/, driver.get('about:blank')];
-                    case 6:
-                        _b.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
-                        error_2 = _b.sent();
-                        throw new Error("switchTo failed. Are you using updated browser drivers? \nDriver reported:\n".concat(error_2));
-                    case 8: return [4 /*yield*/, (0, browser_1.axeFinishRun)(driver, axeSource, config, partials, option)];
-                    case 9:
-                        res = _b.sent();
-                        return [4 /*yield*/, driver.close()];
-                    case 10:
-                        _b.sent();
-                        return [4 /*yield*/, driver.switchTo().window(win)];
-                    case 11:
-                        _b.sent();
-                        return [2 /*return*/, res];
-                }
-            });
-        });
-    };
-    return AxeBuilder;
-}());
-exports = module.exports = AxeBuilder;
-exports.default = AxeBuilder;
-//# sourceMappingURL=index.js.map
+        partials.push("null");
+      }
+    }
+    return partials;
+  }
+  /**
+   * Use axe.finishRun() to turn partial results into actual results
+   */
+  async finishRun(partials) {
+    const { driver, axeSource, config, option } = this;
+    const win = await driver.getWindowHandle();
+    try {
+      await driver.executeScript(`window.open('about:blank')`);
+      const handlers = await driver.getAllWindowHandles();
+      await driver.switchTo().window(handlers[handlers.length - 1]);
+      await driver.get("about:blank");
+    } catch (error2) {
+      throw new Error(
+        `switchTo failed. Are you using updated browser drivers? 
+Driver reported:
+${error2}`
+      );
+    }
+    const res = await axeFinishRun(driver, axeSource, config, partials, option);
+    await driver.close();
+    await driver.switchTo().window(win);
+    return res;
+  }
+};
+if (typeof module === "object") {
+  exports = module.exports = AxeBuilder;
+}
+var src_default = AxeBuilder;