govuk_publishing_components 21.22.1 → 21.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4fbce34bcd064f394e73fd7f2934e8fc63e75c83f7a060074e77f4e5e9dc158
-  data.tar.gz: a4448f2e003b564116ca50fc04b23f8a68f0146c6a7ac8aade4cb2ced2baf85e
+  metadata.gz: 4f90a6f2455647f21585244ee5a6893bfa8474baceee038ca4a5190446a68367
+  data.tar.gz: 49aeec37d6161caa77934cceca478f2ba27f08f6f96eb4018717ab71d19ecbe9
 SHA512:
-  metadata.gz: b649960d546156ccc749d22f80fd109d4a7af1fef1cd6c7891609625a3e6712ef6c14e30693a7b485a4f28142478e3adc785a8c76369c4787c11655439f96b1e
-  data.tar.gz: 16c5887e164e664b97925061636097f0142391b32081ec86a75cee11eef7dc6aa681a2b341b4095b9b0f49ff9c533b2df82f7fa657f611caea7b6594cc617c7f
+  metadata.gz: beb447c9295c02c585f9e0cbacb6302324b31dce14915e34bc3b41654937e3495ddde3364c5abfe860f3469808967f3d58ab2bb3c7db4e8e58951558435e8aca
+  data.tar.gz: 692091eab0e27eb475dffe97d24ce579ac6e6f17f3d8154591a04da2df83344c9a7064ce3615fcecee1e24fab3c7ac2853854494a9a5c1f327459af530037102

data/README.md

@@ -1,4 +1,7 @@
-# GOV.UK Publishing Components
+GOV.UK Publishing Components ·
+[![status](https://badgen.net/github/status/alphagov/govuk_publishing_components/master)](https://ci.integration.publishing.service.gov.uk/job/govuk_publishing_components/job/master/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+=====================
 
 This gem:
 
@@ -8,8 +11,6 @@ This gem:
 
 Components should be added to this gem if they are required in more than one application, otherwise they should be added to that application.
 
-![Screenshot of component guide](docs/screenshot.png)
-
 ## How to
 
 - [Install and use this gem](/docs/install-and-use.md)

data/app/assets/stylesheets/govuk_publishing_components/components/_breadcrumbs.scss

@@ -20,3 +20,37 @@
 .gem-c-breadcrumbs--inverse .govuk-breadcrumbs__list-item:before {
   border-color: govuk-colour("white");
 }
+
+@include govuk-media-query($until: tablet) {
+
+  .govuk-breadcrumbs__list {
+    display: flex;
+  }
+
+  .govuk-breadcrumbs__list-item:not(:last-child):not(:first-child) {
+    display: none;
+  }
+
+  .govuk-breadcrumbs__list-item {
+    padding-top: 14px;
+    padding-bottom: 14px;
+  }
+
+  .govuk-breadcrumbs__list-item:before {
+    margin: 0;
+    top: 18px;
+  }
+
+  .govuk-breadcrumbs__link {
+    position: relative;
+  }
+
+  .govuk-breadcrumbs__link::after {
+    content: "";
+    position: absolute;
+    top: -14px;
+    right: 0;
+    left: 0;
+    bottom: -14px;
+  }
+}

data/app/assets/stylesheets/govuk_publishing_components/components/_document-list.scss

@@ -7,8 +7,8 @@
 
 .gem-c-document-list__item {
   overflow: hidden;
-  margin-bottom: govuk-spacing(2);
-  padding-bottom: govuk-spacing(2);
+  margin-bottom: govuk-spacing(4);
+  padding-bottom: govuk-spacing(4);
   border-bottom: 1px solid $govuk-border-colour;
   list-style: none;
 

data/app/views/govuk_publishing_components/components/_breadcrumbs.html.erb

@@ -1,8 +1,6 @@
 <%
   breadcrumbs ||= []
-  collapse_on_mobile ||= false
   inverse ||= false
-  collapse_class =  collapse_on_mobile && breadcrumbs.any? { |crumb| crumb[:is_page_parent] } ? "gem-c-breadcrumbs--collapse-on-mobile" : ""
   invert_class = inverse ? "gem-c-breadcrumbs--inverse" : ""
   breadcrumb_presenter = GovukPublishingComponents::Presenters::Breadcrumbs.new(breadcrumbs, request.path)
 %>
@@ -33,4 +31,3 @@
     <% end %>
   </ol>
 </div>
-

data/app/views/govuk_publishing_components/components/_contextual_breadcrumbs.html.erb

@@ -15,7 +15,6 @@
           and we want to prioritise them over all other breadcrumbs %>
     <%= render 'govuk_publishing_components/components/breadcrumbs',
                breadcrumbs: navigation.taxon_breadcrumbs[:breadcrumbs],
-               collapse_on_mobile: true,
                inverse: inverse %>
   <% elsif navigation.content_tagged_to_mainstream_browse_pages? %>
     <%# Rendering parent-based breadcrumbs because the page is tagged to mainstream browse %>
@@ -27,7 +26,6 @@
     <%# Rendering taxonomy breadcrumbs because the page is tagged to live taxons %>
     <%= render 'govuk_publishing_components/components/breadcrumbs',
       breadcrumbs: navigation.taxon_breadcrumbs[:breadcrumbs],
-      collapse_on_mobile: true,
       inverse: inverse %>
   <% elsif navigation.breadcrumbs.any? %>
     <%# Rendering parent-based breadcrumbs because no browse, no related links, no live taxons %>

data/lib/govuk_publishing_components/version.rb

@@ -1,3 +1,3 @@
 module GovukPublishingComponents
-  VERSION = '21.22.1'.freeze
+  VERSION = '21.22.2'.freeze
 end

data/node_modules/axe-core/CHANGELOG.md

@@ -2,42 +2,88 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-### [3.4.2](https://github.com/dequelabs/axe-core/compare/v3.4.0...v3.4.2) (2020-02-04)
+### [3.5.1](https://github.com/dequelabs/axe-core/compare/v3.5.0...v3.5.1) (2020-02-12)
+
+### Bug Fixes
+
+- **color-contrast:** parse font-weight value as number ([#2031](https://github.com/dequelabs/axe-core/issues/2031)) ([#2040](https://github.com/dequelabs/axe-core/issues/2040)) ([0bb2166](https://github.com/dequelabs/axe-core/commit/0bb21669f75b3adc0e3345c85680d437c57f94d8))
+- **color-contrast:** properly pass options to check ([#2033](https://github.com/dequelabs/axe-core/issues/2033)) ([26b99c0](https://github.com/dequelabs/axe-core/commit/26b99c0a511bd6fffaaca7535d732f26b39ef46e))
+- **commons:** avoid unicode regex encoding in axe.min.js ([#2024](https://github.com/dequelabs/axe-core/issues/2024)) ([ae90dc4](https://github.com/dequelabs/axe-core/commit/ae90dc47521f6047f71befcb3551686cf857208d))
+- **sri-history:** correct SRI for various versions ([#2041](https://github.com/dequelabs/axe-core/issues/2041)) ([940c017](https://github.com/dequelabs/axe-core/commit/940c01708cede33e796972ce810a815ddf492ba4))
+
+## [3.5.0](https://github.com/dequelabs/axe-core/compare/v3.4.0...v3.5.0) (2020-02-04)
 
 ### Features
 
 - **aria-dpub-role-fallback:** depreacte aria-dpub-role-fallback and move into aria-allowed-role ([#1899](https://github.com/dequelabs/axe-core/issues/1899)) ([8e25c20](https://github.com/dequelabs/axe-core/commit/8e25c20a479b03820117c6cd349b51ce7f2e94ee))
 - **aria-label:** deprecate Element arg; use virtualNode ([#1922](https://github.com/dequelabs/axe-core/issues/1922)) ([d14981c](https://github.com/dequelabs/axe-core/commit/d14981c1f67ba849f9519ee826ac646d281649c7))
 - **audit:** allow runOnly option to accept an array of rules ([#1889](https://github.com/dequelabs/axe-core/issues/1889)) ([38d6a3f](https://github.com/dequelabs/axe-core/commit/38d6a3fb26c66215cca0f3df8da268b34bcb6be5))
+- **color-contrast:** greatly improve performance for very large sites ([#1943](https://github.com/dequelabs/axe-core/issues/1943)) ([9ea0065](https://github.com/dequelabs/axe-core/commit/9ea006534a423b2b7df1826a40e8214c6bb1fc48))
+- **core:** add preload configuration option for media files ([#1958](https://github.com/dequelabs/axe-core/issues/1958)) ([8a62649](https://github.com/dequelabs/axe-core/commit/8a626498dc9694a992e76855781e2ad1cbd4fe9b))
+- **core/reporters/v1:** Add failureSummary to incomplete results ([#1972](https://github.com/dequelabs/axe-core/issues/1972)) ([c88883d](https://github.com/dequelabs/axe-core/commit/c88883d00b6578593b83f3134ebf897d22a3ba61))
 - **get-element-stack:** performant api to replace document.elementsFromPoint ([#1842](https://github.com/dequelabs/axe-core/issues/1842)) ([9ae07fb](https://github.com/dequelabs/axe-core/commit/9ae07fbda36afd18a42a96d6755055006f309a4c))
+- **i18n:** add Danish (da-DK) translation ([#1876](https://github.com/dequelabs/axe-core/issues/1876)) ([fb6fc41](https://github.com/dequelabs/axe-core/commit/fb6fc414246bdaf1590d367352e4bea033822639))
+- **landmark-no-duplicate-\*:** add rule landmark-no-duplicate-main, don't use html as element source for all duplicate rules ([#1949](https://github.com/dequelabs/axe-core/issues/1949)) ([5ec7894](https://github.com/dequelabs/axe-core/commit/5ec7894394f8348761f5fe48ad0d09b31a27d2b2))
 - **layout-table:** deprecate layout-table rule and checks ([#1885](https://github.com/dequelabs/axe-core/issues/1885)) ([d22cb30](https://github.com/dequelabs/axe-core/commit/d22cb30ad29f5d1aec089eea3544ff88f3b4f8ab))
+- **matches:** use VirtualNode and deprecate HTMLElement ([#1988](https://github.com/dequelabs/axe-core/issues/1988)) ([2600a06](https://github.com/dequelabs/axe-core/commit/2600a062d65f0c079b30d6a9f2aa3b6faeea6872))
+- **rule:** add color-contrast check for unicode characters, behind flags. ([#1969](https://github.com/dequelabs/axe-core/issues/1969)) ([0cd4037](https://github.com/dequelabs/axe-core/commit/0cd40373ff9a080ffcb128ce66f9eaf80f0d19b4)), closes [#1906](https://github.com/dequelabs/axe-core/issues/1906)
+- **rule:** identical-links-same-purpose ([#1649](https://github.com/dequelabs/axe-core/issues/1649)) ([9c73f62](https://github.com/dequelabs/axe-core/commit/9c73f62fea2be68cb555c36fc32c79f7ce2697dd))
+- **rule:** no-autoplay-audio ([#1946](https://github.com/dequelabs/axe-core/issues/1946)) ([b2373cb](https://github.com/dequelabs/axe-core/commit/b2373cb9ce73a15e79aec86af7edff62c9a4e2b3))
+- **svg-img-alt:** rule for when svg needs a title ([#1953](https://github.com/dequelabs/axe-core/issues/1953)) ([9491e09](https://github.com/dequelabs/axe-core/commit/9491e094fe82c4dba45eb253ed18bf0a0165197c))
 - deprecate the use doT.js for messages ([#1938](https://github.com/dequelabs/axe-core/issues/1938)) ([a2ddba3](https://github.com/dequelabs/axe-core/commit/a2ddba305003db0540c093f4ad9015c8854cd98d))
 
 ### Bug Fixes
 
-- **td-has-headers:** greatly improve performance of td-has-headers rule ([#1887](https://github.com/dequelabs/axe-core/issues/1887)) ([a550309](https://github.com/dequelabs/axe-core/commit/a550309255b025cb1e63710af2142f2c02d79657))
+- **color-contrast:** properly pass options to check ([#2033](https://github.com/dequelabs/axe-core/issues/2033)) ([26b99c0](https://github.com/dequelabs/axe-core/commit/26b99c0a511bd6fffaaca7535d732f26b39ef46e))
+- **commons:** avoid unicode regex encoding in axe.min.js ([#2024](https://github.com/dequelabs/axe-core/issues/2024)) ([ae90dc4](https://github.com/dequelabs/axe-core/commit/ae90dc47521f6047f71befcb3551686cf857208d))
 - add tags with dots for wcag sc ([#1849](https://github.com/dequelabs/axe-core/issues/1849)) ([2f1ab36](https://github.com/dequelabs/axe-core/commit/2f1ab36354add65fe77be3e2831278ce37c3bbab))
+- compute orientation lock from various transformation func… ([#1937](https://github.com/dequelabs/axe-core/issues/1937)) ([c987de0](https://github.com/dequelabs/axe-core/commit/c987de0ce7cfcde5a280a9d6c643879093df1bcd))
+- ignores axe.ping responses that do not contain axe=true ([26cb1fb](https://github.com/dequelabs/axe-core/commit/26cb1fbdd7127c421bb7ca60e07d72385c6e2ea1))
+- input[role=button][value='correct'] should pass ([#1897](https://github.com/dequelabs/axe-core/issues/1897)) ([4635fef](https://github.com/dequelabs/axe-core/commit/4635fef8bafd1c1cf916962693d0deee082266cf))
+- remove heading from list of widget roles ([#1882](https://github.com/dequelabs/axe-core/issues/1882)) ([a8cbf71](https://github.com/dequelabs/axe-core/commit/a8cbf717ef3aa8b0bf09ddcb17f3a95fd2d1a64a))
+- **link-name:** test role=link when there is no href ([#1921](https://github.com/dequelabs/axe-core/issues/1921)) ([6db28bc](https://github.com/dequelabs/axe-core/commit/6db28bc455b1c8937f44346aa232eacc4a1c3457))
+- remove isNaN check ([#2010](https://github.com/dequelabs/axe-core/issues/2010)) ([5359b3f](https://github.com/dequelabs/axe-core/commit/5359b3f06ac051963ee61fcef417bcc20bdec55b))
+- **aria-allowed-attr:** allow aria-details ([#1956](https://github.com/dequelabs/axe-core/issues/1956)) ([79e1c58](https://github.com/dequelabs/axe-core/commit/79e1c58cad4fdbd1409a0b545981c12f13252432))
 - **aria-allowed-role:** allow role combobox on input tel, search, url, and email ([#1850](https://github.com/dequelabs/axe-core/issues/1850)) ([ba75961](https://github.com/dequelabs/axe-core/commit/ba759618ed8068f4eb74b6cd00f002322b20eca5))
+- **aria-hidden-focus:** mark as needs review if a modal is open ([#1995](https://github.com/dequelabs/axe-core/issues/1995)) ([28a3553](https://github.com/dequelabs/axe-core/commit/28a35531b97b987e2fd1ad0beb25fbda3822fbd5))
+- **aria-required-children:** allow comboboxes with more popup roles ([#1950](https://github.com/dequelabs/axe-core/issues/1950)) ([35a24c0](https://github.com/dequelabs/axe-core/commit/35a24c034520e3c6d95514e3b9d9f2ab6ca10e06))
+- **aria-roles:** report error for fallback roles ([#1970](https://github.com/dequelabs/axe-core/issues/1970)) ([a1b7e08](https://github.com/dequelabs/axe-core/commit/a1b7e08f1f8e1c1caff228469cd891d0458680de))
+- **aria-valid-attr-value:** mark as needs review for aria-current with invalid value ([#1998](https://github.com/dequelabs/axe-core/issues/1998)) ([39b8eae](https://github.com/dequelabs/axe-core/commit/39b8eae9d3352be4f77bef41abcb8eab268a6809))
 - **axe.d.ts:** RunOnly.values should not accept a RunOnlyOption ([#1888](https://github.com/dequelabs/axe-core/issues/1888)) ([b68aa19](https://github.com/dequelabs/axe-core/commit/b68aa19500ffb57fdf370707d7614384ac239ad6))
 - **build:** add lang query parameter to helpUrl when builing with a locale ([#1909](https://github.com/dequelabs/axe-core/issues/1909)) ([8c5f9ef](https://github.com/dequelabs/axe-core/commit/8c5f9efd6449f82e410eb7c6a68cfb5304fc66ae))
-- **color-contrast:** support IE extension context ([#2008](https://github.com/dequelabs/axe-core/issues/2008)) ([64f6910](https://github.com/dequelabs/axe-core/commit/64f6910e8051cd5daed8a7094dfd383ba1090273))
+- **color-contrast:** improve speed and accuracy of code blocks with syntax highlighting ([#2003](https://github.com/dequelabs/axe-core/issues/2003)) ([1b6ab42](https://github.com/dequelabs/axe-core/commit/1b6ab42f72b1ea0d2ed223c6fd63b9b1e54cfa9b))
+- **color-contrast:** mark as needs review for text that contains only non-BMP characters ([#2005](https://github.com/dequelabs/axe-core/issues/2005)) ([e559be0](https://github.com/dequelabs/axe-core/commit/e559be041e90951c734de4e7ad70d7299f590cf6))
+- **color-contrast:** support IE extension context ([#2008](https://github.com/dequelabs/axe-core/issues/2008)) ([62e31ea](https://github.com/dequelabs/axe-core/commit/62e31ea5034871f572f8bb47dba2596fb1b13063))
 - **color-contrast:** take into account parent opacity for foreground color ([#1902](https://github.com/dequelabs/axe-core/issues/1902)) ([8719700](https://github.com/dequelabs/axe-core/commit/87197005d046cc8c845764ff9107683938864c65))
+- **getElementStack:** do not add hidden elements to the stack ([#1991](https://github.com/dequelabs/axe-core/issues/1991)) ([759d88d](https://github.com/dequelabs/axe-core/commit/759d88d08af059755d908794038770cc57448252))
 - **is-focusable:** use tabindex attribute instead of property ([#1912](https://github.com/dequelabs/axe-core/issues/1912)) ([042a148](https://github.com/dequelabs/axe-core/commit/042a1487df76489483330274933d06fd27b842e0))
 - **is-icon-ligature:** ignore whitespace characters ([#1908](https://github.com/dequelabs/axe-core/issues/1908)) ([7d2b2a6](https://github.com/dequelabs/axe-core/commit/7d2b2a6fca992e27bab36ed8ab64b7ba3385d7e5))
 - **is-ligature-icon:** rename canvas to canvasContext ([#1880](https://github.com/dequelabs/axe-core/issues/1880)) ([de9885d](https://github.com/dequelabs/axe-core/commit/de9885d5708d6928fa2eb2816351879307a31a5b))
-- **link-name:** test role=link when there is no href ([#1921](https://github.com/dequelabs/axe-core/issues/1921)) ([6db28bc](https://github.com/dequelabs/axe-core/commit/6db28bc455b1c8937f44346aa232eacc4a1c3457))
+- **isFocusable:** return true for summary element and false for details element with summary child ([#1957](https://github.com/dequelabs/axe-core/issues/1957)) ([34ec2d7](https://github.com/dequelabs/axe-core/commit/34ec2d7326786347f8704786e886fc8d13dd3f9b))
 - **listitem:** clarify that li elements must be contained in a list or role=list ([#1894](https://github.com/dequelabs/axe-core/issues/1894)) ([6d8cfee](https://github.com/dequelabs/axe-core/commit/6d8cfee91f0f0b5dcacba7ffb0b3d6505862e6b7))
 - **locales:** fix incompeteMessageFallback to be a string rather than an object ([#1853](https://github.com/dequelabs/axe-core/issues/1853)) ([88677a9](https://github.com/dequelabs/axe-core/commit/88677a93d0ffe32d7305984314a37e623fb51153))
+- **meta-viewport:** mark as a best-practice rule instead of wcag failure ([#1960](https://github.com/dequelabs/axe-core/issues/1960)) ([766f962](https://github.com/dequelabs/axe-core/commit/766f96210d05d35cab0139839db4f009b1139ce1))
+- **only-listitem:** add message about invalid role on li elements ([#1954](https://github.com/dequelabs/axe-core/issues/1954)) ([c3049ab](https://github.com/dequelabs/axe-core/commit/c3049abaccff72412ec3d58fab9b386fe8a2ae5a))
+- **page-has-main:** do not find hidden elements ([#2001](https://github.com/dequelabs/axe-core/issues/2001)) ([6429e60](https://github.com/dequelabs/axe-core/commit/6429e608f082db76b4cc445679b61a6e0ab8f034))
+- **page-no-duplicate-main:** do not fail for duplicate hidden elements ([#2000](https://github.com/dequelabs/axe-core/issues/2000)) ([414dfb1](https://github.com/dequelabs/axe-core/commit/414dfb1c9a4ade645ce60e8918e8143fe58b3eb6))
+- **preload:** reject promise `axe.utils.preload` when XHR fails ([#2009](https://github.com/dequelabs/axe-core/issues/2009)) ([b406b1f](https://github.com/dequelabs/axe-core/commit/b406b1fd09d72f9193d5b4011fa6f24bd33e3576))
+- **region:** allow content in roles with implicit aria-live ([#2002](https://github.com/dequelabs/axe-core/issues/2002)) ([a8d829e](https://github.com/dequelabs/axe-core/commit/a8d829e081dabb62a5247e8956adbf7a2ef000a2))
+- **region:** return outermost regionless node instead of html ([#1980](https://github.com/dequelabs/axe-core/issues/1980)) ([8d77be2](https://github.com/dequelabs/axe-core/commit/8d77be206e11537e8b509d593707c98143181bfa))
+- **region-rule:** allow live regions with explicit roles ([#1999](https://github.com/dequelabs/axe-core/issues/1999)) ([b49bd95](https://github.com/dequelabs/axe-core/commit/b49bd9547b7d8ac392ebf958356f90aca7e48a38))
 - **run:** throw error if axe.run is called after a run has started but not completed ([#1914](https://github.com/dequelabs/axe-core/issues/1914)) ([3252a02](https://github.com/dequelabs/axe-core/commit/3252a020ffd372e9583d39c989affd3d3b22957b))
 - **server-side-image-map:** return as needs review rather than failure ([#1898](https://github.com/dequelabs/axe-core/issues/1898)) ([d544856](https://github.com/dequelabs/axe-core/commit/d5448567b23de8289443c9c314b34b3140f68c30))
 - **tabindex:** don't error when tabindex property is overridden ([#1910](https://github.com/dequelabs/axe-core/issues/1910)) ([6b82a4c](https://github.com/dequelabs/axe-core/commit/6b82a4c513a1d5be78dcc54ad90a90768613b918))
-- **typings:** add proper return value to getRule ([#1900](https://github.com/dequelabs/axe-core/issues/1900)) ([4d907f8](https://github.com/dequelabs/axe-core/commit/4d907f86b0152122f92cceae0b242e09aff0f49a))
-- **unicode:** stop parsing escaped unicode strings ([#1997](https://github.com/dequelabs/axe-core/issues/1997)) ([5b49264](https://github.com/dequelabs/axe-core/commit/5b49264e2a2b5e84c839825bf88e3a0745731153))
-- compute orientation lock from various transformation func… ([#1937](https://github.com/dequelabs/axe-core/issues/1937)) ([c987de0](https://github.com/dequelabs/axe-core/commit/c987de0ce7cfcde5a280a9d6c643879093df1bcd))
-- ignores axe.ping responses that do not contain axe=true ([26cb1fb](https://github.com/dequelabs/axe-core/commit/26cb1fbdd7127c421bb7ca60e07d72385c6e2ea1))
-- input[role=button][value='correct'] should pass ([#1897](https://github.com/dequelabs/axe-core/issues/1897)) ([4635fef](https://github.com/dequelabs/axe-core/commit/4635fef8bafd1c1cf916962693d0deee082266cf))
-- remove heading from list of widget roles ([#1882](https://github.com/dequelabs/axe-core/issues/1882)) ([a8cbf71](https://github.com/dequelabs/axe-core/commit/a8cbf717ef3aa8b0bf09ddcb17f3a95fd2d1a64a))
+- **td-has-headers:** greatly improve performance of td-has-headers rule ([#1887](https://github.com/dequelabs/axe-core/issues/1887)) ([a550309](https://github.com/dequelabs/axe-core/commit/a550309255b025cb1e63710af2142f2c02d79657))
 - removes flaky test in axe Pro api check ([b2bdcd1](https://github.com/dequelabs/axe-core/commit/b2bdcd13e7623d3111f7035f2e951ff6b330132c))
+- **typings:** add proper return value to getRule ([#1900](https://github.com/dequelabs/axe-core/issues/1900)) ([4d907f8](https://github.com/dequelabs/axe-core/commit/4d907f86b0152122f92cceae0b242e09aff0f49a))
+- **unicode:** stop parsing escaped unicode strings ([#1997](https://github.com/dequelabs/axe-core/issues/1997)) ([7447d03](https://github.com/dequelabs/axe-core/commit/7447d03bcfd118897d8114fded1ea8a42f3da08f))
+
+## [3.4.2](https://github.com/dequelabs/axe-core/compare/v3.4.1...v3.4.2) (2020-02-04)
+
+### Bug Fixes
+
+- **color-contrast:** support IE extension context ([#2008](https://github.com/dequelabs/axe-core/issues/2008)) ([cd651a0](https://github.com/dequelabs/axe-core/commit/cd651a0713fa2f4b307cc7fc2be033f8636b40d2))
+- **unicode:** stop parsing escaped unicode strings ([#1997](https://github.com/dequelabs/axe-core/issues/1997)) ([523a31c](https://github.com/dequelabs/axe-core/commit/523a31c19fefd330e0b4f4c45f51d400c6f66164))
 
 ### [3.4.1](https://github.com/dequelabs/axe-core/compare/v3.4.0...v3.4.1) (2019-12-11)
 
@@ -103,6 +149,13 @@ All notable changes to this project will be documented in this file. See [standa
 - **runVirtualNode:** Allow serialised nodes [experimental](<[512d51b](https://github.com/dequelabs/axe-core/commit/512d51b)>)
 - **video-description:** deprecate video-description rule ([#1737](https://github.com/dequelabs/axe-core/issues/1737)) ([e91c25f](https://github.com/dequelabs/axe-core/commit/e91c25f))
 
+## [3.3.3](https://github.com/dequelabs/axe-core/compare/v3.3.2...v3.3.3) (2020-02-04)
+
+### Bug Fixes
+
+- **color-contrast:** support IE extension context ([#2008](https://github.com/dequelabs/axe-core/issues/2008)) ([cd651a0](https://github.com/dequelabs/axe-core/commit/cd651a0713fa2f4b307cc7fc2be033f8636b40d2))
+- **unicode:** stop parsing escaped unicode strings ([#1997](https://github.com/dequelabs/axe-core/issues/1997)) ([523a31c](https://github.com/dequelabs/axe-core/commit/523a31c19fefd330e0b4f4c45f51d400c6f66164))
+
 ### [3.3.2](https://github.com/dequelabs/axe-core/compare/v3.3.1...v3.3.2) (2019-08-12)
 
 ### Bug Fixes
@@ -203,6 +256,13 @@ All notable changes to this project will be documented in this file. See [standa
 - only run IE11 tests in appveyor ([#1571](https://github.com/dequelabs/axe-core/issues/1571)) ([35261ef](https://github.com/dequelabs/axe-core/commit/35261ef))
 - watch integration html and json files ([#1598](https://github.com/dequelabs/axe-core/issues/1598)) ([3de0b05](https://github.com/dequelabs/axe-core/commit/3de0b05))
 
+## [3.2.3](https://github.com/dequelabs/axe-core/compare/v3.2.2...v3.2.3) (2020-02-04)
+
+### Bug Fixes
+
+- **color-contrast:** support IE extension context ([#2008](https://github.com/dequelabs/axe-core/issues/2008)) ([cd651a0](https://github.com/dequelabs/axe-core/commit/cd651a0713fa2f4b307cc7fc2be033f8636b40d2))
+- **unicode:** stop parsing escaped unicode strings ([#1997](https://github.com/dequelabs/axe-core/issues/1997)) ([523a31c](https://github.com/dequelabs/axe-core/commit/523a31c19fefd330e0b4f4c45f51d400c6f66164))
+
 ## [3.2.2](https://github.com/dequelabs/axe-core/compare/v3.2.0...v3.2.2) (2019-03-07)
 
 ### Bug Fixes

data/node_modules/axe-core/axe.js

@@ -1,4 +1,4 @@
-/*! axe v3.4.2
+/*! axe v3.5.1
  * Copyright (c) 2020 Deque Systems, Inc.
  *
  * Your use of this Source Code Form is subject to the terms of the Mozilla Public
@@ -27,7 +27,7 @@
     return _typeof(obj);
   }
   var axe = axe || {};
-  axe.version = '3.4.2';
+  axe.version = '3.5.1';
   if (typeof define === 'function' && define.amd) {
     define('axe-core', [], function() {
       'use strict';
@@ -9692,6 +9692,7 @@
     };
     return _setPrototypeOf(o, p);
   }
+  var isXHTMLGlobal;
   var VirtualNode = function(_axe$AbstractVirtualN) {
     _inherits(VirtualNode, _axe$AbstractVirtualN);
     function VirtualNode(node, parent, shadowId) {
@@ -9704,6 +9705,10 @@
       _this.parent = parent;
       _this._isHidden = null;
       _this._cache = {};
+      if (typeof isXHTMLGlobal === 'undefined') {
+        isXHTMLGlobal = axe.utils.isXHTML(node.ownerDocument);
+      }
+      _this._isXHTML = isXHTMLGlobal;
       if (axe._cache.get('nodeMap')) {
         axe._cache.get('nodeMap').set(node, _assertThisInitialized(_this));
       }
@@ -9740,12 +9745,13 @@
     }, {
       key: 'props',
       get: function get() {
-        var _this$actualNode = this.actualNode, nodeType = _this$actualNode.nodeType, nodeName = _this$actualNode.nodeName, id = _this$actualNode.id, type = _this$actualNode.type;
+        var _this$actualNode = this.actualNode, nodeType = _this$actualNode.nodeType, nodeName = _this$actualNode.nodeName, id = _this$actualNode.id, type = _this$actualNode.type, multiple = _this$actualNode.multiple;
         return {
           nodeType: nodeType,
-          nodeName: nodeName.toLowerCase(),
+          nodeName: this._isXHTML ? nodeName : nodeName.toLowerCase(),
           id: id,
-          type: type
+          type: type,
+          multiple: multiple
         };
       }
     }, {
@@ -9816,7 +9822,7 @@
       resultGroupMap: {},
       impact: Object.freeze([ 'minor', 'moderate', 'serious', 'critical' ]),
       preload: Object.freeze({
-        assets: [ 'cssom' ],
+        assets: [ 'cssom', 'media' ],
         timeout: 1e4
       })
     };
@@ -10648,11 +10654,13 @@
       options = {};
     }
     var out = helpers.processAggregate(results, options);
-    out.violations.forEach(function(result) {
-      return result.nodes.forEach(function(nodeResult) {
+    var addFailureSummaries = function addFailureSummaries(result) {
+      result.nodes.forEach(function(nodeResult) {
         nodeResult.failureSummary = helpers.failureSummary(nodeResult);
       });
-    });
+    };
+    out.incomplete.forEach(addFailureSummaries);
+    out.violations.forEach(addFailureSummaries);
     callback(_extends({}, helpers.getEnvironmentData(), {
       toolOptions: options,
       violations: out.violations,
@@ -11889,6 +11897,186 @@
     return doc.createElement('A').localName === 'A';
   };
   'use strict';
+  function matchesTag(vNode, exp) {
+    return vNode.props.nodeType === 1 && (exp.tag === '*' || vNode.props.nodeName === exp.tag);
+  }
+  function matchesClasses(vNode, exp) {
+    return !exp.classes || exp.classes.every(function(cl) {
+      return vNode.hasClass(cl.value);
+    });
+  }
+  function matchesAttributes(vNode, exp) {
+    return !exp.attributes || exp.attributes.every(function(att) {
+      var nodeAtt = vNode.attr(att.key);
+      return nodeAtt !== null && (!att.value || att.test(nodeAtt));
+    });
+  }
+  function matchesId(vNode, exp) {
+    return !exp.id || vNode.props.id === exp.id;
+  }
+  function matchesPseudos(target, exp) {
+    if (!exp.pseudos || exp.pseudos.every(function(pseudo) {
+      if (pseudo.name === 'not') {
+        return !axe.utils.matchesExpression(target, pseudo.expressions[0]);
+      }
+      throw new Error('the pseudo selector ' + pseudo.name + ' has not yet been implemented');
+    })) {
+      return true;
+    }
+    return false;
+  }
+  function matchExpression(vNode, expression) {
+    return matchesTag(vNode, expression) && matchesClasses(vNode, expression) && matchesAttributes(vNode, expression) && matchesId(vNode, expression) && matchesPseudos(vNode, expression);
+  }
+  var escapeRegExp = function() {
+    var from = /(?=[\-\[\]{}()*+?.\\\^$|,#\s])/g;
+    var to = '\\';
+    return function(string) {
+      return string.replace(from, to);
+    };
+  }();
+  var reUnescape = /\\/g;
+  function convertAttributes(atts) {
+    if (!atts) {
+      return;
+    }
+    return atts.map(function(att) {
+      var attributeKey = att.name.replace(reUnescape, '');
+      var attributeValue = (att.value || '').replace(reUnescape, '');
+      var test, regexp;
+      switch (att.operator) {
+       case '^=':
+        regexp = new RegExp('^' + escapeRegExp(attributeValue));
+        break;
+
+       case '$=':
+        regexp = new RegExp(escapeRegExp(attributeValue) + '$');
+        break;
+
+       case '~=':
+        regexp = new RegExp('(^|\\s)' + escapeRegExp(attributeValue) + '(\\s|$)');
+        break;
+
+       case '|=':
+        regexp = new RegExp('^' + escapeRegExp(attributeValue) + '(-|$)');
+        break;
+
+       case '=':
+        test = function test(value) {
+          return attributeValue === value;
+        };
+        break;
+
+       case '*=':
+        test = function test(value) {
+          return value && value.includes(attributeValue);
+        };
+        break;
+
+       case '!=':
+        test = function test(value) {
+          return attributeValue !== value;
+        };
+        break;
+
+       default:
+        test = function test(value) {
+          return !!value;
+        };
+      }
+      if (attributeValue === '' && /^[*$^]=$/.test(att.operator)) {
+        test = function test() {
+          return false;
+        };
+      }
+      if (!test) {
+        test = function test(value) {
+          return value && regexp.test(value);
+        };
+      }
+      return {
+        key: attributeKey,
+        value: attributeValue,
+        test: test
+      };
+    });
+  }
+  function convertClasses(classes) {
+    if (!classes) {
+      return;
+    }
+    return classes.map(function(className) {
+      className = className.replace(reUnescape, '');
+      return {
+        value: className,
+        regexp: new RegExp('(^|\\s)' + escapeRegExp(className) + '(\\s|$)')
+      };
+    });
+  }
+  function convertPseudos(pseudos) {
+    if (!pseudos) {
+      return;
+    }
+    return pseudos.map(function(p) {
+      var expressions;
+      if (p.name === 'not') {
+        expressions = p.value;
+        expressions = expressions.selectors ? expressions.selectors : [ expressions ];
+        expressions = convertExpressions(expressions);
+      }
+      return {
+        name: p.name,
+        expressions: expressions,
+        value: p.value
+      };
+    });
+  }
+  function convertExpressions(expressions) {
+    return expressions.map(function(exp) {
+      var newExp = [];
+      var rule = exp.rule;
+      while (rule) {
+        newExp.push({
+          tag: rule.tagName ? rule.tagName.toLowerCase() : '*',
+          combinator: rule.nestingOperator ? rule.nestingOperator : ' ',
+          id: rule.id,
+          attributes: convertAttributes(rule.attrs),
+          classes: convertClasses(rule.classNames),
+          pseudos: convertPseudos(rule.pseudos)
+        });
+        rule = rule.rule;
+      }
+      return newExp;
+    });
+  }
+  axe.utils.convertSelector = function convertSelector(selector) {
+    var expressions = axe.utils.cssParser.parse(selector);
+    expressions = expressions.selectors ? expressions.selectors : [ expressions ];
+    return convertExpressions(expressions);
+  };
+  axe.utils.matchesExpression = function matchesExpression(vNode, expressions, matchAnyParent) {
+    var exps = [].concat(expressions);
+    var expression = exps.pop();
+    var matches = matchExpression(vNode, expression);
+    while (!matches && matchAnyParent && vNode.parent) {
+      vNode = vNode.parent;
+      matches = matchExpression(vNode, expression);
+    }
+    if (exps.length) {
+      if ([ ' ', '>' ].includes(expression.combinator) === false) {
+        throw new Error('axe.utils.matchesExpression does not support the combinator: ' + expression.combinator);
+      }
+      matches = matches && axe.utils.matchesExpression(vNode.parent, exps, expression.combinator === ' ');
+    }
+    return matches;
+  };
+  axe.utils.matches = function matches(vNode, selector) {
+    var expressions = axe.utils.convertSelector(selector);
+    return expressions.some(function(expression) {
+      return axe.utils.matchesExpression(vNode, expression);
+    });
+  };
+  'use strict';
   axe._memoizedFns = [];
   axe.utils.memoize = function(fn) {
     var memoized = axe.imports.memoize(fn);
@@ -12482,6 +12670,39 @@
     });
   }
   'use strict';
+  axe.utils.preloadMedia = function preloadMedia(_ref) {
+    var _ref$treeRoot = _ref.treeRoot, treeRoot = _ref$treeRoot === void 0 ? axe._tree[0] : _ref$treeRoot;
+    var mediaVirtualNodes = axe.utils.querySelectorAllFilter(treeRoot, 'video, audio', function(_ref2) {
+      var actualNode = _ref2.actualNode;
+      if (actualNode.hasAttribute('src')) {
+        return !!actualNode.getAttribute('src');
+      }
+      var sourceWithSrc = Array.from(actualNode.getElementsByTagName('source')).filter(function(source) {
+        return !!source.getAttribute('src');
+      });
+      if (sourceWithSrc.length <= 0) {
+        return false;
+      }
+      return true;
+    });
+    return Promise.all(mediaVirtualNodes.map(function(_ref3) {
+      var actualNode = _ref3.actualNode;
+      return isMediaElementReady(actualNode);
+    }));
+  };
+  function isMediaElementReady(elm) {
+    return new Promise(function(resolve) {
+      if (elm.readyState > 0) {
+        resolve(elm);
+      }
+      function onMediaReady() {
+        elm.removeEventListener('loadedmetadata', onMediaReady);
+        resolve(elm);
+      }
+      elm.addEventListener('loadedmetadata', onMediaReady);
+    });
+  }
+  'use strict';
   function _extends() {
     _extends = Object.assign || function(target) {
       for (var i = 1; i < arguments.length; i++) {
@@ -12555,14 +12776,15 @@
     config.assets = axe.utils.uniqueArray(options.preload.assets.map(function(a) {
       return a.toLowerCase();
     }), []);
-    if (options.preload.timeout && typeof options.preload.timeout === 'number' && !Number.isNaN(options.preload.timeout)) {
+    if (options.preload.timeout && typeof options.preload.timeout === 'number' && !isNaN(options.preload.timeout)) {
       config.timeout = options.preload.timeout;
     }
     return config;
   };
   axe.utils.preload = function preload(options) {
     var preloadFunctionsMap = {
-      cssom: axe.utils.preloadCssom
+      cssom: axe.utils.preloadCssom,
+      media: axe.utils.preloadMedia
     };
     var shouldPreload = axe.utils.shouldPreload(options);
     if (!shouldPreload) {
@@ -12570,8 +12792,8 @@
     }
     return new Promise(function(resolve, reject) {
       var _axe$utils$getPreload = axe.utils.getPreloadConfig(options), assets = _axe$utils$getPreload.assets, timeout = _axe$utils$getPreload.timeout;
-      setTimeout(function() {
-        return reject('Preload assets timed out.');
+      var preloadTimeout = setTimeout(function() {
+        return reject(new Error('Preload assets timed out.'));
       }, timeout);
       Promise.all(assets.map(function(asset) {
         return preloadFunctionsMap[asset](options).then(function(results) {
@@ -12581,7 +12803,11 @@
         var preloadAssets = results.reduce(function(out, result) {
           return _extends({}, out, {}, result);
         }, {});
+        clearTimeout(preloadTimeout);
         resolve(preloadAssets);
+      })['catch'](function(err) {
+        clearTimeout(preloadTimeout);
+        reject(err);
       });
     });
   };
@@ -12667,195 +12893,44 @@
     }
   }
   function extender(checksData, shouldBeTrue) {
-    'use strict';
-    return function(check) {
-      var sourceData = checksData[check.id] || {};
-      var messages = sourceData.messages || {};
-      var data = Object.assign({}, sourceData);
-      delete data.messages;
-      if (check.result === undefined) {
-        if (_typeof(messages.incomplete) === 'object' && !Array.isArray(check.data)) {
-          data.message = getIncompleteReason(check.data, messages);
-        }
-        if (!data.message) {
-          data.message = messages.incomplete;
-        }
-      } else {
-        data.message = check.result === shouldBeTrue ? messages.pass : messages.fail;
-      }
-      if (typeof data.message !== 'function') {
-        data.message = axe.utils.processMessage(data.message, check.data);
-      }
-      axe.utils.extendMetaData(check, data);
-    };
-  }
-  axe.utils.publishMetaData = function(ruleResult) {
-    'use strict';
-    var checksData = axe._audit.data.checks || {};
-    var rulesData = axe._audit.data.rules || {};
-    var rule = axe.utils.findBy(axe._audit.rules, 'id', ruleResult.id) || {};
-    ruleResult.tags = axe.utils.clone(rule.tags || []);
-    var shouldBeTrue = extender(checksData, true);
-    var shouldBeFalse = extender(checksData, false);
-    ruleResult.nodes.forEach(function(detail) {
-      detail.any.forEach(shouldBeTrue);
-      detail.all.forEach(shouldBeTrue);
-      detail.none.forEach(shouldBeFalse);
-    });
-    axe.utils.extendMetaData(ruleResult, axe.utils.clone(rulesData[ruleResult.id] || {}));
-  };
-  'use strict';
-  var convertExpressions = function convertExpressions() {};
-  var matchExpressions = function matchExpressions() {};
-  function matchesTag(vNode, exp) {
-    return vNode.props.nodeType === 1 && (exp.tag === '*' || vNode.props.nodeName === exp.tag);
-  }
-  function matchesClasses(vNode, exp) {
-    return !exp.classes || exp.classes.every(function(cl) {
-      return vNode.hasClass(cl.value);
-    });
-  }
-  function matchesAttributes(vNode, exp) {
-    return !exp.attributes || exp.attributes.every(function(att) {
-      var nodeAtt = vNode.attr(att.key);
-      return nodeAtt !== null && (!att.value || att.test(nodeAtt));
-    });
-  }
-  function matchesId(vNode, exp) {
-    return !exp.id || vNode.props.id === exp.id;
-  }
-  function matchesPseudos(target, exp) {
-    if (!exp.pseudos || exp.pseudos.every(function(pseudo) {
-      if (pseudo.name === 'not') {
-        return !matchExpressions([ target ], pseudo.expressions, false).length;
-      }
-      throw new Error('the pseudo selector ' + pseudo.name + ' has not yet been implemented');
-    })) {
-      return true;
-    }
-    return false;
-  }
-  var escapeRegExp = function() {
-    var from = /(?=[\-\[\]{}()*+?.\\\^$|,#\s])/g;
-    var to = '\\';
-    return function(string) {
-      return string.replace(from, to);
-    };
-  }();
-  var reUnescape = /\\/g;
-  function convertAttributes(atts) {
-    if (!atts) {
-      return;
-    }
-    return atts.map(function(att) {
-      var attributeKey = att.name.replace(reUnescape, '');
-      var attributeValue = (att.value || '').replace(reUnescape, '');
-      var test, regexp;
-      switch (att.operator) {
-       case '^=':
-        regexp = new RegExp('^' + escapeRegExp(attributeValue));
-        break;
-
-       case '$=':
-        regexp = new RegExp(escapeRegExp(attributeValue) + '$');
-        break;
-
-       case '~=':
-        regexp = new RegExp('(^|\\s)' + escapeRegExp(attributeValue) + '(\\s|$)');
-        break;
-
-       case '|=':
-        regexp = new RegExp('^' + escapeRegExp(attributeValue) + '(-|$)');
-        break;
-
-       case '=':
-        test = function test(value) {
-          return attributeValue === value;
-        };
-        break;
-
-       case '*=':
-        test = function test(value) {
-          return value && value.includes(attributeValue);
-        };
-        break;
-
-       case '!=':
-        test = function test(value) {
-          return attributeValue !== value;
-        };
-        break;
-
-       default:
-        test = function test(value) {
-          return !!value;
-        };
-      }
-      if (attributeValue === '' && /^[*$^]=$/.test(att.operator)) {
-        test = function test() {
-          return false;
-        };
-      }
-      if (!test) {
-        test = function test(value) {
-          return value && regexp.test(value);
-        };
-      }
-      return {
-        key: attributeKey,
-        value: attributeValue,
-        test: test
-      };
-    });
-  }
-  function convertClasses(classes) {
-    if (!classes) {
-      return;
-    }
-    return classes.map(function(className) {
-      className = className.replace(reUnescape, '');
-      return {
-        value: className,
-        regexp: new RegExp('(^|\\s)' + escapeRegExp(className) + '(\\s|$)')
-      };
-    });
-  }
-  function convertPseudos(pseudos) {
-    if (!pseudos) {
-      return;
-    }
-    return pseudos.map(function(p) {
-      var expressions;
-      if (p.name === 'not') {
-        expressions = p.value;
-        expressions = expressions.selectors ? expressions.selectors : [ expressions ];
-        expressions = convertExpressions(expressions);
-      }
-      return {
-        name: p.name,
-        expressions: expressions,
-        value: p.value
-      };
-    });
-  }
-  convertExpressions = function convertExpressions(expressions) {
-    return expressions.map(function(exp) {
-      var newExp = [];
-      var rule = exp.rule;
-      while (rule) {
-        newExp.push({
-          tag: rule.tagName ? rule.tagName.toLowerCase() : '*',
-          combinator: rule.nestingOperator ? rule.nestingOperator : ' ',
-          id: rule.id,
-          attributes: convertAttributes(rule.attrs),
-          classes: convertClasses(rule.classNames),
-          pseudos: convertPseudos(rule.pseudos)
-        });
-        rule = rule.rule;
+    'use strict';
+    return function(check) {
+      var sourceData = checksData[check.id] || {};
+      var messages = sourceData.messages || {};
+      var data = Object.assign({}, sourceData);
+      delete data.messages;
+      if (check.result === undefined) {
+        if (_typeof(messages.incomplete) === 'object' && !Array.isArray(check.data)) {
+          data.message = getIncompleteReason(check.data, messages);
+        }
+        if (!data.message) {
+          data.message = messages.incomplete;
+        }
+      } else {
+        data.message = check.result === shouldBeTrue ? messages.pass : messages.fail;
       }
-      return newExp;
+      if (typeof data.message !== 'function') {
+        data.message = axe.utils.processMessage(data.message, check.data);
+      }
+      axe.utils.extendMetaData(check, data);
+    };
+  }
+  axe.utils.publishMetaData = function(ruleResult) {
+    'use strict';
+    var checksData = axe._audit.data.checks || {};
+    var rulesData = axe._audit.data.rules || {};
+    var rule = axe.utils.findBy(axe._audit.rules, 'id', ruleResult.id) || {};
+    ruleResult.tags = axe.utils.clone(rule.tags || []);
+    var shouldBeTrue = extender(checksData, true);
+    var shouldBeFalse = extender(checksData, false);
+    ruleResult.nodes.forEach(function(detail) {
+      detail.any.forEach(shouldBeTrue);
+      detail.all.forEach(shouldBeTrue);
+      detail.none.forEach(shouldBeFalse);
     });
+    axe.utils.extendMetaData(ruleResult, axe.utils.clone(rulesData[ruleResult.id] || {}));
   };
+  'use strict';
   function createLocalVariables(vNodes, anyLevel, thisLevel, parentShadowId) {
     var retVal = {
       vNodes: vNodes.slice(),
@@ -12866,10 +12941,7 @@
     retVal.vNodes.reverse();
     return retVal;
   }
-  function matchesSelector(vNode, exp) {
-    return matchesTag(vNode, exp[0]) && matchesClasses(vNode, exp[0]) && matchesAttributes(vNode, exp[0]) && matchesId(vNode, exp[0]) && matchesPseudos(vNode, exp[0]);
-  }
-  matchExpressions = function matchExpressions(domTree, expressions, recurse, filter) {
+  function matchExpressions(domTree, expressions, filter) {
     var stack = [];
     var vNodes = Array.isArray(domTree) ? domTree : [ domTree ];
     var currentLevel = createLocalVariables(vNodes, expressions, [], domTree[0].shadowId);
@@ -12882,7 +12954,7 @@
       var added = false;
       for (var i = 0; i < combined.length; i++) {
         var exp = combined[i];
-        if ((!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) && matchesSelector(vNode, exp)) {
+        if ((!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) && axe.utils.matchesExpression(vNode, exp[0])) {
           if (exp.length === 1) {
             if (!added && (!filter || filter(vNode))) {
               result.push(vNode);
@@ -12904,7 +12976,7 @@
           childAny.push(exp);
         }
       }
-      if (vNode.children && vNode.children.length && recurse) {
+      if (vNode.children && vNode.children.length) {
         stack.push(currentLevel);
         currentLevel = createLocalVariables(vNode.children, childAny, childOnly, vNode.shadowId);
       }
@@ -12913,16 +12985,14 @@
       }
     }
     return result;
-  };
+  }
   axe.utils.querySelectorAll = function(domTree, selector) {
     return axe.utils.querySelectorAllFilter(domTree, selector);
   };
   axe.utils.querySelectorAllFilter = function(domTree, selector, filter) {
     domTree = Array.isArray(domTree) ? domTree : [ domTree ];
-    var expressions = axe.utils.cssParser.parse(selector);
-    expressions = expressions.selectors ? expressions.selectors : [ expressions ];
-    expressions = convertExpressions(expressions);
-    return matchExpressions(domTree, expressions, true, filter);
+    var expressions = axe.utils.convertSelector(selector);
+    return matchExpressions(domTree, expressions, filter);
   };
   'use strict';
   function _typeof(obj) {
@@ -13493,6 +13563,20 @@
     return langs;
   };
   'use strict';
+  function _extends() {
+    _extends = Object.assign || function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
   function _toConsumableArray(arr) {
     return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
   }
@@ -13512,20 +13596,6 @@
       return arr2;
     }
   }
-  function _extends() {
-    _extends = Object.assign || function(target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
-      }
-      return target;
-    };
-    return _extends.apply(this, arguments);
-  }
   function _slicedToArray(arr, i) {
     return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
   }
@@ -13753,6 +13823,10 @@
           description: 'Ensure that HTML elements with both valid lang and xml:lang attributes agree on the base language of the page',
           help: 'HTML elements with lang and xml:lang must have the same base language'
         },
+        'identical-links-same-purpose': {
+          description: 'Ensure that links with the same accessible name serve a similar purpose',
+          help: 'Links with the same name have a similar purpose'
+        },
         'image-alt': {
           description: 'Ensures <img> elements have alternate text or a role of none or presentation',
           help: 'Images must have alternate text'
@@ -13805,8 +13879,12 @@
           description: 'Ensures the document has at most one contentinfo landmark',
           help: 'Document must not have more than one contentinfo landmark'
         },
+        'landmark-no-duplicate-main': {
+          description: 'Ensures the document has at most one main landmark',
+          help: 'Document must not have more than one main landmark'
+        },
         'landmark-one-main': {
-          description: 'Ensures the document has only one main landmark and each iframe in the page has at most one main landmark',
+          description: 'Ensures the document has a main landmark',
           help: 'Document must have one main landmark'
         },
         'landmark-unique': {
@@ -13849,6 +13927,10 @@
           description: 'Ensures <meta name="viewport"> does not disable text scaling and zooming',
           help: 'Zooming and scaling must not be disabled'
         },
+        'no-autoplay-audio': {
+          description: 'Ensures <video> or <audio> elements do not autoplay audio for more than 3 seconds without a control mechanism to stop or mute the audio',
+          help: '<video> or <audio> elements do not autoplay audio'
+        },
         'object-alt': {
           description: 'Ensures <object> elements have alternate text',
           help: '<object> elements must have alternate text'
@@ -13889,6 +13971,10 @@
           description: 'Ensure all skip links have a focusable target',
           help: 'The skip-link target should exist and be focusable'
         },
+        'svg-img-alt': {
+          description: 'Ensures svg elements with an img, graphics-document or graphics-symbol role have an accessible text',
+          help: 'svg elements with an img role have an alternative text'
+        },
         tabindex: {
           description: 'Ensures tabindex attribute values are not greater than 0',
           help: 'Elements should not have tabindex greater than zero'
@@ -14007,6 +14093,13 @@
             fail: 'aria-hidden=true should not be present on the document body'
           }
         },
+        'focusable-modal-open': {
+          impact: 'serious',
+          messages: {
+            pass: 'No focusable elements while a modal is open',
+            incomplete: 'Check that focusable elements are not tabbable in the current state'
+          }
+        },
         'focusable-disabled': {
           impact: 'serious',
           messages: {
@@ -14070,18 +14163,31 @@
             fail: 'Give the element a role that supports aria-roledescription'
           }
         },
+        fallbackrole: {
+          impact: 'serious',
+          messages: {
+            pass: 'Only one role value used',
+            fail: 'Use only one role value, since fallback roles are not supported in older browsers'
+          }
+        },
         invalidrole: {
           impact: 'critical',
           messages: {
             pass: 'ARIA role is valid',
-            fail: 'Role must be one of the valid ARIA roles'
+            fail: {
+              singular: 'Role must be one of the valid ARIA roles: ${data.values}',
+              plural: 'Roles must be one of the valid ARIA roles: ${data.values}'
+            }
           }
         },
         abstractrole: {
           impact: 'serious',
           messages: {
             pass: 'Abstract roles are not used',
-            fail: 'Abstract roles cannot be directly used'
+            fail: {
+              singular: 'Abstract role cannot be directly used: ${data.values}',
+              plural: 'Abstract roles cannot be directly used: ${data.values}'
+            }
           }
         },
         unsupportedrole: {
@@ -14107,8 +14213,8 @@
               plural: 'Invalid ARIA attribute values: ${data.values}'
             },
             incomplete: {
-              singular: 'ARIA attribute element ID does not exist on the page: ${data.values}',
-              plural: 'ARIA attributes element ID does not exist on the page: ${data.values}'
+              noId: 'ARIA attribute element ID does not exist on the page: ${data.needsReview}',
+              ariaCurrent: 'ARIA attribute value is invalid and will be treated as "aria-current=true": ${data.needsReview}'
             }
           }
         },
@@ -14253,7 +14359,8 @@
               elmPartiallyObscuring: 'Element\'s background color could not be determined because it partially overlaps other elements',
               outsideViewport: 'Element\'s background color could not be determined because it\'s outside the viewport',
               equalRatio: 'Element has a 1:1 contrast ratio with the background',
-              shortTextContent: 'Element content is too short to determine if it is actual text content'
+              shortTextContent: 'Element content is too short to determine if it is actual text content',
+              nonBmp: 'Element content contains only non-text characters'
             }
           }
         },
@@ -14386,6 +14493,13 @@
             fail: 'Lang and xml:lang attributes do not have the same base language'
           }
         },
+        'identical-links-same-purpose': {
+          impact: 'minor',
+          messages: {
+            pass: 'There are no other links with the same name, that go to a different URL',
+            incomplete: 'Check that links have the same purpose, or are intentionally ambiguous.'
+          }
+        },
         'has-alt': {
           impact: 'critical',
           messages: {
@@ -14487,18 +14601,18 @@
             fail: 'Document has more than one contentinfo landmark'
           }
         },
-        'page-has-main': {
+        'page-no-duplicate-main': {
           impact: 'moderate',
           messages: {
-            pass: 'Document has at least one main landmark',
-            fail: 'Document does not have a main landmark'
+            pass: 'Document does not have more than one main landmark',
+            fail: 'Document has more than one main landmark'
           }
         },
-        'page-no-duplicate-main': {
+        'page-has-main': {
           impact: 'moderate',
           messages: {
-            pass: 'Document does not have more than one main landmark',
-            fail: 'Document has more than one main landmark'
+            pass: 'Document has at least one main landmark',
+            fail: 'Document does not have a main landmark'
           }
         },
         'landmark-is-unique': {
@@ -14555,7 +14669,10 @@
           impact: 'serious',
           messages: {
             pass: 'List element only has direct children that are allowed inside <li> elements',
-            fail: 'List element has direct children that are not allowed inside <li> elements'
+            fail: {
+              default: 'List element has direct children that are not allowed inside <li> elements',
+              roleNotValid: 'List element has direct children with a role that is not allowed: ${data.roles}'
+            }
           }
         },
         listitem: {
@@ -14589,6 +14706,14 @@
             fail: '${data} on <meta> tag disables zooming on mobile devices'
           }
         },
+        'no-autoplay-audio': {
+          impact: 'moderate',
+          messages: {
+            pass: '<video> or <audio> does not output audio for more than allowed duration or has controls mechanism',
+            fail: '<video> or <audio> outputs audio for more than allowed duration and does not have a controls mechanism',
+            incomplete: 'Check that the <video> or <audio> does not output audio for more than allowed duration or provides a controls mechanism'
+          }
+        },
         'p-as-heading': {
           impact: 'serious',
           messages: {
@@ -14653,6 +14778,13 @@
             fail: 'No skip link target'
           }
         },
+        'svg-non-empty-title': {
+          impact: 'serious',
+          messages: {
+            pass: 'element has a child that is a title',
+            fail: 'element has no child that is a title'
+          }
+        },
         tabindex: {
           impact: 'serious',
           messages: {
@@ -14829,7 +14961,7 @@
       },
       excludeHidden: false,
       tags: [ 'cat.name-role-value', 'wcag2a', 'wcag412', 'wcag131' ],
-      all: [ 'focusable-disabled', 'focusable-not-tabbable' ],
+      all: [ 'focusable-modal-open', 'focusable-disabled', 'focusable-not-tabbable' ],
       any: [],
       none: []
     }, {
@@ -14906,7 +15038,7 @@
       tags: [ 'cat.aria', 'wcag2a', 'wcag412' ],
       all: [],
       any: [],
-      none: [ 'invalidrole', 'abstractrole', 'unsupportedrole' ]
+      none: [ 'fallbackrole', 'invalidrole', 'abstractrole', 'unsupportedrole' ]
     }, {
       id: 'aria-toggle-field-name',
       selector: '[role="checkbox"], [role="menuitemcheckbox"], [role="menuitemradio"], [role="radio"], [role="switch"]',
@@ -15122,7 +15254,7 @@
         var visibleText = axe.commons.text.visibleVirtual(virtualNode, false, true);
         if (visibleText === '' || axe.commons.text.removeUnicode(visibleText, {
           emoji: true,
-          nonBmp: true,
+          nonBmp: false,
           punctuations: true
         }) === '') {
           return false;
@@ -15148,12 +15280,16 @@
         return false;
       },
       excludeHidden: false,
-      options: {
-        noScroll: false
-      },
       tags: [ 'cat.color', 'wcag2aa', 'wcag143' ],
       all: [],
-      any: [ 'color-contrast' ],
+      any: [ {
+        options: {
+          noScroll: false,
+          ignoreUnicode: true,
+          ignoreLength: false
+        },
+        id: 'color-contrast'
+      } ],
       none: []
     }, {
       id: 'css-orientation-lock',
@@ -15375,6 +15511,26 @@
       all: [ 'xml-lang-mismatch' ],
       any: [],
       none: []
+    }, {
+      id: 'identical-links-same-purpose',
+      selector: 'a[href], area[href], [role="link"]',
+      excludeHidden: false,
+      matches: function matches(node, virtualNode, context) {
+        var _axe$commons4 = axe.commons, aria = _axe$commons4.aria, text = _axe$commons4.text;
+        var hasAccName = !!text.accessibleTextVirtual(virtualNode);
+        if (!hasAccName) {
+          return false;
+        }
+        var role = aria.getRole(node);
+        if (role && role !== 'link') {
+          return false;
+        }
+        return true;
+      },
+      tags: [ 'wcag2aaa', 'wcag249', 'best-practice' ],
+      all: [ 'identical-links-same-purpose' ],
+      any: [],
+      none: []
     }, {
       id: 'image-alt',
       selector: 'img',
@@ -15406,7 +15562,7 @@
     }, {
       id: 'label-content-name-mismatch',
       matches: function matches(node, virtualNode, context) {
-        var _axe$commons4 = axe.commons, aria = _axe$commons4.aria, text = _axe$commons4.text;
+        var _axe$commons5 = axe.commons, aria = _axe$commons5.aria, text = _axe$commons5.text;
         var role = aria.getRole(node);
         if (!role) {
           return false;
@@ -15503,7 +15659,7 @@
       none: []
     }, {
       id: 'landmark-no-duplicate-banner',
-      selector: 'html',
+      selector: 'header:not([role]), [role=banner]',
       tags: [ 'cat.semantics', 'best-practice' ],
       all: [],
       any: [ {
@@ -15516,7 +15672,7 @@
       none: []
     }, {
       id: 'landmark-no-duplicate-contentinfo',
-      selector: 'html',
+      selector: 'footer:not([role]), [role=contentinfo]',
       tags: [ 'cat.semantics', 'best-practice' ],
       all: [],
       any: [ {
@@ -15527,6 +15683,18 @@
         id: 'page-no-duplicate-contentinfo'
       } ],
       none: []
+    }, {
+      id: 'landmark-no-duplicate-main',
+      selector: 'main:not([role]), [role=main]',
+      tags: [ 'cat.semantics', 'best-practice' ],
+      all: [],
+      any: [ {
+        options: {
+          selector: 'main:not([role]), [role=\'main\']'
+        },
+        id: 'page-no-duplicate-main'
+      } ],
+      none: []
     }, {
       id: 'landmark-one-main',
       selector: 'html',
@@ -15536,11 +15704,6 @@
           selector: 'main:not([role]), [role=\'main\']'
         },
         id: 'page-has-main'
-      }, {
-        options: {
-          selector: 'main:not([role]), [role=\'main\']'
-        },
-        id: 'page-no-duplicate-main'
       } ],
       any: [],
       none: []
@@ -15670,7 +15833,7 @@
       id: 'meta-viewport',
       selector: 'meta[name="viewport"]',
       excludeHidden: false,
-      tags: [ 'cat.sensory-and-visual-cues', 'wcag2aa', 'wcag144' ],
+      tags: [ 'cat.sensory-and-visual-cues', 'best-practice' ],
       all: [],
       any: [ {
         options: {
@@ -15679,6 +15842,29 @@
         id: 'meta-viewport'
       } ],
       none: []
+    }, {
+      id: 'no-autoplay-audio',
+      excludeHidden: false,
+      selector: 'audio[autoplay], video[autoplay]',
+      matches: function matches(node, virtualNode, context) {
+        if (!node.currentSrc) {
+          return false;
+        }
+        if (node.hasAttribute('paused') || node.hasAttribute('muted')) {
+          return false;
+        }
+        return true;
+      },
+      tags: [ 'wcag2a', 'wcag142', 'experimental' ],
+      preload: true,
+      all: [ {
+        options: {
+          allowedDuration: 3
+        },
+        id: 'no-autoplay-audio'
+      } ],
+      any: [],
+      none: []
     }, {
       id: 'object-alt',
       selector: 'object',
@@ -15743,15 +15929,17 @@
       none: []
     }, {
       id: 'region',
-      selector: 'html',
-      pageLevel: true,
+      selector: 'body *',
       tags: [ 'cat.keyboard', 'best-practice' ],
       all: [],
       any: [ 'region' ],
       none: []
     }, {
       id: 'role-img-alt',
-      selector: '[role=\'img\']:not(svg):not(img):not(area):not(input):not(object)',
+      selector: '[role=\'img\']:not(img):not(area):not(input):not(object)',
+      matches: function matches(node, virtualNode, context) {
+        return node.namespaceURI === 'http://www.w3.org/1999/xhtml';
+      },
       tags: [ 'cat.text-alternatives', 'wcag2a', 'wcag111', 'section508', 'section508.22.a' ],
       all: [],
       any: [ 'aria-label', 'aria-labelledby', 'non-empty-title' ],
@@ -15801,6 +15989,16 @@
       all: [],
       any: [ 'skip-link' ],
       none: []
+    }, {
+      id: 'svg-img-alt',
+      selector: '[role="img"], [role="graphics-symbol"], svg[role="graphics-document"]',
+      matches: function matches(node, virtualNode, context) {
+        return node.namespaceURI === 'http://www.w3.org/2000/svg';
+      },
+      tags: [ 'cat.text-alternatives', 'wcag2a', 'wcag111', 'section508', 'section508.22.a' ],
+      all: [],
+      any: [ 'svg-non-empty-title', 'aria-label', 'aria-labelledby', 'non-empty-title' ],
+      none: []
     }, {
       id: 'tabindex',
       selector: '[tabindex]',
@@ -15887,7 +16085,14 @@
     checks: [ {
       id: 'abstractrole',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        return axe.commons.aria.getRoleType(node.getAttribute('role')) === 'abstract';
+        var abstractRoles = axe.utils.tokenList(virtualNode.attr('role')).filter(function(role) {
+          return axe.commons.aria.getRoleType(role) === 'abstract';
+        });
+        if (abstractRoles.length > 0) {
+          this.data(abstractRoles);
+          return true;
+        }
+        return false;
       }
     }, {
       id: 'aria-allowed-attr',
@@ -15967,7 +16172,7 @@
     }, {
       id: 'aria-errormessage',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons5 = axe.commons, aria = _axe$commons5.aria, dom = _axe$commons5.dom;
+        var _axe$commons6 = axe.commons, aria = _axe$commons6.aria, dom = _axe$commons6.dom;
         options = Array.isArray(options) ? options : [];
         var attr = node.getAttribute('aria-errormessage');
         var hasAttr = node.hasAttribute('aria-errormessage');
@@ -15989,6 +16194,11 @@
         }
         return true;
       }
+    }, {
+      id: 'fallbackrole',
+      evaluate: function evaluate(node, options, virtualNode, context) {
+        return axe.utils.tokenList(virtualNode.attr('role')).length > 1;
+      }
     }, {
       id: 'has-widget-role',
       evaluate: function evaluate(node, options, virtualNode, context) {
@@ -16014,14 +16224,21 @@
     }, {
       id: 'invalidrole',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        return !axe.commons.aria.isValidRole(node.getAttribute('role'), {
-          allowAbstract: true
+        var invalidRoles = axe.utils.tokenList(virtualNode.attr('role')).filter(function(role) {
+          return !axe.commons.aria.isValidRole(role, {
+            allowAbstract: true
+          });
         });
+        if (invalidRoles.length > 0) {
+          this.data(invalidRoles);
+          return true;
+        }
+        return false;
       }
     }, {
       id: 'no-implicit-explicit-label',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons6 = axe.commons, aria = _axe$commons6.aria, text = _axe$commons6.text;
+        var _axe$commons7 = axe.commons, aria = _axe$commons7.aria, text = _axe$commons7.text;
         var role = aria.getRole(node, {
           noImplicit: true
         });
@@ -16084,7 +16301,8 @@
           if (node === null) {
             return false;
           }
-          var implicit = implicitNodes(role), selector = [ '[role="' + role + '"]' ];
+          var implicit = implicitNodes(role);
+          var selector = [ '[role="' + role + '"]' ];
           if (implicit) {
             selector = selector.concat(implicit.map(function(implicitSelector) {
               return implicitSelector + ':not([role])';
@@ -16094,21 +16312,21 @@
           return ariaOwned ? matchesSelector(node, selector) || !!axe.utils.querySelectorAll(virtualTree, selector)[0] : !!axe.utils.querySelectorAll(virtualTree, selector)[0];
         }
         function ariaOwns(nodes, role) {
-          var index, length;
-          for (index = 0, length = nodes.length; index < length; index++) {
-            if (nodes[index] === null) {
+          for (var index = 0; index < nodes.length; index++) {
+            var _node = nodes[index];
+            if (_node === null) {
               continue;
             }
-            var virtualTree = axe.utils.getNodeFromTree(nodes[index]);
-            if (owns(nodes[index], virtualTree, role, true)) {
+            var virtualTree = axe.utils.getNodeFromTree(_node);
+            if (owns(_node, virtualTree, role, true)) {
               return true;
             }
           }
           return false;
         }
         function missingRequiredChildren(node, childRoles, all, role) {
-          var index, length = childRoles.length, missing = [], ownedElements = idrefs(node, 'aria-owns');
-          for (index = 0; index < length; index++) {
+          var missing = [], ownedElements = idrefs(node, 'aria-owns');
+          for (var index = 0; index < childRoles.length; index++) {
             var childRole = childRoles[index];
             if (owns(node, virtualNode, childRole) || ariaOwns(ownedElements, childRole)) {
               if (!all) {
@@ -16126,10 +16344,19 @@
             if (textboxIndex >= 0 && node.nodeName.toUpperCase() === 'INPUT' && textTypeInputs.includes(node.type) || owns(node, virtualNode, 'searchbox') || ariaOwns(ownedElements, 'searchbox')) {
               missing.splice(textboxIndex, 1);
             }
-            var listboxIndex = missing.indexOf('listbox');
-            var expanded = node.getAttribute('aria-expanded');
-            if (listboxIndex >= 0 && (!expanded || expanded === 'false')) {
-              missing.splice(listboxIndex, 1);
+            var expandedChildRoles = [ 'listbox', 'tree', 'grid', 'dialog' ];
+            var expandedValue = node.getAttribute('aria-expanded');
+            var expanded = expandedValue && expandedValue !== 'false';
+            var popupRole = (node.getAttribute('aria-haspopup') || 'listbox').toLowerCase();
+            for (var _index = 0; _index < expandedChildRoles.length; _index++) {
+              var expandedChildRole = expandedChildRoles[_index];
+              if (expanded && expandedChildRole === popupRole) {
+                continue;
+              }
+              var missingIndex = missing.indexOf(expandedChildRole);
+              if (missingIndex >= 0) {
+                missing.splice(missingIndex, 1);
+              }
             }
           }
           if (missing.length) {
@@ -16154,7 +16381,7 @@
         var all = false;
         var childRoles = required.one;
         if (!childRoles) {
-          var all = true;
+          all = true;
           childRoles = required.all;
         }
         var missing = missingRequiredChildren(node, childRoles, all, role);
@@ -16272,7 +16499,8 @@
       id: 'aria-valid-attr-value',
       evaluate: function evaluate(node, options, virtualNode, context) {
         options = Array.isArray(options) ? options : [];
-        var needsReview = [];
+        var needsReview = '';
+        var messageKey = '';
         var invalid = [];
         var aria = /^aria-/;
         var attrs = axe.utils.getNodeAttributes(node);
@@ -16281,12 +16509,20 @@
           'aria-controls': function ariaControls() {
             return node.getAttribute('aria-expanded') !== 'false' && node.getAttribute('aria-selected') !== 'false';
           },
+          'aria-current': function ariaCurrent() {
+            if (!axe.commons.aria.validateAttrValue(node, 'aria-current')) {
+              needsReview = 'aria-current="'.concat(node.getAttribute('aria-current'), '"');
+              messageKey = 'ariaCurrent';
+            }
+            return;
+          },
           'aria-owns': function ariaOwns() {
             return node.getAttribute('aria-expanded') !== 'false';
           },
           'aria-describedby': function ariaDescribedby() {
             if (!axe.commons.aria.validateAttrValue(node, 'aria-describedby')) {
-              needsReview.push('aria-describedby="'.concat(node.getAttribute('aria-describedby'), '"'));
+              needsReview = 'aria-describedby="'.concat(node.getAttribute('aria-describedby'), '"');
+              messageKey = 'noId';
             }
             return;
           }
@@ -16298,8 +16534,11 @@
             invalid.push(''.concat(attrName, '="').concat(attr.nodeValue, '"'));
           }
         }
-        if (needsReview.length) {
-          this.data(needsReview);
+        if (needsReview) {
+          this.data({
+            messageKey: messageKey,
+            needsReview: needsReview
+          });
           return undefined;
         }
         if (invalid.length) {
@@ -16368,18 +16607,31 @@
     }, {
       id: 'color-contrast',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons7 = axe.commons, dom = _axe$commons7.dom, color = _axe$commons7.color, text = _axe$commons7.text;
+        var _axe$commons8 = axe.commons, dom = _axe$commons8.dom, color = _axe$commons8.color, text = _axe$commons8.text;
         if (!dom.isVisible(node, false)) {
           return true;
         }
+        var visibleText = text.visibleVirtual(virtualNode, false, true);
+        var ignoreUnicode = !!(options || {}).ignoreUnicode;
+        var textContainsOnlyUnicode = text.hasUnicode(visibleText, {
+          nonBmp: true
+        }) && text.sanitize(text.removeUnicode(visibleText, {
+          nonBmp: true
+        })) === '';
+        if (textContainsOnlyUnicode && ignoreUnicode) {
+          this.data({
+            messageKey: 'nonBmp'
+          });
+          return undefined;
+        }
         var noScroll = !!(options || {}).noScroll;
         var bgNodes = [];
         var bgColor = color.getBackgroundColor(node, bgNodes, noScroll);
         var fgColor = color.getForegroundColor(node, noScroll, bgColor);
         var nodeStyle = window.getComputedStyle(node);
         var fontSize = parseFloat(nodeStyle.getPropertyValue('font-size'));
-        var fontWeight = nodeStyle.getPropertyValue('font-weight');
-        var bold = [ 'bold', 'bolder', '600', '700', '800', '900' ].indexOf(fontWeight) !== -1;
+        var fontWeight = parseFloat(nodeStyle.getPropertyValue('font-weight'));
+        var bold = !isNaN(fontWeight) && fontWeight >= 700;
         var cr = color.hasValidContrastRatio(bgColor, fgColor, fontSize, bold);
         var truncatedResult = Math.floor(cr.contrastRatio * 100) / 100;
         var missing;
@@ -16387,10 +16639,11 @@
           missing = color.incompleteData.get('bgColor');
         }
         var equalRatio = truncatedResult === 1;
-        var shortTextContent = text.visibleVirtual(virtualNode, false, true).length === 1;
+        var shortTextContent = visibleText.length === 1;
+        var ignoreLength = !!(options || {}).ignoreLength;
         if (equalRatio) {
           missing = color.incompleteData.set('bgColor', 'equalRatio');
-        } else if (shortTextContent) {
+        } else if (shortTextContent && !ignoreLength) {
           missing = 'shortTextContent';
         }
         var data = {
@@ -16403,7 +16656,7 @@
           expectedContrastRatio: cr.expectedContrastRatio + ':1'
         };
         this.data(data);
-        if (fgColor === null || bgColor === null || equalRatio || shortTextContent && !cr.isValid) {
+        if (fgColor === null || bgColor === null || equalRatio || shortTextContent && !ignoreLength && !cr.isValid) {
           missing = null;
           color.incompleteData.clear();
           this.relatedNodes(bgNodes);
@@ -16413,11 +16666,16 @@
           this.relatedNodes(bgNodes);
         }
         return cr.isValid;
+      },
+      options: {
+        noScroll: false,
+        ignoreUnicode: true,
+        ignoreLength: false
       }
     }, {
       id: 'link-in-text-block',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons8 = axe.commons, color = _axe$commons8.color, dom = _axe$commons8.dom;
+        var _axe$commons9 = axe.commons, color = _axe$commons9.color, dom = _axe$commons9.dom;
         function getContrast(color1, color2) {
           var c1lum = color1.getRelativeLuminance();
           var c2lum = color2.getRelativeLuminance();
@@ -16639,7 +16897,7 @@
     }, {
       id: 'group-labelledby',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons9 = axe.commons, dom = _axe$commons9.dom, text = _axe$commons9.text;
+        var _axe$commons10 = axe.commons, dom = _axe$commons10.dom, text = _axe$commons10.text;
         var type = axe.utils.escapeSelector(node.type);
         var name = axe.utils.escapeSelector(node.name);
         var doc = dom.getRootNode(node);
@@ -16763,6 +17021,9 @@
           return out;
         }, []);
         this.relatedNodes(relatedNodes);
+        if (relatedNodes.length && axe.commons.dom.isModalOpen()) {
+          return true;
+        }
         return relatedNodes.length === 0;
       }
     }, {
@@ -16773,6 +17034,22 @@
         tabIndex = !isNaN(tabIndex) ? tabIndex : null;
         return tabIndex ? isFocusable && tabIndex >= 0 : isFocusable;
       }
+    }, {
+      id: 'focusable-modal-open',
+      evaluate: function evaluate(node, options, virtualNode, context) {
+        var tabbableElements = virtualNode.tabbableElements.map(function(_ref4) {
+          var actualNode = _ref4.actualNode;
+          return actualNode;
+        });
+        if (!tabbableElements || !tabbableElements.length) {
+          return true;
+        }
+        if (axe.commons.dom.isModalOpen()) {
+          this.relatedNodes(tabbableElements);
+          return undefined;
+        }
+        return true;
+      }
     }, {
       id: 'focusable-no-name',
       evaluate: function evaluate(node, options, virtualNode, context) {
@@ -16790,8 +17067,8 @@
         if (!tabbableElements || !tabbableElements.length) {
           return true;
         }
-        var relatedNodes = tabbableElements.reduce(function(out, _ref4) {
-          var el = _ref4.actualNode;
+        var relatedNodes = tabbableElements.reduce(function(out, _ref5) {
+          var el = _ref5.actualNode;
           var nodeName = el.nodeName.toUpperCase();
           if (!elementsThatCanBeDisabled.includes(nodeName)) {
             out.push(el);
@@ -16799,6 +17076,9 @@
           return out;
         }, []);
         this.relatedNodes(relatedNodes);
+        if (relatedNodes.length > 0 && axe.commons.dom.isModalOpen()) {
+          return true;
+        }
         return relatedNodes.length === 0;
       }
     }, {
@@ -16827,7 +17107,9 @@
         if (!options || !options.selector || typeof options.selector !== 'string') {
           throw new TypeError('visible-in-page requires options.selector to be a string');
         }
-        var matchingElms = axe.utils.querySelectorAll(virtualNode, options.selector);
+        var matchingElms = axe.utils.querySelectorAllFilter(virtualNode, options.selector, function(vNode) {
+          return axe.commons.dom.isVisible(vNode.actualNode);
+        });
         this.relatedNodes(matchingElms.map(function(vNode) {
           return vNode.actualNode;
         }));
@@ -16853,7 +17135,9 @@
         if (!options || !options.selector || typeof options.selector !== 'string') {
           throw new TypeError('visible-in-page requires options.selector to be a string');
         }
-        var matchingElms = axe.utils.querySelectorAll(virtualNode, options.selector);
+        var matchingElms = axe.utils.querySelectorAllFilter(virtualNode, options.selector, function(vNode) {
+          return axe.commons.dom.isVisible(vNode.actualNode);
+        });
         this.relatedNodes(matchingElms.map(function(vNode) {
           return vNode.actualNode;
         }));
@@ -16879,7 +17163,15 @@
         if (!options || !options.selector || typeof options.selector !== 'string') {
           throw new TypeError('visible-in-page requires options.selector to be a string');
         }
-        var elms = axe.utils.querySelectorAll(virtualNode, options.selector);
+        var key = 'page-no-duplicate;' + options.selector;
+        if (axe._cache.get(key)) {
+          this.data('ignored');
+          return;
+        }
+        axe._cache.set(key, true);
+        var elms = axe.utils.querySelectorAllFilter(axe._tree[0], options.selector, function(elm) {
+          return elm !== virtualNode && axe.commons.dom.isVisible(elm.actualNode);
+        });
         if (typeof options.nativeScopeFilter === 'string') {
           elms = elms.filter(function(elm) {
             return elm.actualNode.hasAttribute('role') || !axe.commons.dom.findUpVirtual(elm, options.nativeScopeFilter);
@@ -16888,7 +17180,12 @@
         this.relatedNodes(elms.map(function(elm) {
           return elm.actualNode;
         }));
-        return elms.length <= 1;
+        return elms.length === 0;
+      },
+      after: function after(results, options) {
+        return results.filter(function(checkResult) {
+          return checkResult.data !== 'ignored';
+        });
       },
       options: {
         selector: 'header:not([role]), [role=banner]',
@@ -16900,7 +17197,15 @@
         if (!options || !options.selector || typeof options.selector !== 'string') {
           throw new TypeError('visible-in-page requires options.selector to be a string');
         }
-        var elms = axe.utils.querySelectorAll(virtualNode, options.selector);
+        var key = 'page-no-duplicate;' + options.selector;
+        if (axe._cache.get(key)) {
+          this.data('ignored');
+          return;
+        }
+        axe._cache.set(key, true);
+        var elms = axe.utils.querySelectorAllFilter(axe._tree[0], options.selector, function(elm) {
+          return elm !== virtualNode && axe.commons.dom.isVisible(elm.actualNode);
+        });
         if (typeof options.nativeScopeFilter === 'string') {
           elms = elms.filter(function(elm) {
             return elm.actualNode.hasAttribute('role') || !axe.commons.dom.findUpVirtual(elm, options.nativeScopeFilter);
@@ -16909,7 +17214,12 @@
         this.relatedNodes(elms.map(function(elm) {
           return elm.actualNode;
         }));
-        return elms.length <= 1;
+        return elms.length === 0;
+      },
+      after: function after(results, options) {
+        return results.filter(function(checkResult) {
+          return checkResult.data !== 'ignored';
+        });
       },
       options: {
         selector: 'footer:not([role]), [role=contentinfo]',
@@ -16921,7 +17231,15 @@
         if (!options || !options.selector || typeof options.selector !== 'string') {
           throw new TypeError('visible-in-page requires options.selector to be a string');
         }
-        var elms = axe.utils.querySelectorAll(virtualNode, options.selector);
+        var key = 'page-no-duplicate;' + options.selector;
+        if (axe._cache.get(key)) {
+          this.data('ignored');
+          return;
+        }
+        axe._cache.set(key, true);
+        var elms = axe.utils.querySelectorAllFilter(axe._tree[0], options.selector, function(elm) {
+          return elm !== virtualNode && axe.commons.dom.isVisible(elm.actualNode);
+        });
         if (typeof options.nativeScopeFilter === 'string') {
           elms = elms.filter(function(elm) {
             return elm.actualNode.hasAttribute('role') || !axe.commons.dom.findUpVirtual(elm, options.nativeScopeFilter);
@@ -16930,7 +17248,12 @@
         this.relatedNodes(elms.map(function(elm) {
           return elm.actualNode;
         }));
-        return elms.length <= 1;
+        return elms.length === 0;
+      },
+      after: function after(results, options) {
+        return results.filter(function(checkResult) {
+          return checkResult.data !== 'ignored';
+        });
       },
       options: {
         selector: 'main:not([role]), [role=\'main\']'
@@ -16951,7 +17274,7 @@
     }, {
       id: 'duplicate-img-label',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons10 = axe.commons, aria = _axe$commons10.aria, text = _axe$commons10.text, dom = _axe$commons10.dom;
+        var _axe$commons11 = axe.commons, aria = _axe$commons11.aria, text = _axe$commons11.text, dom = _axe$commons11.dom;
         if ([ 'none', 'presentation' ].includes(aria.getRole(node))) {
           return false;
         }
@@ -17020,7 +17343,7 @@
     }, {
       id: 'implicit-label',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons11 = axe.commons, dom = _axe$commons11.dom, text = _axe$commons11.text;
+        var _axe$commons12 = axe.commons, dom = _axe$commons12.dom, text = _axe$commons12.text;
         var label = dom.findUpVirtual(virtualNode, 'label');
         if (label) {
           return !!text.accessibleText(label, {
@@ -17033,7 +17356,7 @@
       id: 'label-content-name-mismatch',
       evaluate: function evaluate(node, options, virtualNode, context) {
         var text = axe.commons.text;
-        var _ref5 = options || {}, pixelThreshold = _ref5.pixelThreshold, occuranceThreshold = _ref5.occuranceThreshold;
+        var _ref6 = options || {}, pixelThreshold = _ref6.pixelThreshold, occuranceThreshold = _ref6.occuranceThreshold;
         var accText = text.accessibleText(node).toLowerCase();
         if (text.isHumanInterpretable(accText) < 1) {
           return undefined;
@@ -17225,7 +17548,7 @@
     }, {
       id: 'only-dlitems',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons12 = axe.commons, dom = _axe$commons12.dom, aria = _axe$commons12.aria;
+        var _axe$commons13 = axe.commons, dom = _axe$commons13.dom, aria = _axe$commons13.aria;
         var ALLOWED_ROLES = [ 'definition', 'term', 'list' ];
         var base = {
           badNodes: [],
@@ -17263,54 +17586,52 @@
     }, {
       id: 'only-listitems',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var dom = axe.commons.dom;
-        var getIsListItemRole = function getIsListItemRole(role, tagName) {
-          return role === 'listitem' || tagName === 'LI' && !role;
-        };
-        var getHasListItem = function getHasListItem(hasListItem, tagName, isListItemRole) {
-          return hasListItem || tagName === 'LI' && isListItemRole || isListItemRole;
-        };
-        var base = {
-          badNodes: [],
-          isEmpty: true,
-          hasNonEmptyTextNode: false,
-          hasListItem: false,
-          liItemsWithRole: 0
-        };
-        var out = virtualNode.children.reduce(function(out, _ref6) {
-          var actualNode = _ref6.actualNode;
-          var tagName = actualNode.nodeName.toUpperCase();
-          if (actualNode.nodeType === 1 && dom.isVisible(actualNode, true, false)) {
-            var role = (actualNode.getAttribute('role') || '').toLowerCase();
-            var isListItemRole = getIsListItemRole(role, tagName);
-            out.hasListItem = getHasListItem(out.hasListItem, tagName, isListItemRole);
-            if (isListItemRole) {
-              out.isEmpty = false;
-            }
-            if (tagName === 'LI' && !isListItemRole) {
-              out.liItemsWithRole++;
-            }
-            if (tagName !== 'LI' && !isListItemRole) {
-              out.badNodes.push(actualNode);
-            }
+        var _axe$commons14 = axe.commons, dom = _axe$commons14.dom, aria = _axe$commons14.aria;
+        var hasNonEmptyTextNode = false;
+        var atLeastOneListitem = false;
+        var isEmpty = true;
+        var badNodes = [];
+        var badRoleNodes = [];
+        var badRoles = [];
+        virtualNode.children.forEach(function(vNode) {
+          var actualNode = vNode.actualNode;
+          if (actualNode.nodeType === 3 && actualNode.nodeValue.trim() !== '') {
+            hasNonEmptyTextNode = true;
+            return;
+          }
+          if (actualNode.nodeType !== 1 || !dom.isVisible(actualNode, true, false)) {
+            return;
+          }
+          isEmpty = false;
+          var isLi = actualNode.nodeName.toUpperCase() === 'LI';
+          var role = aria.getRole(vNode);
+          var isListItemRole = role === 'listitem';
+          if (!isLi && !isListItemRole) {
+            badNodes.push(actualNode);
           }
-          if (actualNode.nodeType === 3) {
-            if (actualNode.nodeValue.trim() !== '') {
-              out.hasNonEmptyTextNode = true;
+          if (isLi && !isListItemRole) {
+            badRoleNodes.push(actualNode);
+            if (!badRoles.includes(role)) {
+              badRoles.push(role);
             }
           }
-          return out;
-        }, base);
-        var virtualNodeChildrenOfTypeLi = virtualNode.children.filter(function(_ref7) {
-          var actualNode = _ref7.actualNode;
-          return actualNode.nodeName.toUpperCase() === 'LI';
+          if (isListItemRole) {
+            atLeastOneListitem = true;
+          }
         });
-        var allLiItemsHaveRole = out.liItemsWithRole > 0 && virtualNodeChildrenOfTypeLi.length === out.liItemsWithRole;
-        if (out.badNodes.length) {
-          this.relatedNodes(out.badNodes);
+        if (hasNonEmptyTextNode || badNodes.length) {
+          this.relatedNodes(badNodes);
+          return true;
+        }
+        if (isEmpty || atLeastOneListitem) {
+          return false;
         }
-        var isInvalidListItem = !(out.hasListItem || out.isEmpty && !allLiItemsHaveRole);
-        return isInvalidListItem || !!out.badNodes.length || out.hasNonEmptyTextNode;
+        this.relatedNodes(badRoleNodes);
+        this.data({
+          messageKey: 'roleNotValid',
+          roles: badRoles.join(', ')
+        });
+        return true;
       }
     }, {
       id: 'structured-dlitems',
@@ -17338,8 +17659,8 @@
       id: 'caption',
       evaluate: function evaluate(node, options, virtualNode, context) {
         var tracks = axe.utils.querySelectorAll(virtualNode, 'track');
-        var hasCaptions = tracks.some(function(_ref8) {
-          var actualNode = _ref8.actualNode;
+        var hasCaptions = tracks.some(function(_ref7) {
+          var actualNode = _ref7.actualNode;
           return (actualNode.getAttribute('kind') || '').toLowerCase() === 'captions';
         });
         return hasCaptions ? false : undefined;
@@ -17348,8 +17669,8 @@
       id: 'description',
       evaluate: function evaluate(node, options, virtualNode, context) {
         var tracks = axe.utils.querySelectorAll(virtualNode, 'track');
-        var hasDescriptions = tracks.some(function(_ref9) {
-          var actualNode = _ref9.actualNode;
+        var hasDescriptions = tracks.some(function(_ref8) {
+          var actualNode = _ref8.actualNode;
           return (actualNode.getAttribute('kind') || '').toLowerCase() === 'descriptions';
         });
         return hasDescriptions ? false : undefined;
@@ -17378,11 +17699,68 @@
       options: {
         isViolation: false
       }
+    }, {
+      id: 'no-autoplay-audio',
+      evaluate: function evaluate(node, options, virtualNode, context) {
+        if (!node.duration) {
+          console.warn('axe.utils.preloadMedia did not load metadata');
+          return undefined;
+        }
+        var _options$allowedDurat = options.allowedDuration, allowedDuration = _options$allowedDurat === void 0 ? 3 : _options$allowedDurat;
+        var playableDuration = getPlayableDuration(node);
+        if (playableDuration <= allowedDuration && !node.hasAttribute('loop')) {
+          return true;
+        }
+        if (!node.hasAttribute('controls')) {
+          return false;
+        }
+        return true;
+        function getPlayableDuration(elm) {
+          if (!elm.currentSrc) {
+            return 0;
+          }
+          var playbackRange = getPlaybackRange(elm.currentSrc);
+          if (!playbackRange) {
+            return Math.abs(elm.duration - (elm.currentTime || 0));
+          }
+          if (playbackRange.length === 1) {
+            return Math.abs(elm.duration - playbackRange[0]);
+          }
+          return Math.abs(playbackRange[1] - playbackRange[0]);
+        }
+        function getPlaybackRange(src) {
+          var match = src.match(/#t=(.*)/);
+          if (!match) {
+            return;
+          }
+          var _match = _slicedToArray(match, 2), value = _match[1];
+          var ranges = value.split(',');
+          return ranges.map(function(range) {
+            if (/:/.test(range)) {
+              return convertHourMinSecToSeconds(range);
+            }
+            return parseFloat(range);
+          });
+        }
+        function convertHourMinSecToSeconds(hhMmSs) {
+          var parts = hhMmSs.split(':');
+          var secs = 0;
+          var mins = 1;
+          while (parts.length > 0) {
+            secs += mins * parseInt(parts.pop(), 10);
+            mins *= 60;
+          }
+          return parseFloat(secs);
+        }
+      },
+      options: {
+        allowedDuration: 3
+      }
     }, {
       id: 'css-orientation-lock',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _ref10 = context || {}, _ref10$cssom = _ref10.cssom, cssom = _ref10$cssom === void 0 ? undefined : _ref10$cssom;
-        var _ref11 = options || {}, _ref11$degreeThreshol = _ref11.degreeThreshold, degreeThreshold = _ref11$degreeThreshol === void 0 ? 0 : _ref11$degreeThreshol;
+        var _ref9 = context || {}, _ref9$cssom = _ref9.cssom, cssom = _ref9$cssom === void 0 ? undefined : _ref9$cssom;
+        var _ref10 = options || {}, _ref10$degreeThreshol = _ref10.degreeThreshold, degreeThreshold = _ref10$degreeThreshol === void 0 ? 0 : _ref10$degreeThreshol;
         if (!cssom || !cssom.length) {
           return undefined;
         }
@@ -17390,14 +17768,14 @@
         var relatedElements = [];
         var rulesGroupByDocumentFragment = groupCssomByDocument(cssom);
         var _loop = function _loop() {
-          var key = _Object$keys[_i];
+          var key = _Object$keys[_i2];
           var _rulesGroupByDocument = rulesGroupByDocumentFragment[key], root = _rulesGroupByDocument.root, rules = _rulesGroupByDocument.rules;
           var orientationRules = rules.filter(isMediaRuleWithOrientation);
           if (!orientationRules.length) {
             return 'continue';
           }
-          orientationRules.forEach(function(_ref17) {
-            var cssRules = _ref17.cssRules;
+          orientationRules.forEach(function(_ref16) {
+            var cssRules = _ref16.cssRules;
             Array.from(cssRules).forEach(function(cssRule) {
               var locked = getIsOrientationLocked(cssRule);
               if (locked && cssRule.selectorText.toUpperCase() !== 'HTML') {
@@ -17408,7 +17786,7 @@
             });
           });
         };
-        for (var _i = 0, _Object$keys = Object.keys(rulesGroupByDocumentFragment); _i < _Object$keys.length; _i++) {
+        for (var _i2 = 0, _Object$keys = Object.keys(rulesGroupByDocumentFragment); _i2 < _Object$keys.length; _i2++) {
           var _ret = _loop();
           if (_ret === 'continue') {
             continue;
@@ -17422,8 +17800,8 @@
         }
         return false;
         function groupCssomByDocument(cssObjectModel) {
-          return cssObjectModel.reduce(function(out, _ref12) {
-            var sheet = _ref12.sheet, root = _ref12.root, shadowId = _ref12.shadowId;
+          return cssObjectModel.reduce(function(out, _ref11) {
+            var sheet = _ref11.sheet, root = _ref11.root, shadowId = _ref11.shadowId;
             var key = shadowId ? shadowId : 'topDocument';
             if (!out[key]) {
               out[key] = {
@@ -17439,15 +17817,15 @@
             return out;
           }, {});
         }
-        function isMediaRuleWithOrientation(_ref13) {
-          var type = _ref13.type, cssText = _ref13.cssText;
+        function isMediaRuleWithOrientation(_ref12) {
+          var type = _ref12.type, cssText = _ref12.cssText;
           if (type !== 4) {
             return false;
           }
           return /orientation:\s*landscape/i.test(cssText) || /orientation:\s*portrait/i.test(cssText);
         }
-        function getIsOrientationLocked(_ref14) {
-          var selectorText = _ref14.selectorText, style = _ref14.style;
+        function getIsOrientationLocked(_ref13) {
+          var selectorText = _ref13.selectorText, style = _ref13.style;
           if (!selectorText || style.length <= 0) {
             return false;
           }
@@ -17494,7 +17872,7 @@
           }
         }
         function getAngleInDegrees(angleWithUnit) {
-          var _ref15 = angleWithUnit.match(/(deg|grad|rad|turn)/) || [], _ref16 = _slicedToArray(_ref15, 1), unit = _ref16[0];
+          var _ref14 = angleWithUnit.match(/(deg|grad|rad|turn)/) || [], _ref15 = _slicedToArray(_ref14, 1), unit = _ref15[0];
           if (!unit) {
             return;
           }
@@ -17634,6 +18012,92 @@
         }
         return results;
       }
+    }, {
+      id: 'identical-links-same-purpose',
+      evaluate: function evaluate(node, options, virtualNode, context) {
+        var _axe$commons15 = axe.commons, dom = _axe$commons15.dom, text = _axe$commons15.text;
+        var accText = text.accessibleTextVirtual(virtualNode);
+        var name = text.sanitize(text.removeUnicode(accText, {
+          emoji: true,
+          nonBmp: true,
+          punctuations: true
+        })).toLowerCase();
+        if (!name) {
+          return undefined;
+        }
+        var afterData = {
+          name: name,
+          urlProps: dom.urlPropsFromAttribute(node, 'href')
+        };
+        this.data(afterData);
+        this.relatedNodes([ node ]);
+        return true;
+      },
+      after: function after(results, options) {
+        if (results.length < 2) {
+          return results;
+        }
+        var incompleteResults = results.filter(function(_ref17) {
+          var result = _ref17.result;
+          return result !== undefined;
+        });
+        var uniqueResults = [];
+        var nameMap = {};
+        var _loop2 = function _loop2(index) {
+          var _currentResult$relate;
+          var currentResult = incompleteResults[index];
+          var _currentResult$data = currentResult.data, name = _currentResult$data.name, urlProps = _currentResult$data.urlProps;
+          if (nameMap[name]) {
+            return 'continue';
+          }
+          var sameNameResults = incompleteResults.filter(function(_ref18, resultNum) {
+            var data = _ref18.data;
+            return data.name === name && resultNum !== index;
+          });
+          var isSameUrl = sameNameResults.every(function(_ref19) {
+            var data = _ref19.data;
+            return isIdenticalObject(data.urlProps, urlProps);
+          });
+          if (sameNameResults.length && !isSameUrl) {
+            currentResult.result = undefined;
+          }
+          currentResult.relatedNodes = [];
+          (_currentResult$relate = currentResult.relatedNodes).push.apply(_currentResult$relate, _toConsumableArray(sameNameResults.map(function(node) {
+            return node.relatedNodes[0];
+          })));
+          nameMap[name] = sameNameResults;
+          uniqueResults.push(currentResult);
+        };
+        for (var index = 0; index < incompleteResults.length; index++) {
+          var _ret2 = _loop2(index);
+          if (_ret2 === 'continue') {
+            continue;
+          }
+        }
+        return uniqueResults;
+        function isIdenticalObject(a, b) {
+          if (!a || !b) {
+            return false;
+          }
+          var aProps = Object.getOwnPropertyNames(a);
+          var bProps = Object.getOwnPropertyNames(b);
+          if (aProps.length !== bProps.length) {
+            return false;
+          }
+          var result = aProps.every(function(propName) {
+            var aValue = a[propName];
+            var bValue = b[propName];
+            if (_typeof(aValue) !== _typeof(bValue)) {
+              return false;
+            }
+            if (typeof aValue === 'object' || typeof bValue === 'object') {
+              return isIdenticalObject(aValue, bValue);
+            }
+            return aValue === bValue;
+          });
+          return result;
+        }
+      }
     }, {
       id: 'internal-link-present',
       evaluate: function evaluate(node, options, virtualNode, context) {
@@ -17746,8 +18210,13 @@
     }, {
       id: 'region',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons13 = axe.commons, dom = _axe$commons13.dom, aria = _axe$commons13.aria;
+        var _axe$commons16 = axe.commons, dom = _axe$commons16.dom, aria = _axe$commons16.aria;
         var landmarkRoles = aria.getRolesByType('landmark');
+        var implicitAriaLiveRoles = [ 'alert', 'log', 'status' ];
+        var regionlessNodes = axe._cache.get('regionlessNodes');
+        if (regionlessNodes) {
+          return !regionlessNodes.includes(virtualNode);
+        }
         var implicitLandmarks = landmarkRoles.reduce(function(arr, role) {
           return arr.concat(aria.implicitNodes(role));
         }, []).filter(function(r) {
@@ -17759,12 +18228,12 @@
             noImplicit: true
           });
           var ariaLive = (node.getAttribute('aria-live') || '').toLowerCase().trim();
+          if ([ 'assertive', 'polite' ].includes(ariaLive) || implicitAriaLiveRoles.includes(explicitRole)) {
+            return true;
+          }
           if (explicitRole) {
             return explicitRole === 'dialog' || landmarkRoles.includes(explicitRole);
           }
-          if ([ 'assertive', 'polite' ].includes(ariaLive)) {
-            return true;
-          }
           return implicitLandmarks.some(function(implicitSelector) {
             var matches = axe.utils.matchesSelector(node, implicitSelector);
             if (node.nodeName.toUpperCase() === 'FORM') {
@@ -17778,24 +18247,33 @@
         function findRegionlessElms(virtualNode) {
           var node = virtualNode.actualNode;
           if (isRegion(virtualNode) || dom.isSkipLink(virtualNode.actualNode) && dom.getElementByReference(virtualNode.actualNode, 'href') || !dom.isVisible(node, true)) {
+            var vNode = virtualNode;
+            while (vNode) {
+              vNode._hasRegionDescendant = true;
+              vNode = vNode.parent;
+            }
             return [];
           } else if (dom.hasContent(node, true)) {
-            return [ node ];
+            return [ virtualNode ];
           } else {
-            return virtualNode.children.filter(function(_ref18) {
-              var actualNode = _ref18.actualNode;
+            return virtualNode.children.filter(function(_ref20) {
+              var actualNode = _ref20.actualNode;
               return actualNode.nodeType === 1;
             }).map(findRegionlessElms).reduce(function(a, b) {
               return a.concat(b);
             }, []);
           }
         }
-        var regionlessNodes = findRegionlessElms(virtualNode);
-        this.relatedNodes(regionlessNodes);
-        return regionlessNodes.length === 0;
-      },
-      after: function after(results, options) {
-        return [ results[0] ];
+        regionlessNodes = findRegionlessElms(axe._tree[0]).map(function(vNode) {
+          while (vNode.parent && !vNode.parent._hasRegionDescendant && vNode.parent.actualNode !== document.body) {
+            vNode = vNode.parent;
+          }
+          return vNode;
+        }).filter(function(vNode, index, array) {
+          return array.indexOf(vNode) === index;
+        });
+        axe._cache.set('regionlessNodes', regionlessNodes);
+        return !regionlessNodes.includes(virtualNode);
       }
     }, {
       id: 'skip-link',
@@ -17907,13 +18385,13 @@
     }, {
       id: 'aria-label',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons14 = axe.commons, text = _axe$commons14.text, aria = _axe$commons14.aria;
+        var _axe$commons17 = axe.commons, text = _axe$commons17.text, aria = _axe$commons17.aria;
         return !!text.sanitize(aria.arialabelText(virtualNode));
       }
     }, {
       id: 'aria-labelledby',
       evaluate: function evaluate(node, options, virtualNode, context) {
-        var _axe$commons15 = axe.commons, text = _axe$commons15.text, aria = _axe$commons15.aria;
+        var _axe$commons18 = axe.commons, text = _axe$commons18.text, aria = _axe$commons18.aria;
         return !!text.sanitize(aria.arialabelledbyText(node));
       }
     }, {
@@ -18019,6 +18497,15 @@
       evaluate: function evaluate(node, options, virtualNode, context) {
         return node.getAttribute('role') === 'presentation';
       }
+    }, {
+      id: 'svg-non-empty-title',
+      evaluate: function evaluate(node, options, virtualNode, context) {
+        var titleNode = virtualNode.children.find(function(_ref21) {
+          var props = _ref21.props;
+          return props.nodeName === 'title';
+        });
+        return !!titleNode && titleNode.actualNode.textContent.trim() !== '';
+      }
     }, {
       id: 'caption-faked',
       evaluate: function evaluate(node, options, virtualNode, context) {
@@ -18288,7 +18775,9 @@
           unstandardized: true
         },
         'aria-details': {
-          unsupported: true
+          type: 'idref',
+          allowEmpty: true,
+          unsupported: false
         },
         'aria-disabled': {
           type: 'boolean',
@@ -18463,7 +18952,7 @@
           unsupported: false
         }
       };
-      lookupTable.globalAttributes = [ 'aria-atomic', 'aria-busy', 'aria-controls', 'aria-current', 'aria-describedby', 'aria-disabled', 'aria-dropeffect', 'aria-flowto', 'aria-grabbed', 'aria-haspopup', 'aria-hidden', 'aria-invalid', 'aria-keyshortcuts', 'aria-label', 'aria-labelledby', 'aria-live', 'aria-owns', 'aria-relevant', 'aria-roledescription' ];
+      lookupTable.globalAttributes = [ 'aria-atomic', 'aria-busy', 'aria-controls', 'aria-current', 'aria-describedby', 'aria-details', 'aria-disabled', 'aria-dropeffect', 'aria-flowto', 'aria-grabbed', 'aria-haspopup', 'aria-hidden', 'aria-invalid', 'aria-keyshortcuts', 'aria-label', 'aria-labelledby', 'aria-live', 'aria-owns', 'aria-relevant', 'aria-roledescription' ];
       lookupTable.role = {
         alert: {
           type: 'widget',
@@ -18579,7 +19068,7 @@
             required: [ 'aria-expanded' ]
           },
           owned: {
-            all: [ 'listbox', 'textbox' ]
+            all: [ 'listbox', 'tree', 'grid', 'dialog', 'textbox' ]
           },
           nameFrom: [ 'author' ],
           context: null,
@@ -19933,8 +20422,11 @@
         }
       }, {
         nodeName: 'select',
-        condition: function condition(node) {
-          return Number(node.getAttribute('size')) > 1;
+        condition: function condition(vNode) {
+          if (!(vNode instanceof axe.AbstractVirtualNode)) {
+            vNode = axe.utils.getNodeFromTree(vNode);
+          }
+          return Number(vNode.attr('size')) > 1;
         },
         properties: {
           multiple: true
@@ -19956,8 +20448,8 @@
         nodeName: [ 'abbr', 'address', 'canvas', 'div', 'p', 'pre', 'blockquote', 'ins', 'del', 'output', 'span', 'table', 'tbody', 'thead', 'tfoot', 'td', 'em', 'strong', 'small', 's', 'cite', 'q', 'dfn', 'abbr', 'time', 'code', 'var', 'samp', 'kbd', 'sub', 'sup', 'i', 'b', 'u', 'mark', 'ruby', 'rt', 'rp', 'bdi', 'bdo', 'br', 'wbr', 'th', 'tr' ]
       } ];
       lookupTable.evaluateRoleForElement = {
-        A: function A(_ref19) {
-          var node = _ref19.node, out = _ref19.out;
+        A: function A(_ref22) {
+          var node = _ref22.node, out = _ref22.out;
           if (node.namespaceURI === 'http://www.w3.org/2000/svg') {
             return true;
           }
@@ -19966,19 +20458,19 @@
           }
           return true;
         },
-        AREA: function AREA(_ref20) {
-          var node = _ref20.node;
+        AREA: function AREA(_ref23) {
+          var node = _ref23.node;
           return !node.href;
         },
-        BUTTON: function BUTTON(_ref21) {
-          var node = _ref21.node, role = _ref21.role, out = _ref21.out;
+        BUTTON: function BUTTON(_ref24) {
+          var node = _ref24.node, role = _ref24.role, out = _ref24.out;
           if (node.getAttribute('type') === 'menu') {
             return role === 'menuitem';
           }
           return out;
         },
-        IMG: function IMG(_ref22) {
-          var node = _ref22.node, role = _ref22.role, out = _ref22.out;
+        IMG: function IMG(_ref25) {
+          var node = _ref25.node, role = _ref25.role, out = _ref25.out;
           switch (node.alt) {
            case null:
             return out;
@@ -19990,8 +20482,8 @@
             return role !== 'presentation' && role !== 'none';
           }
         },
-        INPUT: function INPUT(_ref23) {
-          var node = _ref23.node, role = _ref23.role, out = _ref23.out;
+        INPUT: function INPUT(_ref26) {
+          var node = _ref26.node, role = _ref26.role, out = _ref26.out;
           switch (node.type) {
            case 'button':
            case 'image':
@@ -20019,32 +20511,32 @@
             return false;
           }
         },
-        LI: function LI(_ref24) {
-          var node = _ref24.node, out = _ref24.out;
+        LI: function LI(_ref27) {
+          var node = _ref27.node, out = _ref27.out;
           var hasImplicitListitemRole = axe.utils.matchesSelector(node, 'ol li, ul li');
           if (hasImplicitListitemRole) {
             return out;
           }
           return true;
         },
-        MENU: function MENU(_ref25) {
-          var node = _ref25.node;
+        MENU: function MENU(_ref28) {
+          var node = _ref28.node;
           if (node.getAttribute('type') === 'context') {
             return false;
           }
           return true;
         },
-        OPTION: function OPTION(_ref26) {
-          var node = _ref26.node;
+        OPTION: function OPTION(_ref29) {
+          var node = _ref29.node;
           var withinOptionList = axe.utils.matchesSelector(node, 'select > option, datalist > option, optgroup > option');
           return !withinOptionList;
         },
-        SELECT: function SELECT(_ref27) {
-          var node = _ref27.node, role = _ref27.role;
+        SELECT: function SELECT(_ref30) {
+          var node = _ref30.node, role = _ref30.role;
           return !node.multiple && node.size <= 1 && role === 'menu';
         },
-        SVG: function SVG(_ref28) {
-          var node = _ref28.node, out = _ref28.out;
+        SVG: function SVG(_ref31) {
+          var node = _ref31.node, out = _ref31.out;
           if (node.parentNode && node.parentNode.namespaceURI === 'http://www.w3.org/2000/svg') {
             return true;
           }
@@ -20052,15 +20544,15 @@
         }
       };
       lookupTable.rolesOfType = {
-        widget: [ 'button', 'checkbox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'scrollbar', 'slider', 'spinbutton', 'status', 'switch', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'tree', 'treeitem' ]
+        widget: [ 'button', 'checkbox', 'dialog', 'gridcell', 'link', 'log', 'marquee', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'progressbar', 'radio', 'scrollbar', 'searchbox', 'slider', 'spinbutton', 'status', 'switch', 'tab', 'tabpanel', 'textbox', 'timer', 'tooltip', 'tree', 'treeitem' ]
       };
       var color = {};
       commons.color = color;
       var dom = commons.dom = {};
       var forms = {};
       commons.forms = forms;
-      function matches(node, definition) {
-        return matches.fromDefinition(node, definition);
+      function matches(vNode, definition) {
+        return matches.fromDefinition(vNode, definition);
       }
       commons.matches = matches;
       var table = commons.table = {};
@@ -20156,8 +20648,8 @@
         });
         return unallowedRoles;
       };
-      aria.getOwnedVirtual = function getOwned(_ref29) {
-        var actualNode = _ref29.actualNode, children = _ref29.children;
+      aria.getOwnedVirtual = function getOwned(_ref32) {
+        var actualNode = _ref32.actualNode, children = _ref32.children;
         if (!actualNode || !children) {
           throw new Error('getOwnedVirtual requires a virtual node');
         }
@@ -20170,7 +20662,7 @@
         }, children);
       };
       aria.getRole = function getRole(node) {
-        var _ref30 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, noImplicit = _ref30.noImplicit, fallback = _ref30.fallback, abstracts = _ref30.abstracts, dpub = _ref30.dpub;
+        var _ref33 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, noImplicit = _ref33.noImplicit, fallback = _ref33.fallback, abstracts = _ref33.abstracts, dpub = _ref33.dpub;
         node = node.actualNode || node;
         if (node.nodeType !== 1) {
           return null;
@@ -20210,8 +20702,8 @@
             }
           }
         }
-        for (var _i2 = 0; _i2 < node.children.length; _i2++) {
-          cacheIdRefs(node.children[_i2], refAttrs);
+        for (var _i3 = 0; _i3 < node.children.length; _i3++) {
+          cacheIdRefs(node.children[_i3], refAttrs);
         }
       }
       aria.isAccessibleRef = function isAccessibleRef(node) {
@@ -20256,8 +20748,8 @@
         var roleDefinition = aria.lookupTable.role[role];
         return roleDefinition ? roleDefinition.unsupported : false;
       };
-      aria.labelVirtual = function(_ref31) {
-        var actualNode = _ref31.actualNode;
+      aria.labelVirtual = function(_ref34) {
+        var actualNode = _ref34.actualNode;
         var ref, candidate;
         if (actualNode.getAttribute('aria-labelledby')) {
           ref = dom.idrefs(actualNode, 'aria-labelledby');
@@ -20283,7 +20775,7 @@
         return aria.labelVirtual(node);
       };
       aria.namedFromContents = function namedFromContents(node) {
-        var _ref32 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, strict = _ref32.strict;
+        var _ref35 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, strict = _ref35.strict;
         node = node.actualNode || node;
         if (node.nodeType !== 1) {
           return false;
@@ -20299,7 +20791,7 @@
         return !roleDef || [ 'presentation', 'none' ].includes(role);
       };
       aria.isValidRole = function(role) {
-        var _ref33 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, allowAbstract = _ref33.allowAbstract, _ref33$flagUnsupporte = _ref33.flagUnsupported, flagUnsupported = _ref33$flagUnsupporte === void 0 ? false : _ref33$flagUnsupporte;
+        var _ref36 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, allowAbstract = _ref36.allowAbstract, _ref36$flagUnsupporte = _ref36.flagUnsupported, flagUnsupported = _ref36$flagUnsupporte === void 0 ? false : _ref36$flagUnsupporte;
         var roleDefinition = aria.lookupTable.role[role];
         var isRoleUnsupported = roleDefinition ? roleDefinition.unsupported : false;
         if (!roleDefinition || flagUnsupported && isRoleUnsupported) {
@@ -20579,22 +21071,6 @@
       color.elementIsDistinct = elementIsDistinct;
       color.getBackgroundColor = function getBackgroundColor(elm) {
         var bgElms = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-        var noScroll = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-        if (noScroll !== true) {
-          var clientHeight = elm.getBoundingClientRect().height;
-          var alignToTop = clientHeight - 2 >= window.innerHeight * 2;
-          elm.scrollIntoView(alignToTop);
-          var center, scrollParent;
-          do {
-            var rect = elm.getBoundingClientRect();
-            var x = 'x' in rect ? rect.x : rect.left;
-            center = x + rect.width / 2;
-            if (center < 0) {
-              scrollParent = getScrollParent(elm);
-              scrollParent.scrollLeft = 0;
-            }
-          } while (center < 0 && scrollParent !== document.documentElement);
-        }
         var bgColors = [];
         var elmStack = color.getBackgroundStack(elm);
         (elmStack || []).some(function(bgElm) {
@@ -20625,7 +21101,6 @@
         if (elmStack === null) {
           return null;
         }
-        elmStack = includeMissingElements(elmStack, elm);
         elmStack = dom.reduceToElementsBelowFloating(elmStack, elm);
         elmStack = sortPageBackground(elmStack);
         var elmIndex = elmStack.indexOf(elm);
@@ -20643,7 +21118,6 @@
         if (rectStack && rectStack.length > 1) {
           var boundingStack = rectStack.shift();
           var isSame;
-          includeMissingElements(boundingStack, elm);
           rectStack.forEach(function(rectList, index) {
             if (index === 0) {
               return;
@@ -20663,23 +21137,11 @@
         return null;
       };
       color.getRectStack = function(elm) {
-        var boundingCoords = axe.commons.color.centerPointOfRect(elm.getBoundingClientRect());
-        if (!boundingCoords) {
-          return null;
-        }
-        var boundingStack = dom.shadowElementsFromPoint(boundingCoords.x, boundingCoords.y);
-        var rects = Array.from(elm.getClientRects());
-        if (!rects || rects.length <= 1) {
+        var boundingStack = axe.commons.dom.getElementStack(elm);
+        var filteredArr = axe.commons.dom.getTextElementStack(elm);
+        if (!filteredArr || filteredArr.length <= 1) {
           return [ boundingStack ];
         }
-        var filteredArr = rects.filter(function(rect) {
-          return rect.width && rect.width > 0;
-        }).map(function(rect) {
-          var coords = axe.commons.color.centerPointOfRect(rect);
-          if (coords) {
-            return dom.shadowElementsFromPoint(coords.x, coords.y);
-          }
-        });
         if (filteredArr.some(function(stack) {
           return stack === undefined;
         })) {
@@ -20701,35 +21163,6 @@
         }
         return bgNodes;
       }
-      function includeMissingElements(elmStack, elm) {
-        var nodeName = elm.nodeName.toUpperCase();
-        var elementMap = {
-          TD: [ 'TR', 'THEAD', 'TBODY', 'TFOOT' ],
-          TH: [ 'TR', 'THEAD', 'TBODY', 'TFOOT' ],
-          INPUT: [ 'LABEL' ]
-        };
-        var tagArray = elmStack.map(function(elm) {
-          return elm.nodeName.toUpperCase();
-        });
-        var bgNodes = elmStack;
-        for (var candidate in elementMap) {
-          if (tagArray.includes(candidate)) {
-            for (var candidateIndex = 0; candidateIndex < elementMap[candidate].length; candidateIndex++) {
-              var ancestorMatch = axe.commons.dom.findUp(elm, elementMap[candidate][candidateIndex]);
-              if (ancestorMatch && elmStack.indexOf(ancestorMatch) === -1) {
-                var overlaps = axe.commons.dom.visuallyOverlaps(elm.getBoundingClientRect(), ancestorMatch);
-                if (overlaps) {
-                  bgNodes.splice(tagArray.indexOf(candidate) + 1, 0, ancestorMatch);
-                }
-              }
-              if (nodeName === elementMap[candidate][candidateIndex] && tagArray.indexOf(nodeName) === -1) {
-                bgNodes.splice(tagArray.indexOf(candidate) + 1, 0, elm);
-              }
-            }
-          }
-        }
-        return bgNodes;
-      }
       function elmPartiallyObscured(elm, bgElm, bgColor) {
         var obscured = elm !== bgElm && !dom.visuallyContains(elm, bgElm) && bgColor.alpha !== 0;
         if (obscured) {
@@ -20762,24 +21195,6 @@
         }
         return false;
       }
-      function getScrollParent(element, includeHidden) {
-        var style = getComputedStyle(element);
-        var excludeStaticParent = style.position === 'absolute';
-        var overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;
-        if (style.position === 'fixed') {
-          return document.documentElement;
-        }
-        for (var parent = element; parent = parent.parentElement; ) {
-          style = getComputedStyle(parent);
-          if (excludeStaticParent && style.position === 'static') {
-            continue;
-          }
-          if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) {
-            return parent;
-          }
-        }
-        return document.documentElement;
-      }
       dom.isOpaque = function(node) {
         var style = window.getComputedStyle(node);
         return color.elementHasImage(node, style) || color.getOwnBackgroundColor(style).alpha === 1;
@@ -20864,8 +21279,8 @@
         }
         return finalElements;
       };
-      dom.findElmsInContext = function(_ref34) {
-        var context = _ref34.context, value = _ref34.value, attr = _ref34.attr, _ref34$elm = _ref34.elm, elm = _ref34$elm === void 0 ? '' : _ref34$elm;
+      dom.findElmsInContext = function(_ref37) {
+        var context = _ref37.context, value = _ref37.value, attr = _ref37.attr, _ref37$elm = _ref37.elm, elm = _ref37$elm === void 0 ? '' : _ref37$elm;
         var root;
         var escapedValue = axe.utils.escapeSelector(value);
         if (context.nodeType === 9 || context.nodeType === 11) {
@@ -20948,15 +21363,13 @@
         };
       };
       var gridSize = 200;
-      function isStackingContext(vNode) {
-        var node = vNode.actualNode;
-        if (!node || node.nodeName === 'HTML' || node.nodeName === '#document-fragment') {
+      function isStackingContext(vNode, parentVNode) {
+        var position = vNode.getComputedStylePropertyValue('position');
+        var zIndex = vNode.getComputedStylePropertyValue('z-index');
+        if (position === 'fixed' || position === 'sticky') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('position') === 'fixed' || vNode.getComputedStylePropertyValue('position') === 'sticky') {
-          return true;
-        }
-        if (vNode.getComputedStylePropertyValue('z-index') !== 'auto' && vNode.getComputedStylePropertyValue('position') !== 'static') {
+        if (zIndex !== 'auto' && position !== 'static') {
           return true;
         }
         if (vNode.getComputedStylePropertyValue('opacity') !== '1') {
@@ -20966,16 +21379,20 @@
         if (transform !== 'none') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('mix-blend-mode') && vNode.getComputedStylePropertyValue('mix-blend-mode') !== 'normal') {
+        var mixBlendMode = vNode.getComputedStylePropertyValue('mix-blend-mode');
+        if (mixBlendMode && mixBlendMode !== 'normal') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('filter') && vNode.getComputedStylePropertyValue('filter') !== 'none') {
+        var filter = vNode.getComputedStylePropertyValue('filter');
+        if (filter && filter !== 'none') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('perspective') && vNode.getComputedStylePropertyValue('perspective') !== 'none') {
+        var perspective = vNode.getComputedStylePropertyValue('perspective');
+        if (perspective && perspective !== 'none') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('clip-path') && vNode.getComputedStylePropertyValue('clip-path') !== 'none') {
+        var clipPath = vNode.getComputedStylePropertyValue('clip-path');
+        if (clipPath && clipPath !== 'none') {
           return true;
         }
         var mask = vNode.getComputedStylePropertyValue('-webkit-mask') || vNode.getComputedStylePropertyValue('mask') || 'none';
@@ -20993,7 +21410,8 @@
         if (vNode.getComputedStylePropertyValue('isolation') === 'isolate') {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('will-change') === 'transform' || vNode.getComputedStylePropertyValue('will-change') === 'opacity') {
+        var willChange = vNode.getComputedStylePropertyValue('will-change');
+        if (willChange === 'transform' || willChange === 'opacity') {
           return true;
         }
         if (vNode.getComputedStylePropertyValue('-webkit-overflow-scrolling') === 'touch') {
@@ -21003,8 +21421,8 @@
         if ([ 'layout', 'paint', 'strict', 'content' ].includes(contain)) {
           return true;
         }
-        if (vNode.getComputedStylePropertyValue('z-index') !== 'auto' && vNode.parent) {
-          var parentDsiplay = vNode.parent.getComputedStylePropertyValue('display');
+        if (zIndex !== 'auto' && parentVNode) {
+          var parentDsiplay = parentVNode.getComputedStylePropertyValue('display');
           if ([ 'flex', 'inline-flex', 'inline flex', 'grid', 'inline-grid', 'inline grid' ].includes(parentDsiplay)) {
             return true;
           }
@@ -21019,19 +21437,11 @@
           if (vNode.getComputedStylePropertyValue('float') !== 'none') {
             return 1;
           }
-          if (vNode.getComputedStylePropertyValue('position') === 'static') {
-            return 0;
-          }
+          return 0;
         }
         return 3;
       }
       function visuallySort(a, b) {
-        if (a.actualNode.nodeName.toLowerCase() === 'html') {
-          return 1;
-        }
-        if (b.actualNode.nodeName.toLowerCase() === 'html') {
-          return -1;
-        }
         for (var i = 0; i < a._stackingOrder.length; i++) {
           if (typeof b._stackingOrder[i] === 'undefined') {
             return -1;
@@ -21043,9 +21453,33 @@
             return -1;
           }
         }
-        var docPosition = a.actualNode.compareDocumentPosition(b.actualNode);
-        var DOMOrder = docPosition & 4 ? 1 : -1;
-        var isDescendant = docPosition & 8 || docPosition & 16;
+        var aNode = a.actualNode;
+        var bNode = b.actualNode;
+        if (aNode.getRootNode && aNode.getRootNode() !== bNode.getRootNode()) {
+          var boundaries = [];
+          while (aNode) {
+            boundaries.push({
+              root: aNode.getRootNode(),
+              node: aNode
+            });
+            aNode = aNode.getRootNode().host;
+          }
+          while (bNode && !boundaries.find(function(boundary) {
+            return boundary.root === bNode.getRootNode();
+          })) {
+            bNode = bNode.getRootNode().host;
+          }
+          aNode = boundaries.find(function(boundary) {
+            return boundary.root === bNode.getRootNode();
+          }).node;
+          if (aNode === bNode) {
+            return a.actualNode.getRootNode() !== aNode.getRootNode() ? -1 : 1;
+          }
+        }
+        var _window$Node = window.Node, DOCUMENT_POSITION_FOLLOWING = _window$Node.DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_CONTAINS = _window$Node.DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_CONTAINED_BY = _window$Node.DOCUMENT_POSITION_CONTAINED_BY;
+        var docPosition = aNode.compareDocumentPosition(bNode);
+        var DOMOrder = docPosition & DOCUMENT_POSITION_FOLLOWING ? 1 : -1;
+        var isDescendant = docPosition & DOCUMENT_POSITION_CONTAINS || docPosition & DOCUMENT_POSITION_CONTAINED_BY;
         var aPosition = getPositionOrder(a);
         var bPosition = getPositionOrder(b);
         if (aPosition === bPosition || isDescendant) {
@@ -21053,50 +21487,46 @@
         }
         return bPosition - aPosition;
       }
-      function getStackingOrder(vNode) {
-        var stackingOrder = vNode.parent ? vNode.parent._stackingOrder.slice() : [ 0 ];
-        if (vNode.getComputedStylePropertyValue('z-index') !== 'auto') {
-          stackingOrder[stackingOrder.length - 1] = parseInt(vNode.getComputedStylePropertyValue('z-index'));
+      function getStackingOrder(vNode, parentVNode) {
+        var stackingOrder = parentVNode._stackingOrder.slice();
+        var zIndex = vNode.getComputedStylePropertyValue('z-index');
+        if (zIndex !== 'auto') {
+          stackingOrder[stackingOrder.length - 1] = parseInt(zIndex);
         }
-        if (isStackingContext(vNode)) {
+        if (isStackingContext(vNode, parentVNode)) {
           stackingOrder.push(0);
         }
         return stackingOrder;
       }
-      function findScrollRegionParent(vNode) {
+      function findScrollRegionParent(vNode, parentVNode) {
         var scrollRegionParent = null;
-        var vNodeParent = vNode.parent;
         var checkedNodes = [ vNode ];
-        while (vNodeParent) {
-          if (vNodeParent._scrollRegionParent) {
-            scrollRegionParent = vNodeParent._scrollRegionParent;
+        while (parentVNode) {
+          if (parentVNode._scrollRegionParent) {
+            scrollRegionParent = parentVNode._scrollRegionParent;
             break;
           }
-          if (axe.utils.getScroll(vNodeParent.actualNode)) {
-            scrollRegionParent = vNodeParent;
+          if (axe.utils.getScroll(parentVNode.actualNode)) {
+            scrollRegionParent = parentVNode;
             break;
           }
-          checkedNodes.push(vNodeParent);
-          vNodeParent = vNodeParent.parent;
+          checkedNodes.push(parentVNode);
+          parentVNode = axe.utils.getNodeFromTree(parentVNode.actualNode.parentElement || parentVNode.actualNode.parentNode);
         }
         checkedNodes.forEach(function(vNode) {
           return vNode._scrollRegionParent = scrollRegionParent;
         });
         return scrollRegionParent;
       }
-      function getDomPosition(rect, pos) {
-        if (pos === 'x') {
-          return 'x' in rect ? rect.x : rect.left;
-        }
-        return 'y' in rect ? rect.y : rect.top;
-      }
       function addNodeToGrid(grid, vNode) {
         vNode._grid = grid;
         vNode.clientRects.forEach(function(rect) {
-          var startRow = Math.floor(getDomPosition(rect, 'y') / gridSize);
-          var startCol = Math.floor(getDomPosition(rect, 'x') / gridSize);
-          var endRow = Math.floor((getDomPosition(rect, 'y') + rect.height) / gridSize);
-          var endCol = Math.floor((getDomPosition(rect, 'x') + rect.width) / gridSize);
+          var x = rect.left;
+          var y = rect.top;
+          var startRow = y / gridSize | 0;
+          var startCol = x / gridSize | 0;
+          var endRow = (y + rect.height) / gridSize | 0;
+          var endCol = (x + rect.width) / gridSize | 0;
           for (var row = startRow; row <= endRow; row++) {
             grid.cells[row] = grid.cells[row] || [];
             for (var col = startCol; col <= endCol; col++) {
@@ -21109,23 +21539,19 @@
         });
       }
       function createGrid() {
-        var rootGrid = {
+        var root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
+        var rootGrid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
           container: null,
           cells: []
         };
-        axe.utils.querySelectorAll(axe._tree[0], '*').filter(function(vNode) {
-          return vNode.actualNode.parentElement !== document.head;
-        }).forEach(function(vNode) {
-          if (vNode.actualNode.nodeType !== window.Node.ELEMENT_NODE) {
-            return;
-          }
-          vNode._stackingOrder = getStackingOrder(vNode);
-          var rect = vNode.boundingClientRect;
-          if (rect.width === 0 || rect.height === 0) {
-            return;
-          }
-          var scrollRegionParent = findScrollRegionParent(vNode);
-          var grid = scrollRegionParent ? scrollRegionParent._subGrid : rootGrid;
+        var parentVNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+        if (!parentVNode) {
+          var vNode = axe.utils.getNodeFromTree(document.documentElement);
+          if (!vNode) {
+            vNode = new VirtualNode(document.documentElement);
+          }
+          vNode._stackingOrder = [ 0 ];
+          addNodeToGrid(rootGrid, vNode);
           if (axe.utils.getScroll(vNode.actualNode)) {
             var subGrid = {
               container: vNode,
@@ -21133,42 +21559,104 @@
             };
             vNode._subGrid = subGrid;
           }
-          addNodeToGrid(grid, vNode);
+        }
+        var treeWalker = document.createTreeWalker(root, window.NodeFilter.SHOW_ELEMENT, null, false);
+        var node = parentVNode ? treeWalker.nextNode() : treeWalker.currentNode;
+        while (node) {
+          var _vNode = axe.utils.getNodeFromTree(node);
+          if (node.parentElement) {
+            parentVNode = axe.utils.getNodeFromTree(node.parentElement);
+          } else if (node.parentNode && axe.utils.getNodeFromTree(node.parentNode)) {
+            parentVNode = axe.utils.getNodeFromTree(node.parentNode);
+          }
+          if (!_vNode) {
+            _vNode = new VirtualNode(node, parentVNode);
+          }
+          _vNode._stackingOrder = getStackingOrder(_vNode, parentVNode);
+          var scrollRegionParent = findScrollRegionParent(_vNode, parentVNode);
+          var grid = scrollRegionParent ? scrollRegionParent._subGrid : rootGrid;
+          if (axe.utils.getScroll(_vNode.actualNode)) {
+            var _subGrid = {
+              container: _vNode,
+              cells: []
+            };
+            _vNode._subGrid = _subGrid;
+          }
+          var rect = _vNode.boundingClientRect;
+          if (rect.width !== 0 && rect.height !== 0 && dom.isVisible(node)) {
+            addNodeToGrid(grid, _vNode);
+          }
+          if (axe.utils.isShadowRoot(node)) {
+            createGrid(node.shadowRoot, grid, _vNode);
+          }
+          node = treeWalker.nextNode();
+        }
+      }
+      function getRectStack(grid, rect) {
+        var recursed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        var x = rect.left + rect.width / 2;
+        var y = rect.top + rect.height / 2;
+        var row = y / gridSize | 0;
+        var col = x / gridSize | 0;
+        var stack = grid.cells[row][col].filter(function(gridCellNode) {
+          return gridCellNode.clientRects.find(function(clientRect) {
+            var rectX = clientRect.left;
+            var rectY = clientRect.top;
+            return x <= rectX + clientRect.width && x >= rectX && y <= rectY + clientRect.height && y >= rectY;
+          });
         });
+        var gridContainer = grid.container;
+        if (gridContainer) {
+          stack = getRectStack(gridContainer._grid, gridContainer.boundingClientRect, true).concat(stack);
+        }
+        if (!recursed) {
+          stack = stack.sort(visuallySort).map(function(vNode) {
+            return vNode.actualNode;
+          }).concat(document.documentElement).filter(function(node, index, array) {
+            return array.indexOf(node) === index;
+          });
+        }
+        return stack;
       }
-      dom.getElementStack = function(vNode) {
-        var recursed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      dom.getElementStack = function(node) {
         if (!axe._cache.get('gridCreated')) {
           createGrid();
           axe._cache.set('gridCreated', true);
         }
+        var vNode = axe.utils.getNodeFromTree(node);
         var grid = vNode._grid;
         if (!grid) {
           return [];
         }
-        var boundingRect = vNode.boundingClientRect;
-        var x = getDomPosition(boundingRect, 'x') + boundingRect.width / 2;
-        var y = getDomPosition(boundingRect, 'y') + boundingRect.height / 2;
-        var row = Math.floor(y / gridSize);
-        var col = Math.floor(x / gridSize);
-        var stack = grid.cells[row][col].filter(function(gridCellNode) {
-          return gridCellNode.clientRects.find(function(rect) {
-            var pointX = x;
-            var pointY = y;
-            var rectWidth = rect.width;
-            var rectHeight = rect.height;
-            var rectX = getDomPosition(rect, 'x');
-            var rectY = getDomPosition(rect, 'y');
-            return pointX < rectX + rectWidth && pointX > rectX && pointY < rectY + rectHeight && pointY > rectY;
-          });
-        });
-        if (grid.container) {
-          stack = dom.getElementStack(grid.container, true).concat(stack);
+        return getRectStack(grid, vNode.boundingClientRect);
+      };
+      dom.getTextElementStack = function(node) {
+        if (!axe._cache.get('gridCreated')) {
+          createGrid();
+          axe._cache.set('gridCreated', true);
         }
-        if (!recursed) {
-          stack.sort(visuallySort);
+        var vNode = axe.utils.getNodeFromTree(node);
+        var grid = vNode._grid;
+        if (!grid) {
+          return [];
         }
-        return stack;
+        var clientRects = [];
+        Array.from(node.childNodes).forEach(function(elm) {
+          if (elm.nodeType === 3 && axe.commons.text.sanitize(elm.textContent) !== '') {
+            var range = document.createRange();
+            range.selectNodeContents(elm);
+            var rects = range.getClientRects();
+            for (var i = 0; i < rects.length; i++) {
+              var rect = rects[i];
+              if (rect.width >= 1 && rect.height >= 1) {
+                clientRects.push(rect);
+              }
+            }
+          }
+        });
+        return clientRects.map(function(rect) {
+          return getRectStack(grid, rect);
+        });
       };
       dom.getRootNode = axe.utils.getRootNode;
       dom.getScrollOffset = function(element) {
@@ -21222,8 +21710,8 @@
       var hiddenTextElms = [ 'HEAD', 'TITLE', 'TEMPLATE', 'SCRIPT', 'STYLE', 'IFRAME', 'OBJECT', 'VIDEO', 'AUDIO', 'NOSCRIPT' ];
       function hasChildTextNodes(elm) {
         if (!hiddenTextElms.includes(elm.actualNode.nodeName.toUpperCase())) {
-          return elm.children.some(function(_ref35) {
-            var actualNode = _ref35.actualNode;
+          return elm.children.some(function(_ref38) {
+            var actualNode = _ref38.actualNode;
             return actualNode.nodeType === 3 && actualNode.nodeValue.trim();
           });
         }
@@ -21282,9 +21770,12 @@
 
          case 'TEXTAREA':
          case 'SELECT':
-         case 'DETAILS':
+         case 'SUMMARY':
          case 'BUTTON':
           return true;
+
+         case 'DETAILS':
+          return !el.querySelector('summary');
         }
         return false;
       };
@@ -21400,6 +21891,66 @@
         linkText = axe.commons.text.sanitize(linkText);
         return parentText.length > linkText.length;
       };
+      dom.isModalOpen = function isModalOpen(options) {
+        options = options || {};
+        var modalPercent = options.modalPercent || .75;
+        if (axe._cache.get('isModalOpen')) {
+          return axe._cache.get('isModalOpen');
+        }
+        var definiteModals = axe.utils.querySelectorAllFilter(axe._tree[0], 'dialog, [role=dialog], [aria-modal=true]', function(vNode) {
+          return dom.isVisible(vNode.actualNode);
+        });
+        if (definiteModals.length) {
+          axe._cache.set('isModalOpen', true);
+          return true;
+        }
+        var viewport = dom.getViewportSize(window);
+        var percentWidth = viewport.width * modalPercent;
+        var percentHeight = viewport.height * modalPercent;
+        var x = (viewport.width - percentWidth) / 2;
+        var y = (viewport.height - percentHeight) / 2;
+        var points = [ {
+          x: x,
+          y: y
+        }, {
+          x: viewport.width - x,
+          y: y
+        }, {
+          x: viewport.width / 2,
+          y: viewport.height / 2
+        }, {
+          x: x,
+          y: viewport.height - y
+        }, {
+          x: viewport.width - x,
+          y: viewport.height - y
+        } ];
+        var stacks = points.map(function(point) {
+          return Array.from(document.elementsFromPoint(point.x, point.y));
+        });
+        var _loop3 = function _loop3(i) {
+          var modalElement = stacks[i].find(function(elm) {
+            var style = window.getComputedStyle(elm);
+            return parseInt(style.width, 10) >= percentWidth && parseInt(style.height, 10) >= percentHeight && style.getPropertyValue('pointer-events') !== 'none' && (style.position === 'absolute' || style.position === 'fixed');
+          });
+          if (modalElement && stacks.every(function(stack) {
+            return stack.includes(modalElement);
+          })) {
+            axe._cache.set('isModalOpen', true);
+            return {
+              v: true
+            };
+          }
+        };
+        for (var i = 0; i < stacks.length; i++) {
+          var _ret3 = _loop3(i);
+          if (_typeof(_ret3) === 'object') {
+            return _ret3.v;
+          }
+        }
+        axe._cache.set('isModalOpen', undefined);
+        return undefined;
+      };
       dom.isNode = function(element) {
         'use strict';
         return element instanceof Node;
@@ -21482,6 +22033,28 @@
         }
         return false;
       }
+      function isAreaVisible(el, screenReader, recursed) {
+        var mapEl = dom.findUp(el, 'map');
+        if (!mapEl) {
+          return false;
+        }
+        var mapElName = mapEl.getAttribute('name');
+        if (!mapElName) {
+          return false;
+        }
+        var mapElRootNode = dom.getRootNode(el);
+        if (!mapElRootNode || mapElRootNode.nodeType !== 9) {
+          return false;
+        }
+        var refs = axe.utils.querySelectorAll(axe._tree, 'img[usemap="#'.concat(axe.utils.escapeSelector(mapElName), '"]'));
+        if (!refs || !refs.length) {
+          return false;
+        }
+        return refs.some(function(_ref39) {
+          var actualNode = _ref39.actualNode;
+          return dom.isVisible(actualNode, screenReader, recursed);
+        });
+      }
       dom.isVisible = function(el, screenReader, recursed) {
         'use strict';
         var node = axe.utils.getNodeFromTree(el);
@@ -21500,9 +22073,12 @@
           return false;
         }
         var nodeName = el.nodeName.toUpperCase();
-        if (style.getPropertyValue('display') === 'none' || [ 'STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE' ].includes(nodeName) || !screenReader && isClipped(style) || !recursed && (style.getPropertyValue('visibility') === 'hidden' || !screenReader && dom.isOffscreen(el)) || screenReader && el.getAttribute('aria-hidden') === 'true') {
+        if (nodeName !== 'AREA' && style.getPropertyValue('display') === 'none' || [ 'STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE' ].includes(nodeName) || !screenReader && isClipped(style) || !recursed && (style.getPropertyValue('visibility') === 'hidden' || !screenReader && dom.isOffscreen(el)) || screenReader && el.getAttribute('aria-hidden') === 'true') {
           return false;
         }
+        if (nodeName === 'AREA') {
+          return isAreaVisible(el, screenReader, recursed);
+        }
         var parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
         var isVisible = false;
         if (parent) {
@@ -21564,7 +22140,88 @@
           return stack;
         }, []);
       };
-      dom.visuallyContains = function(node, parent) {
+      dom.urlPropsFromAttribute = function urlPropsFromAttribute(node, attribute) {
+        var value = node[attribute];
+        if (!value) {
+          return undefined;
+        }
+        var nodeName = node.nodeName.toUpperCase();
+        var parser = node;
+        if (![ 'A', 'AREA' ].includes(nodeName)) {
+          parser = document.createElement('a');
+          parser.href = value;
+        }
+        var protocol = [ 'https:', 'ftps:' ].includes(parser.protocol) ? parser.protocol.replace(/s:$/, ':') : parser.protocol;
+        var _getPathnameOrFilenam = getPathnameOrFilename(parser.pathname), pathname = _getPathnameOrFilenam.pathname, filename = _getPathnameOrFilenam.filename;
+        return {
+          protocol: protocol,
+          hostname: parser.hostname,
+          port: getPort(parser.port),
+          pathname: /\/$/.test(pathname) ? pathname : ''.concat(pathname, '/'),
+          search: getSearchPairs(parser.search),
+          hash: getHashRoute(parser.hash),
+          filename: filename
+        };
+      };
+      function getPort(port) {
+        var excludePorts = [ '443', '80' ];
+        return !excludePorts.includes(port) ? port : '';
+      }
+      function getPathnameOrFilename(pathname) {
+        var filename = pathname.split('/').pop();
+        if (!filename || filename.indexOf('.') === -1) {
+          return {
+            pathname: pathname,
+            filename: ''
+          };
+        }
+        return {
+          pathname: pathname.replace(filename, ''),
+          filename: /index./.test(filename) ? '' : filename
+        };
+      }
+      function getSearchPairs(searchStr) {
+        var query = {};
+        if (!searchStr || !searchStr.length) {
+          return query;
+        }
+        var pairs = searchStr.substring(1).split('&');
+        if (!pairs || !pairs.length) {
+          return query;
+        }
+        for (var index = 0; index < pairs.length; index++) {
+          var pair = pairs[index];
+          var _pair$split = pair.split('='), _pair$split2 = _slicedToArray(_pair$split, 2), key = _pair$split2[0], _pair$split2$ = _pair$split2[1], value = _pair$split2$ === void 0 ? '' : _pair$split2$;
+          query[decodeURIComponent(key)] = decodeURIComponent(value);
+        }
+        return query;
+      }
+      function getHashRoute(hash) {
+        if (!hash) {
+          return '';
+        }
+        var hashRegex = /#!?\/?/g;
+        var hasMatch = hash.match(hashRegex);
+        if (!hasMatch) {
+          return '';
+        }
+        var _hasMatch = _slicedToArray(hasMatch, 1), matchedStr = _hasMatch[0];
+        if (matchedStr === '#') {
+          return '';
+        }
+        return hash;
+      }
+      function getScrollAncestor(node) {
+        var vNode = axe.utils.getNodeFromTree(node);
+        var ancestor = vNode.parent;
+        while (ancestor) {
+          if (axe.utils.getScroll(ancestor.actualNode)) {
+            return ancestor.actualNode;
+          }
+          ancestor = ancestor.parent;
+        }
+      }
+      function contains(node, parent) {
         var rectBound = node.getBoundingClientRect();
         var margin = .01;
         var rect = {
@@ -21593,6 +22250,17 @@
           return style.overflow === 'scroll' || style.overflow === 'auto' || style.overflow === 'hidden' || parent instanceof HTMLBodyElement || parent instanceof HTMLHtmlElement;
         }
         return true;
+      }
+      dom.visuallyContains = function visuallyContains(node, parent) {
+        var parentScrollAncestor = getScrollAncestor(parent);
+        do {
+          var nextScrollAncestor = getScrollAncestor(node);
+          if (nextScrollAncestor === parentScrollAncestor || nextScrollAncestor === parent) {
+            return contains(node, parent);
+          }
+          node = nextScrollAncestor;
+        } while (node);
+        return false;
       };
       dom.visuallyOverlaps = function(rect, parent) {
         var parentRect = parent.getBoundingClientRect();
@@ -21647,25 +22315,29 @@
         var nodeName = node.nodeName.toUpperCase();
         return nodeName === 'TEXTAREA' || nodeName === 'INPUT' && !nonTextInputTypes.includes(node.type);
       };
-      matches.attributes = function matchesAttributes(node, matcher) {
-        node = node.actualNode || node;
+      matches.attributes = function matchesAttributes(vNode, matcher) {
+        if (!(vNode instanceof axe.AbstractVirtualNode)) {
+          vNode = axe.utils.getNodeFromTree(vNode);
+        }
         return matches.fromFunction(function(attrName) {
-          return node.getAttribute(attrName);
+          return vNode.attr(attrName);
         }, matcher);
       };
       matches.condition = function(arg, condition) {
         return !!condition(arg);
       };
       var matchers = [ 'nodeName', 'attributes', 'properties', 'condition' ];
-      matches.fromDefinition = function matchFromDefinition(node, definition) {
-        node = node.actualNode || node;
+      matches.fromDefinition = function matchFromDefinition(vNode, definition) {
+        if (!(vNode instanceof axe.AbstractVirtualNode)) {
+          vNode = axe.utils.getNodeFromTree(vNode);
+        }
         if (Array.isArray(definition)) {
           return definition.some(function(definitionItem) {
-            return matches(node, definitionItem);
+            return matches(vNode, definitionItem);
           });
         }
         if (typeof definition === 'string') {
-          return axe.utils.matchesSelector(node, definition);
+          return axe.utils.matches(vNode, definition);
         }
         return Object.keys(definition).every(function(matcherName) {
           if (!matchers.includes(matcherName)) {
@@ -21673,7 +22345,7 @@
           }
           var matchMethod = matches[matcherName];
           var matcher = definition[matcherName];
-          return matchMethod(node, matcher);
+          return matchMethod(vNode, matcher);
         });
       };
       matches.fromFunction = function matchFromFunction(getValue, matcher) {
@@ -21698,28 +22370,19 @@
         }
         return matcher === someString;
       };
-      var isXHTMLGlobal;
-      matches.nodeName = function matchNodeName(node, matcher) {
-        var _ref36 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}, isXHTML = _ref36.isXHTML;
-        node = node.actualNode || node;
-        if (typeof isXHTML === 'undefined') {
-          if (typeof matcher === 'string') {
-            return axe.utils.matchesSelector(node, matcher);
-          }
-          if (typeof isXHTMLGlobal === 'undefined') {
-            isXHTMLGlobal = axe.utils.isXHTML(node.ownerDocument);
-          }
-          isXHTML = isXHTMLGlobal;
+      matches.nodeName = function matchNodeName(vNode, matcher) {
+        if (!(vNode instanceof axe.AbstractVirtualNode)) {
+          vNode = axe.utils.getNodeFromTree(vNode);
         }
-        var nodeName = isXHTML ? node.nodeName : node.nodeName.toLowerCase();
-        return matches.fromPrimative(nodeName, matcher);
+        return matches.fromPrimative(vNode.props.nodeName, matcher);
       };
-      matches.properties = function matchesProperties(node, matcher) {
-        node = node.actualNode || node;
-        var out = matches.fromFunction(function(propName) {
-          return node[propName];
+      matches.properties = function matchesProperties(vNode, matcher) {
+        if (!(vNode instanceof axe.AbstractVirtualNode)) {
+          vNode = axe.utils.getNodeFromTree(vNode);
+        }
+        return matches.fromFunction(function(propName) {
+          return vNode.props[propName];
         }, matcher);
-        return out;
       };
       table.getAllCells = function(tableElm) {
         var rowIndex, cellIndex, rowLength, cellLength;
@@ -22061,15 +22724,15 @@
         }
         return accName;
       };
-      function textNodeContent(_ref37) {
-        var actualNode = _ref37.actualNode;
+      function textNodeContent(_ref40) {
+        var actualNode = _ref40.actualNode;
         if (actualNode.nodeType !== 3) {
           return '';
         }
         return actualNode.textContent;
       }
-      function shouldIgnoreHidden(_ref38, context) {
-        var actualNode = _ref38.actualNode;
+      function shouldIgnoreHidden(_ref41, context) {
+        var actualNode = _ref41.actualNode;
         if (actualNode.nodeType !== 1 || context.includeHidden) {
           return false;
         }
@@ -22297,7 +22960,7 @@
       };
       text.autocomplete = autocomplete;
       text.isValidAutocomplete = function isValidAutocomplete(autocomplete) {
-        var _ref39 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, _ref39$looseTyped = _ref39.looseTyped, looseTyped = _ref39$looseTyped === void 0 ? false : _ref39$looseTyped, _ref39$stateTerms = _ref39.stateTerms, stateTerms = _ref39$stateTerms === void 0 ? [] : _ref39$stateTerms, _ref39$locations = _ref39.locations, locations = _ref39$locations === void 0 ? [] : _ref39$locations, _ref39$qualifiers = _ref39.qualifiers, qualifiers = _ref39$qualifiers === void 0 ? [] : _ref39$qualifiers, _ref39$standaloneTerm = _ref39.standaloneTerms, standaloneTerms = _ref39$standaloneTerm === void 0 ? [] : _ref39$standaloneTerm, _ref39$qualifiedTerms = _ref39.qualifiedTerms, qualifiedTerms = _ref39$qualifiedTerms === void 0 ? [] : _ref39$qualifiedTerms;
+        var _ref42 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, _ref42$looseTyped = _ref42.looseTyped, looseTyped = _ref42$looseTyped === void 0 ? false : _ref42$looseTyped, _ref42$stateTerms = _ref42.stateTerms, stateTerms = _ref42$stateTerms === void 0 ? [] : _ref42$stateTerms, _ref42$locations = _ref42.locations, locations = _ref42$locations === void 0 ? [] : _ref42$locations, _ref42$qualifiers = _ref42.qualifiers, qualifiers = _ref42$qualifiers === void 0 ? [] : _ref42$qualifiers, _ref42$standaloneTerm = _ref42.standaloneTerms, standaloneTerms = _ref42$standaloneTerm === void 0 ? [] : _ref42$standaloneTerm, _ref42$qualifiedTerms = _ref42.qualifiedTerms, qualifiedTerms = _ref42$qualifiedTerms === void 0 ? [] : _ref42$qualifiedTerms;
         autocomplete = autocomplete.toLowerCase().trim();
         stateTerms = stateTerms.concat(text.autocomplete.stateTerms);
         if (stateTerms.includes(autocomplete) || autocomplete === '') {
@@ -22353,8 +23016,8 @@
           return text !== '';
         }).join(' ');
       };
-      function getExplicitLabels(_ref40) {
-        var actualNode = _ref40.actualNode;
+      function getExplicitLabels(_ref43) {
+        var actualNode = _ref43.actualNode;
         if (!actualNode.id) {
           return [];
         }
@@ -22469,8 +23132,8 @@
       };
       function findTextMethods(virtualNode) {
         var nativeElementType = text.nativeElementType, nativeTextMethods = text.nativeTextMethods;
-        var nativeType = nativeElementType.find(function(_ref41) {
-          var matches = _ref41.matches;
+        var nativeType = nativeElementType.find(function(_ref44) {
+          var matches = _ref44.matches;
           return axe.commons.matches(virtualNode, matches);
         });
         var methods = nativeType ? [].concat(nativeType.namingMethods) : [];
@@ -22485,12 +23148,12 @@
         button: ''
       };
       text.nativeTextMethods = {
-        valueText: function valueText(_ref42) {
-          var actualNode = _ref42.actualNode;
+        valueText: function valueText(_ref45) {
+          var actualNode = _ref45.actualNode;
           return actualNode.value || '';
         },
-        buttonDefaultText: function buttonDefaultText(_ref43) {
-          var actualNode = _ref43.actualNode;
+        buttonDefaultText: function buttonDefaultText(_ref46) {
+          var actualNode = _ref46.actualNode;
           return defaultButtonValues[actualNode.type] || '';
         },
         tableCaptionText: descendantText.bind(null, 'caption'),
@@ -22511,12 +23174,12 @@
           return ' ';
         }
       };
-      function attrText(attr, _ref44) {
-        var actualNode = _ref44.actualNode;
+      function attrText(attr, _ref47) {
+        var actualNode = _ref47.actualNode;
         return actualNode.getAttribute(attr) || '';
       }
-      function descendantText(nodeName, _ref45, context) {
-        var actualNode = _ref45.actualNode;
+      function descendantText(nodeName, _ref48, context) {
+        var actualNode = _ref48.actualNode;
         nodeName = nodeName.toLowerCase();
         var nodeNames = [ nodeName, actualNode.nodeName.toLowerCase() ].join(',');
         var candidate = actualNode.querySelector(nodeNames);
@@ -22604,7 +23267,7 @@
         return str;
       };
       function getUnicodeNonBmpRegExp() {
-        return new RegExp('[' + '\u1d00-\u1d7f' + '\u1d80-\u1dbf' + '\u1dc0-\u1dff' + '\u20a0-\u20cf' + '\u20d0-\u20ff' + '\u2100-\u214f' + '\u2150-\u218f' + '\u2190-\u21ff' + '\u2200-\u22ff' + '\u2300-\u23ff' + '\u2400-\u243f' + '\u2440-\u245f' + '\u2460-\u24ff' + '\u2500-\u257f' + '\u2580-\u259f' + '\u25a0-\u25ff' + '\u2600-\u26ff' + '\u2700-\u27bf' + '\ue000-\uf8ff' + ']');
+        return /[\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u20A0-\u20CF\u20D0-\u20FF\u2100-\u214F\u2150-\u218F\u2190-\u21FF\u2200-\u22FF\u2300-\u23FF\u2400-\u243F\u2440-\u245F\u2460-\u24FF\u2500-\u257F\u2580-\u259F\u25A0-\u25FF\u2600-\u26FF\u2700-\u27BF\uE000-\uF8FF]/g;
       }
       function getPunctuationRegExp() {
         return /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]/g;