@axe-core/playwright 4.3.3-alpha.223 → 4.3.3-alpha.227

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@axe-core/playwright",
-  "version": "4.3.3-alpha.223+b32603a",
+  "version": "4.3.3-alpha.227+9f1fa5d",
   "description": "Provides a method to inject and analyze web pages using axe",
   "contributors": [
     {
       "name": "Michael Siek (me@michaelsiek.com)"
     }
   ],
+  "files": [
+    "/dist"
+  ],
   "keywords": [
     "a11y",
     "unit",
@@ -77,5 +80,5 @@
     "functions": 100,
     "lines": 95
   },
-  "gitHead": "b32603a4904fad8968d401d1bb78381d5229e067"
+  "gitHead": "9f1fa5d8cb7c2c87bd6e92fe7b13b961e3d73f37"
 }

package/error-handling.md

@@ -1,43 +0,0 @@
-# Error Handling
-
-## Table of Content
-
-1. [Having Popup blockers enabled](#having-popup-blockers-enabled)
-2. [AxeBuilder.setLegacyMode(legacy: boolean)](#axebuildersetlegacymodelegacy-boolean)
-
-Version 4.3.0 and above of the axe-core integrations use a new technique when calling `AxeBuilder.analyze()` which opens a new window at the end of a run. Many of the issues outlined in this document address common problems with this technique and their potential solutions.
-
-### Having Popup blockers enabled
-
-Popup blockers prevent us from opening the new window when calling `AxeBuilder.analyze()`. The default configuration for most automation testing libraries should allow popups. Please make sure that you do not explicitly enable popup blockers which may cause an issue while running the tests.
-
-### AxeBuilder.setLegacyMode(legacy: boolean)
-
-If for some reason you are unable to run the new `AxeBuilder.analyze` technique without errors, axe provides a new chainable method that allows you to run the legacy version of `AxeBuilder.analyze`. When using this method axe excludes accessibility issues that may occur in cross-domain frames and iframes.
-
-**Please Note:** `AxeBuilder.setLegacyMode` is deprecated and will be removed in v5.0. Please report any errors you may have while running `AxeBuilder.analyze` so that they can be fixed before the legacy version is removed.
-
-#### Example:
-
-```js
-const AxeBuilder = require('@axe-core/playwright').default;
-const playwright = require('playwright');
-
-(async () => {
-  const browser = await playwright.chromium.launch();
-  const context = await browser.newContext();
-  const page = await context.newPage();
-  await page.goto('https://dequeuniversity.com/demo/mars/');
-
-  try {
-    const results = await new AxeBuilder({ page })
-      // enables legacy mode
-      .setLegacyMode()
-      .analyze();
-    console.log(results);
-  } catch (e) {
-    // do something with the error
-  }
-  await browser.close();
-})();
-```

package/example.js

@@ -1,12 +0,0 @@
-const AxeBuilder = require('@axe-core/playwright').default;
-const playwright = require('playwright');
-
-(async () => {
-  const browser = await playwright.chromium.launch();
-  const context = await browser.newContext();
-  const page = await context.newPage();
-  await page.goto('https://dequeuniversity.com/demo/mars/');
-  const results = await new AxeBuilder({ page }).analyze();
-  console.log(results);
-  await browser.close();
-})();

package/src/AxePartialRunner.ts

@@ -1,51 +0,0 @@
-import * as axe from 'axe-core';
-/**
- * This class parallelizes the async calls to axe.runPartial.
- *
- * In this project, most async calls needs to block execution, such as
- * the axeGetFrameContext() and getChildFrame() and calls.
- *
- * Unlike those calls, axe.runPartial() calls must run in parallel, so that
- * frame tests don't wait for each other. This is necessary to minimize the time
- * between when axe-core finds a frame, and when it is tested.
- */
-
-type GetPartialResultsResponse = Parameters<typeof axe.finishRun>[0];
-export default class AxePartialRunner {
-  private partialPromise: Promise<axe.PartialResult>;
-  private childRunners: Array<AxePartialRunner | null> = [];
-
-  constructor(
-    partialPromise: Promise<axe.PartialResult>,
-    private initiator: boolean = false
-  ) {
-    this.partialPromise = caught(partialPromise);
-  }
-
-  public addChildResults(childResultRunner: AxePartialRunner | null): void {
-    this.childRunners.push(childResultRunner);
-  }
-
-  public async getPartials(): Promise<GetPartialResultsResponse> {
-    try {
-      const parentPartial = await this.partialPromise;
-      const childPromises = this.childRunners.map(childRunner => {
-        return childRunner ? caught(childRunner.getPartials()) : [null];
-      });
-      const childPartials = (await Promise.all(childPromises)).flat(1);
-      return [parentPartial, ...childPartials];
-    } catch (e) {
-      if (this.initiator) {
-        throw e;
-      }
-      return [null];
-    }
-  }
-}
-
-// Utility to tell NodeJS not to worry about catching promise errors async.
-// See: https://stackoverflow.com/questions/40920179/should-i-refrain-from-handling-promise-rejection-asynchronously
-export const caught = ((f: () => void) => {
-  return <T>(p: Promise<T>): Promise<T> => (p.catch(f), p);
-  /* eslint-disable @typescript-eslint/no-empty-function */
-})(() => {});

package/src/browser.ts

@@ -1,43 +0,0 @@
-/* istanbul ignore file */
-import type {
-  GetFrameContextsParams,
-  RunPartialParams,
-  FinishRunParams,
-  ShadowSelectParams
-} from './types';
-import { FrameContext, AxeResults, PartialResult } from 'axe-core';
-import * as axeCore from 'axe-core';
-
-// Expect axe to be set up.
-// Tell Typescript that there should be a global variable called `axe` that follows
-// the shape given by the `axe-core` typings (the `run` and `configure` functions).
-declare global {
-  interface Window {
-    axe: typeof axeCore;
-  }
-}
-export const axeGetFrameContexts = ({
-  context
-}: GetFrameContextsParams): FrameContext[] => {
-  return window.axe.utils.getFrameContexts(context);
-};
-
-export const axeShadowSelect = ({
-  frameSelector
-}: ShadowSelectParams): Element | null => {
-  return window.axe.utils.shadowSelect(frameSelector);
-};
-
-export const axeRunPartial = ({
-  context,
-  options
-}: RunPartialParams): Promise<PartialResult> => {
-  return window.axe.runPartial(context, options);
-};
-
-export const axeFinishRun = ({
-  partialResults,
-  options
-}: FinishRunParams): Promise<AxeResults> => {
-  return window.axe.finishRun(partialResults, options);
-};

package/src/index.ts

@@ -1,299 +0,0 @@
-import * as fs from 'fs';
-import * as assert from 'assert';
-import type { Page, Frame, ElementHandle } from 'playwright';
-import type {
-  RunOptions,
-  AxeResults,
-  ContextObject,
-  PartialResults
-} from 'axe-core';
-import { normalizeContext, analyzePage } from './utils';
-import type { AxePlaywrightParams } from './types';
-import {
-  axeFinishRun,
-  axeGetFrameContexts,
-  axeRunPartial,
-  axeShadowSelect
-} from './browser';
-import AxePartialRunner from './AxePartialRunner';
-
-export default class AxeBuilder {
-  private page: Page;
-  private includes: string[][];
-  private excludes: string[][];
-  private option: RunOptions;
-  private source: string;
-  private legacyMode = false;
-
-  constructor({ page, axeSource }: AxePlaywrightParams) {
-    const axePath = require.resolve('axe-core');
-    const source = fs.readFileSync(axePath, 'utf-8');
-    this.page = page;
-    this.includes = [];
-    this.excludes = [];
-    this.option = {};
-    this.source = axeSource || source;
-  }
-
-  /**
-   * Selector to include in analysis.
-   * This may be called any number of times.
-   * @param String selector
-   * @returns this
-   */
-
-  public include(selector: string | string[]): this {
-    selector = Array.isArray(selector) ? selector : [selector];
-    this.includes.push(selector);
-    return this;
-  }
-
-  /**
-   * Selector to exclude in analysis.
-   * This may be called any number of times.
-   * @param String selector
-   * @returns this
-   */
-
-  public exclude(selector: string | string[]): this {
-    selector = Array.isArray(selector) ? selector : [selector];
-    this.excludes.push(selector);
-    return this;
-  }
-
-  /**
-   * Set options to be passed into axe-core
-   * @param RunOptions options
-   * @returns AxeBuilder
-   */
-
-  public options(options: RunOptions): this {
-    this.option = options;
-    return this;
-  }
-
-  /**
-   * Limit analysis to only the specified rules.
-   * Cannot be used with `AxeBuilder#withTags`
-   * @param String|Array rules
-   * @returns this
-   */
-
-  public withRules(rules: string | string[]): this {
-    rules = Array.isArray(rules) ? rules : [rules];
-    /* istanbul ignore next */
-    this.option = this.option || {};
-    this.option.runOnly = {
-      type: 'rule',
-      values: rules
-    };
-
-    return this;
-  }
-
-  /**
-   * Limit analysis to only specified tags.
-   * Cannot be used with `AxeBuilder#withRules`
-   * @param String|Array tags
-   * @returns this
-   */
-
-  public withTags(tags: string | string[]): this {
-    tags = Array.isArray(tags) ? tags : [tags];
-    /* istanbul ignore next */
-    this.option = this.option || {};
-    this.option.runOnly = {
-      type: 'tag',
-      values: tags
-    };
-    return this;
-  }
-
-  /**
-   * Set the list of rules to skip when running an analysis.
-   * @param String|Array rules
-   * @returns this
-   */
-
-  public disableRules(rules: string | string[]): this {
-    rules = Array.isArray(rules) ? rules : [rules];
-    /* istanbul ignore next */
-    this.option = this.option || {};
-    this.option.rules = {};
-
-    for (const rule of rules) {
-      this.option.rules[rule] = { enabled: false };
-    }
-    return this;
-  }
-
-  /**
-   * 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.
-   */
-  public setLegacyMode(legacyMode = true): this {
-    this.legacyMode = legacyMode;
-    return this;
-  }
-
-  /**
-   * Perform analysis and retrieve results. *Does not chain.*
-   * @return Promise<Result | Error>
-   */
-
-  public async analyze(): Promise<AxeResults> {
-    const context = normalizeContext(this.includes, this.excludes);
-    const { page, option: options } = this;
-
-    page.evaluate(this.script());
-    const runPartialDefined = await page.evaluate<boolean>(
-      'typeof window.axe.runPartial === "function"'
-    );
-
-    let results: AxeResults;
-
-    if (!runPartialDefined || this.legacyMode) {
-      results = await this.runLegacy(context);
-      return results;
-    }
-    const partialResults = await this.runPartialRecursive(
-      page.mainFrame(),
-      context
-    );
-    const partials = await partialResults.getPartials();
-
-    try {
-      return await this.finishRun(partials);
-    } catch (error) {
-      throw new Error(
-        `${
-          (error as Error).message
-        }\n Please check out https://github.com/dequelabs/axe-core-npm/blob/develop/packages/playwright/error-handling.md`
-      );
-    }
-  }
-
-  /**
-   * Injects `axe-core` into all frames.
-   * @param Page - playwright page object
-   * @returns Promise<void>
-   */
-
-  private async inject(frames: Frame[]): Promise<void> {
-    for (const iframe of frames) {
-      await iframe.evaluate(this.script());
-    }
-  }
-
-  /**
-   * Get axe-core source and configurations
-   * @returns String
-   */
-
-  private script(): string {
-    return `
-      ${this.source}
-      axe.configure({
-        ${this.legacyMode ? '' : 'allowedOrigins: ["<unsafe_all_origins>"],'}
-        branding: { application: 'playwright' }
-      })
-    `;
-  }
-
-  private async runLegacy(context: ContextObject): Promise<AxeResults> {
-    // in playwright all frames are available in `.frames()`, even nested and
-    // shadowDOM iframes. also navigating to a url causes it to be put into
-    // an iframe so we don't need to inject into the page object itself
-    const frames = this.page.frames();
-    await this.inject(frames);
-    const axeResults = await this.page.evaluate(analyzePage, {
-      context,
-      options: this.option
-    });
-
-    if (axeResults.error) {
-      throw new Error(axeResults.error);
-    }
-
-    return axeResults.results;
-  }
-
-  /**
-   * Inject `axe-core` into each frame and run `axe.runPartial`.
-   * Because we need to inject axe into all frames all at once
-   * (to avoid any potential problems with the DOM becoming out-of-sync)
-   * but also need to not process results for any child frames if the parent
-   * frame throws an error (requirements of the data structure for `axe.finishRun`),
-   *  we have to return a deeply nested array of Promises and then flatten
-   * the array once all Promises have finished, throwing out any nested Promises
-   * if the parent Promise is not fulfilled.
-   * @param frame - playwright frame object
-   * @param context - axe-core context object
-   * @returns Promise<AxePartialRunner>
-   */
-
-  private async runPartialRecursive(
-    frame: Frame,
-    context: ContextObject
-  ): Promise<AxePartialRunner> {
-    const frameContexts = await frame.evaluate(axeGetFrameContexts, {
-      context
-    });
-    const partialPromise = frame.evaluate(axeRunPartial, {
-      context,
-      options: this.option
-    });
-    const initiator = frame === this.page.mainFrame();
-    const axePartialRunner = new AxePartialRunner(partialPromise, initiator);
-
-    for (const { frameSelector, frameContext } of frameContexts) {
-      let childResults: AxePartialRunner | null = null;
-      try {
-        const iframeHandle = await frame.evaluateHandle(axeShadowSelect, {
-          frameSelector
-        });
-        // note: these can return null but the catch will handle this properly for all cases
-        const iframeElement =
-          iframeHandle.asElement() as ElementHandle<Element>;
-        const childFrame = await iframeElement.contentFrame();
-        if (childFrame) {
-          await this.inject([childFrame]);
-          childResults = await this.runPartialRecursive(
-            childFrame,
-            frameContext
-          );
-        }
-      } catch {
-        /* do nothing */
-      }
-      axePartialRunner.addChildResults(childResults);
-    }
-
-    return axePartialRunner;
-  }
-
-  private async finishRun(partialResults: PartialResults): Promise<AxeResults> {
-    const { page, option: options } = this;
-    const context = page.context();
-    const blankPage = await context.newPage();
-
-    assert(
-      blankPage,
-      'Please make sure that you have popup blockers disabled.'
-    );
-
-    blankPage.evaluate(this.script());
-
-    return await blankPage
-      .evaluate(axeFinishRun, {
-        partialResults,
-        options
-      })
-      .finally(() => {
-        blankPage.close();
-      });
-  }
-}

package/src/types.ts

@@ -1,43 +0,0 @@
-import type { Page } from 'playwright';
-import type {
-  RunOptions,
-  AxeResults,
-  ContextObject,
-  CrossTreeSelector,
-  PartialResult
-} from 'axe-core';
-
-export type PartialResults = PartialResult | null;
-
-export interface AnalyzePageParams {
-  context: ContextObject;
-  options: RunOptions | null;
-}
-
-export interface AxePlaywrightParams {
-  page: Page;
-  axeSource?: string;
-}
-
-export interface AnalyzePageResponse {
-  results: AxeResults;
-  error: string | null;
-}
-
-export interface GetFrameContextsParams {
-  context: ContextObject;
-}
-
-export interface ShadowSelectParams {
-  frameSelector: CrossTreeSelector;
-}
-
-export interface RunPartialParams {
-  context: ContextObject;
-  options: RunOptions;
-}
-
-export interface FinishRunParams {
-  partialResults: PartialResults[];
-  options: RunOptions;
-}

package/src/utils.ts

@@ -1,50 +0,0 @@
-import type { AxeResults, ContextObject } from 'axe-core';
-import type { AnalyzePageParams, AnalyzePageResponse } from './types';
-
-/**
- * Get running context
- * @param Array include
- * @param Array exclude
- * @returns ContextObject
- */
-
-export const normalizeContext = (
-  includes: string[][],
-  excludes: string[][]
-): ContextObject => {
-  const base: ContextObject = {
-    exclude: []
-  };
-  if (excludes.length && Array.isArray(base.exclude)) {
-    base.exclude.push(...excludes);
-  }
-
-  if (includes.length) {
-    base.include = includes;
-  }
-  return base;
-};
-
-/**
- * Analyze the page.
- * @param AnalyzePageParams analyzeContext
- * @returns Promise<AnalyzePageResponse>
- */
-
-export const analyzePage = ({
-  context,
-  options
-}: AnalyzePageParams): Promise<AnalyzePageResponse> => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const axeCore = (window as any).axe;
-
-  // Run axe-core
-  return axeCore
-    .run(context || document, options || {})
-    .then((results: AxeResults) => {
-      return { error: null, results };
-    })
-    .catch((err: Error) => {
-      return { error: err.message, results: null };
-    });
-};

package/tests/axe-playwright.spec.ts

@@ -1,710 +0,0 @@
-import 'mocha';
-import * as fs from 'fs';
-import * as playwright from 'playwright';
-import * as express from 'express';
-import type { AxeResults } from 'axe-core';
-import testListen = require('test-listen');
-import { assert } from 'chai';
-import * as path from 'path';
-import { Server, createServer } from 'http';
-import AxeBuilder from '../src';
-
-describe('@axe-core/playwright', () => {
-  let server: Server;
-  let addr: string;
-  let page: playwright.Page;
-  const axePath = require.resolve('axe-core');
-  const axeSource = fs.readFileSync(axePath, 'utf8');
-  let browser: playwright.ChromiumBrowser;
-  const axeTestFixtures = path.resolve(__dirname, 'fixtures');
-  const externalPath = path.resolve(axeTestFixtures, 'external');
-  const axeLegacySource = fs.readFileSync(
-    path.join(externalPath, 'axe-core@legacy.js'),
-    'utf-8'
-  );
-  const axeCrasherSource = fs.readFileSync(
-    path.join(externalPath, 'axe-crasher.js'),
-    'utf8'
-  );
-  const axeForceLegacy = fs.readFileSync(
-    path.join(externalPath, 'axe-force-legacy.js'),
-    'utf8'
-  );
-
-  before(async () => {
-    const app = express();
-    app.use(express.static(axeTestFixtures));
-    server = createServer(app);
-    addr = await testListen(server);
-  });
-
-  after(async () => {
-    server.close();
-  });
-
-  beforeEach(async () => {
-    browser = await playwright.chromium.launch({
-      args: ['--disable-dev-shm-usage']
-    });
-    const context = await browser.newContext();
-    page = await context.newPage();
-  });
-
-  afterEach(async () => {
-    await browser.close();
-  });
-
-  describe('analyze', () => {
-    it('returns results using a different version of axe-core', async () => {
-      await page.goto(`${addr}/index.html`);
-      const results = await new AxeBuilder({
-        page,
-        axeSource: axeLegacySource
-      }).analyze();
-      assert.strictEqual(results.testEngine.version, '4.0.3');
-      assert.isNotNull(results);
-      assert.isArray(results.violations);
-      assert.isArray(results.incomplete);
-      assert.isArray(results.passes);
-      assert.isArray(results.inapplicable);
-    });
-
-    it('returns results', async () => {
-      await page.goto(`${addr}/index.html`);
-      const results = await new AxeBuilder({ page }).analyze();
-      assert.isNotNull(results);
-      assert.isArray(results.violations);
-      assert.isArray(results.incomplete);
-      assert.isArray(results.passes);
-      assert.isArray(results.inapplicable);
-    });
-
-    it('returns correct results metadata', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page }).analyze();
-      assert.isDefined(results.testEngine.name);
-      assert.isDefined(results.testEngine.version);
-      assert.isDefined(results.testEnvironment.orientationAngle);
-      assert.isDefined(results.testEnvironment.orientationType);
-      assert.isDefined(results.testEnvironment.userAgent);
-      assert.isDefined(results.testEnvironment.windowHeight);
-      assert.isDefined(results.testEnvironment.windowWidth);
-      assert.isDefined(results.testRunner.name);
-      assert.isDefined(results.toolOptions.reporter);
-      assert.equal(results.url, `${addr}/external/index.html`);
-    });
-
-    it('properly isolates the call to axe.finishRun', async () => {
-      let err;
-      await page.goto(`${addr}/external/isolated-finish.html`);
-      try {
-        await new AxeBuilder({ page }).analyze();
-      } catch (e) {
-        err = e;
-      }
-      assert.isUndefined(err);
-    });
-
-    it('reports frame-tested', async () => {
-      await page.goto(`${addr}/external/crash-parent.html`);
-      const results = await new AxeBuilder({
-        page,
-        axeSource: axeSource + axeCrasherSource
-      })
-        .options({ runOnly: ['label', 'frame-tested'] })
-        .analyze();
-      assert.equal(results.incomplete[0].id, 'frame-tested');
-      assert.lengthOf(results.incomplete[0].nodes, 1);
-      assert.equal(results.violations[0].id, 'label');
-      assert.lengthOf(results.violations[0].nodes, 2);
-    });
-
-    it('throws when injecting a problematic source', async () => {
-      let error: Error | null = null;
-      await page.goto(`${addr}/external/crash-me.html`);
-      try {
-        await new AxeBuilder({
-          page,
-          axeSource: 'throw new Error()'
-        }).analyze();
-      } catch (e) {
-        error = e as Error;
-      }
-      assert.isNotNull(error);
-    });
-
-    it('throws when a setup fails', async () => {
-      let error: Error | null = null;
-
-      const brokenSource = axeSource + `;window.axe.utils = {}`;
-      await page.goto(`${addr}/external/index.html`);
-      try {
-        await new AxeBuilder({ page, axeSource: brokenSource })
-          .withRules('label')
-          .analyze();
-      } catch (e) {
-        error = e as Error;
-      }
-
-      assert.isNotNull(error);
-    });
-
-    it('returns the same results from runPartial as from legacy mode', async () => {
-      await page.goto(`${addr}/nested-iframes.html`);
-      const legacyResults = await new AxeBuilder({
-        page,
-        axeSource: axeSource + axeForceLegacy
-      }).analyze();
-      assert.equal(legacyResults.testEngine.name, 'axe-legacy');
-
-      const normalResults = await new AxeBuilder({ page, axeSource }).analyze();
-      normalResults.timestamp = legacyResults.timestamp;
-      normalResults.testEngine.name = legacyResults.testEngine.name;
-      assert.deepEqual(normalResults, legacyResults);
-    });
-  });
-
-  describe('disableRules', () => {
-    it('disables the given rules(s) as array', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .disableRules(['region'])
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.isTrue(!all.find(r => r.id === 'region'));
-    });
-
-    it('disables the given rules(s) as string', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .disableRules('region')
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.isTrue(!all.find(r => r.id === 'region'));
-    });
-  });
-
-  describe('withRules', () => {
-    it('only runs the provided rules as an array', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .withRules(['region'])
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.strictEqual(all.length, 1);
-      assert.strictEqual(all[0].id, 'region');
-    });
-
-    it('only runs the provided rules as a string', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .withRules('region')
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.strictEqual(all.length, 1);
-      assert.strictEqual(all[0].id, 'region');
-    });
-  });
-
-  describe('options', () => {
-    it('passes options to axe-core', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .options({ rules: { region: { enabled: false } } })
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.isTrue(!all.find(r => r.id === 'region'));
-    });
-  });
-
-  describe('withTags', () => {
-    it('only rules rules with the given tag(s) as an array', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .withTags(['best-practice'])
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.isOk(all);
-      for (const rule of all) {
-        assert.include(rule.tags, 'best-practice');
-      }
-    });
-
-    it('only rules rules with the given tag(s) as a string', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .withTags('best-practice')
-        .analyze();
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      assert.isOk(all);
-      for (const rule of all) {
-        assert.include(rule.tags, 'best-practice');
-      }
-    });
-
-    it('No results provided when the given tag(s) is invalid', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({ page })
-        .withTags(['foobar'])
-        .analyze();
-
-      const all = [
-        ...results.passes,
-        ...results.inapplicable,
-        ...results.violations,
-        ...results.incomplete
-      ];
-      // Ensure all run rules had the "foobar" tag
-      assert.deepStrictEqual(0, all.length);
-    });
-  });
-
-  describe('frame tests', () => {
-    it('injects into nested iframes', async () => {
-      await page.goto(`${addr}/external/nested-iframes.html`);
-      const { violations } = await new AxeBuilder({ page })
-        .options({ runOnly: 'label' })
-        .analyze();
-
-      assert.equal(violations[0].id, 'label');
-      const nodes = violations[0].nodes;
-      assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes[0].target, [
-        '#ifr-foo',
-        '#foo-bar',
-        '#bar-baz',
-        'input'
-      ]);
-      assert.deepEqual(nodes[1].target, ['#ifr-foo', '#foo-baz', 'input']);
-      assert.deepEqual(nodes[2].target, ['#ifr-bar', '#bar-baz', 'input']);
-      assert.deepEqual(nodes[3].target, ['#ifr-baz', 'input']);
-    });
-
-    it('injects into nested frameset', async () => {
-      await page.goto(`${addr}/external/nested-frameset.html`);
-      const { violations } = await new AxeBuilder({ page })
-        .options({ runOnly: 'label' })
-        .analyze();
-
-      assert.equal(violations[0].id, 'label');
-      assert.lengthOf(violations[0].nodes, 4);
-
-      const nodes = violations[0].nodes;
-      assert.deepEqual(nodes[0].target, [
-        '#frm-foo',
-        '#foo-bar',
-        '#bar-baz',
-        'input'
-      ]);
-      assert.deepEqual(nodes[1].target, ['#frm-foo', '#foo-baz', 'input']);
-      assert.deepEqual(nodes[2].target, ['#frm-bar', '#bar-baz', 'input']);
-      assert.deepEqual(nodes[3].target, ['#frm-baz', 'input']);
-    });
-
-    it('should work on shadow DOM iframes', async () => {
-      await page.goto(`${addr}/external/shadow-frames.html`);
-      const { violations } = await new AxeBuilder({ page })
-        .options({ runOnly: 'label' })
-        .analyze();
-
-      assert.equal(violations[0].id, 'label');
-      assert.lengthOf(violations[0].nodes, 3);
-
-      const nodes = violations[0].nodes;
-      assert.deepEqual(nodes[0].target, ['#light-frame', 'input']);
-      assert.deepEqual(nodes[1].target, [
-        ['#shadow-root', '#shadow-frame'],
-        'input'
-      ]);
-      assert.deepEqual(nodes[2].target, ['#slotted-frame', 'input']);
-    });
-
-    it('injects once per iframe', async () => {
-      await page.goto(`${addr}/external/nested-iframes.html`);
-
-      const builder = new AxeBuilder({ page });
-      const origScript = (builder as any).script;
-      let count = 0;
-      Object.defineProperty(builder, 'script', {
-        get() {
-          count++;
-          return origScript;
-        }
-      });
-
-      await builder.analyze();
-
-      assert.strictEqual(count, 9);
-    });
-  });
-
-  describe('include/exclude', () => {
-    const flatPassesTargets = (results: AxeResults): string[] => {
-      return results.passes
-        .reduce((acc, pass) => {
-          return acc.concat(pass.nodes as any);
-        }, [])
-        .reduce((acc, node: any) => {
-          return acc.concat(node.target);
-        }, []);
-    };
-    it('with include and exclude', async () => {
-      await page.goto(`${addr}/context.html`);
-      const results = await new AxeBuilder({ page })
-        .include('.include')
-        .exclude('.exclude')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-
-      assert.strictEqual(flattenTarget[0], '.include');
-      assert.notInclude(flattenTarget, '.exclude');
-    });
-
-    it('with only include', async () => {
-      await page.goto(`${addr}/context.html`);
-      const results = await new AxeBuilder({ page })
-        .include('.include')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-      assert.strictEqual(flattenTarget[0], '.include');
-    });
-
-    it('with only exclude', async () => {
-      await page.goto(`${addr}/context.html`);
-      const results = await new AxeBuilder({ page })
-        .exclude('.exclude')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-
-      assert.notInclude(flattenTarget, '.exclude');
-    });
-
-    it('with chaining includes', async () => {
-      await page.goto(`${addr}/context.html`);
-
-      const results = await new AxeBuilder({ page })
-        .include('.include')
-        .include('.include2')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-
-      assert.strictEqual(flattenTarget[0], '.include');
-      assert.strictEqual(flattenTarget[1], '.include2');
-      assert.notInclude(flattenTarget, '.exclude');
-      assert.notInclude(flattenTarget, '.exclude2');
-    });
-
-    it('with chaining excludes', async () => {
-      await page.goto(`${addr}/context.html`);
-      const results = await new AxeBuilder({ page })
-        .exclude('.exclude')
-        .exclude('.exclude2')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-
-      assert.notInclude(flattenTarget, '.exclude');
-      assert.notInclude(flattenTarget, '.exclude2');
-    });
-
-    it('with chaining includes and excludes', async () => {
-      await page.goto(`${addr}/context.html`);
-      const results = await new AxeBuilder({ page })
-        .include('.include')
-        .include('.include2')
-        .exclude('.exclude')
-        .exclude('.exclude2')
-        .analyze();
-      const flattenTarget = flatPassesTargets(results);
-
-      assert.strictEqual(flattenTarget[0], '.include');
-      assert.strictEqual(flattenTarget[1], '.include2');
-      assert.notInclude(flattenTarget, '.exclude');
-      assert.notInclude(flattenTarget, '.exclude2');
-    });
-
-    it('with include using an array of strings', async () => {
-      await page.goto(`${addr}/context.html`);
-      const expected = ['.selector-one', '.selector-two', '.selector-three'];
-
-      const axeSource = `
-      window.axe = {
-        configure(){},
-          run({ include }){
-            return Promise.resolve({ include })
-          }
-      }
-    `;
-      const results = new AxeBuilder({ page, axeSource: axeSource }).include([
-        '.selector-one',
-        '.selector-two',
-        '.selector-three'
-      ]);
-
-      const { include: actual } = (await results.analyze()) as any;
-
-      assert.deepEqual(actual[0], expected);
-    });
-
-    it('with exclude using an array of strings', async () => {
-      await page.goto(`${addr}/context.html`);
-      const expected = ['.selector-one', '.selector-two', '.selector-three'];
-
-      const axeSource = `
-      window.axe = {
-        configure(){},
-          run({ exclude }){
-            return Promise.resolve({ exclude })
-          }
-      }
-    `;
-      const results = new AxeBuilder({ page, axeSource: axeSource }).exclude([
-        '.selector-one',
-        '.selector-two',
-        '.selector-three'
-      ]);
-
-      const { exclude: actual } = (await results.analyze()) as any;
-
-      assert.deepEqual(actual[0], expected);
-    });
-  });
-
-  describe('axe.finishRun errors', () => {
-    const finishRunThrows = `;axe.finishRun = () => { throw new Error("No finishRun")}`;
-
-    it('throws an error if axe.finishRun throws', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-      //@ts-ignore
-      delete page.context().newPage;
-      // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-      //@ts-ignore
-      page.context().newPage = () => {
-        return null;
-      };
-
-      try {
-        await new AxeBuilder({
-          page,
-          axeSource: axeSource
-        }).analyze();
-        assert.fail('Should have thrown');
-      } catch (err) {
-        assert.match(
-          (err as Error).message,
-          /Please make sure that you have popup blockers disabled./
-        );
-      }
-    });
-
-    it('throws an error if axe.finishRun throws', async () => {
-      await page.goto(`${addr}/external/index.html`);
-
-      try {
-        await new AxeBuilder({
-          page,
-          axeSource: axeSource + finishRunThrows
-        }).analyze();
-        assert.fail('Should have thrown');
-      } catch (err) {
-        assert.match((err as Error).message, /Please check out/);
-      }
-    });
-  });
-
-  describe('setLegacyMode', () => {
-    const runPartialThrows = `;axe.runPartial = () => { throw new Error("No runPartial")}`;
-    it('runs legacy mode when used', async () => {
-      await page.goto(`${addr}/external/index.html`);
-      const results = await new AxeBuilder({
-        page,
-        axeSource: axeSource + runPartialThrows
-      })
-        .setLegacyMode()
-        .analyze();
-      assert.isNotNull(results);
-    });
-
-    it('prevents cross-origin frame testing', async () => {
-      await page.goto(`${addr}/external/cross-origin.html`);
-      const results = await new AxeBuilder({
-        page,
-        axeSource: axeSource + runPartialThrows
-      })
-        .withRules('frame-tested')
-        .setLegacyMode()
-        .analyze();
-
-      const frameTested = results.incomplete.find(
-        ({ id }) => id === 'frame-tested'
-      );
-      assert.ok(frameTested);
-    });
-
-    it('can be disabled again', async () => {
-      await page.goto(`${addr}/external/cross-origin.html`);
-      const results = await new AxeBuilder({ page })
-        .withRules('frame-tested')
-        .setLegacyMode()
-        .setLegacyMode(false)
-        .analyze();
-
-      const frameTested = results.incomplete.find(
-        ({ id }) => id === 'frame-tested'
-      );
-      assert.isUndefined(frameTested);
-    });
-  });
-
-  describe('for versions without axe.runPartial', () => {
-    describe('analyze', () => {
-      it('returns results', async () => {
-        await page.goto(`${addr}/external/index.html`);
-        const results = await new AxeBuilder({
-          page,
-          axeSource: axeLegacySource
-        }).analyze();
-        assert.strictEqual(results.testEngine.version, '4.0.3');
-        assert.isNotNull(results);
-        assert.isArray(results.violations);
-        assert.isArray(results.incomplete);
-        assert.isArray(results.passes);
-        assert.isArray(results.inapplicable);
-      });
-
-      it('throws if axe errors out on the top window', async () => {
-        let error: Error | null = null;
-        await page.goto(`${addr}/external/crash.html`);
-        try {
-          await new AxeBuilder({
-            page,
-            axeSource: axeLegacySource + axeCrasherSource
-          }).analyze();
-        } catch (e) {
-          error = e as Error;
-        }
-        assert.isNotNull(error);
-      });
-
-      it('tests cross-origin pages', async () => {
-        await page.goto(`${addr}/external/cross-origin.html`);
-        const results = await new AxeBuilder({
-          page,
-          axeSource: axeLegacySource
-        })
-          .withRules('frame-tested')
-          .analyze();
-
-        const frameTested = results.incomplete.find(
-          ({ id }) => id === 'frame-tested'
-        );
-        assert.isUndefined(frameTested);
-      });
-    });
-
-    describe('frame tests', () => {
-      it('injects into nested iframes', async () => {
-        await page.goto(`${addr}/external/nested-iframes.html`);
-        const { violations } = await new AxeBuilder({
-          page,
-          axeSource: axeLegacySource
-        })
-          .withRules('label')
-          .analyze();
-
-        assert.equal(violations[0].id, 'label');
-        const nodes = violations[0].nodes;
-        assert.lengthOf(nodes, 4);
-        assert.deepEqual(nodes[0].target, [
-          '#ifr-foo',
-          '#foo-bar',
-          '#bar-baz',
-          'input'
-        ]);
-        assert.deepEqual(nodes[1].target, ['#ifr-foo', '#foo-baz', 'input']);
-        assert.deepEqual(nodes[2].target, ['#ifr-bar', '#bar-baz', 'input']);
-        assert.deepEqual(nodes[3].target, ['#ifr-baz', 'input']);
-      });
-
-      it('injects into nested frameset', async () => {
-        await page.goto(`${addr}/external/nested-frameset.html`);
-        const { violations } = await new AxeBuilder({
-          page,
-          axeSource: axeLegacySource
-        })
-          .withRules('label')
-          .analyze();
-
-        assert.equal(violations[0].id, 'label');
-        assert.lengthOf(violations[0].nodes, 4);
-
-        const nodes = violations[0].nodes;
-        assert.deepEqual(nodes[0].target, [
-          '#frm-foo',
-          '#foo-bar',
-          '#bar-baz',
-          'input'
-        ]);
-        assert.deepEqual(nodes[1].target, ['#frm-foo', '#foo-baz', 'input']);
-        assert.deepEqual(nodes[2].target, ['#frm-bar', '#bar-baz', 'input']);
-        assert.deepEqual(nodes[3].target, ['#frm-baz', 'input']);
-      });
-
-      it('should work on shadow DOM iframes', async () => {
-        await page.goto(`${addr}/external/shadow-frames.html`);
-        const { violations } = await new AxeBuilder({
-          page,
-          axeSource: axeLegacySource
-        })
-          .withRules('label')
-          .analyze();
-
-        assert.equal(violations[0].id, 'label');
-        assert.lengthOf(violations[0].nodes, 3);
-
-        const nodes = violations[0].nodes;
-        assert.deepEqual(nodes[0].target, ['#light-frame', 'input']);
-        assert.deepEqual(nodes[1].target, ['#slotted-frame', 'input']);
-        assert.deepEqual(nodes[2].target, [
-          ['#shadow-root', '#shadow-frame'],
-          'input'
-        ]);
-      });
-    });
-  });
-});

package/tests/fixtures/context.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Context Test</title>
-  </head>
-  <body>
-    <h1>Context Test</h1>
-    <div class="include">include me</div>
-    <div class="include2">include me</div>
-    <div class="exclude">exclude me</div>
-    <div class="exclude2">exclude me</div>
-  </body>
-</html>

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "moduleResolution": "node",
-    "target": "es5",
-    "module": "commonjs",
-    "lib": ["dom", "es2019"],
-    "strict": true,
-    "pretty": true,
-    "sourceMap": true,
-    "declaration": true,
-    "outDir": "dist",
-    "typeRoots": ["node_modules/@types"]
-  },
-  "include": ["src"]
-}