main repo

node_modules/axe-core/LICENSE

@@ -0,0 +1,362 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+     means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the terms of
+        a Secondary License.
+
+1.6. "Executable Form"
+
+     means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+     means a work that combines Covered Software with other material, in a
+     separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+     means this document.
+
+1.9. "Licensable"
+
+     means having the right to grant, to the maximum extent possible, whether
+     at the time of the initial grant or subsequently, any and all of the
+     rights conveyed by this License.
+
+1.10. "Modifications"
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+      means any patent claim(s), including without limitation, method,
+      process, and apparatus claims, in any patent Licensable by such
+      Contributor that would be infringed, but for the grant of the License,
+      by the making, using, selling, offering for sale, having made, import,
+      or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+      means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, "You" includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, "control" means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or
+        as part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its
+        Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution
+     become effective for each Contribution on the date the Contributor first
+     distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under
+     this License. No additional rights or licenses will be implied from the
+     distribution or licensing of Covered Software under this License.
+     Notwithstanding Section 2.1(b) above, no patent license is granted by a
+     Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party's
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of
+        its Contributions.
+
+     This License does not grant any rights in the trademarks, service marks,
+     or logos of any Contributor (except as may be necessary to comply with
+     the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this
+     License (see Section 10.2) or under the terms of a Secondary License (if
+     permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its
+     Contributions are its original creation(s) or it has sufficient rights to
+     grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under
+     applicable copyright doctrines of fair use, fair dealing, or other
+     equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under
+     the terms of this License. You must inform recipients that the Source
+     Code Form of the Covered Software is governed by the terms of this
+     License, and how they can obtain a copy of this License. You may not
+     attempt to alter or restrict the recipients' rights in the Source Code
+     Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this
+        License, or sublicense it under different terms, provided that the
+        license for the Executable Form does not attempt to limit or alter the
+        recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for
+     the Covered Software. If the Larger Work is a combination of Covered
+     Software with a work governed by one or more Secondary Licenses, and the
+     Covered Software is not Incompatible With Secondary Licenses, this
+     License permits You to additionally distribute such Covered Software
+     under the terms of such Secondary License(s), so that the recipient of
+     the Larger Work may, at their option, further distribute the Covered
+     Software under the terms of either this License or such Secondary
+     License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices
+     (including copyright notices, patent notices, disclaimers of warranty, or
+     limitations of liability) contained within the Source Code Form of the
+     Covered Software, except that You may alter any license notices to the
+     extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on
+     behalf of any Contributor. You must make it absolutely clear that any
+     such warranty, support, indemnity, or liability obligation is offered by
+     You alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute,
+   judicial order, or regulation then You must: (a) comply with the terms of
+   this License to the maximum extent possible; and (b) describe the
+   limitations and the code they affect. Such description must be placed in a
+   text file included with all distributions of the Covered Software under
+   this License. Except to the extent prohibited by statute or regulation,
+   such description must be sufficiently detailed for a recipient of ordinary
+   skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing
+     basis, if such Contributor fails to notify You of the non-compliance by
+     some reasonable means prior to 60 days after You have come back into
+     compliance. Moreover, Your grants from a particular Contributor are
+     reinstated on an ongoing basis if such Contributor notifies You of the
+     non-compliance by some reasonable means, this is the first time You have
+     received notice of non-compliance with this License from such
+     Contributor, and You become compliant prior to 30 days after Your receipt
+     of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions,
+     counter-claims, and cross-claims) alleging that a Contributor Version
+     directly or indirectly infringes any patent, then the rights granted to
+     You by any and all Contributors for the Covered Software under Section
+     2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an "as is" basis,
+   without warranty of any kind, either expressed, implied, or statutory,
+   including, without limitation, warranties that the Covered Software is free
+   of defects, merchantable, fit for a particular purpose or non-infringing.
+   The entire risk as to the quality and performance of the Covered Software
+   is with You. Should any Covered Software prove defective in any respect,
+   You (not any Contributor) assume the cost of any necessary servicing,
+   repair, or correction. This disclaimer of warranty constitutes an essential
+   part of this License. No use of  any Covered Software is authorized under
+   this License except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from
+   such party's negligence to the extent applicable law prohibits such
+   limitation. Some jurisdictions do not allow the exclusion or limitation of
+   incidental or consequential damages, so this exclusion and limitation may
+   not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts
+   of a jurisdiction where the defendant maintains its principal place of
+   business and such litigation shall be governed by laws of that
+   jurisdiction, without reference to its conflict-of-law provisions. Nothing
+   in this Section shall prevent a party's ability to bring cross-claims or
+   counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject
+   matter hereof. If any provision of this License is held to be
+   unenforceable, such provision shall be reformed only to the extent
+   necessary to make it enforceable. Any law or regulation which provides that
+   the language of a contract shall be construed against the drafter shall not
+   be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version
+      of the License under which You originally received the Covered Software,
+      or under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a
+      modified version of this License if you rename the license and remove
+      any references to the name of the license steward (except to note that
+      such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+      Licenses If You choose to distribute Source Code Form that is
+      Incompatible With Secondary Licenses under the terms of this version of
+      the License, the notice described in Exhibit B of this License must be
+      attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+      This Source Code Form is "Incompatible
+      With Secondary Licenses", as defined by
+      the Mozilla Public License, v. 2.0.

node_modules/axe-core/LICENSE-3RD-PARTY.txt

@@ -0,0 +1,66 @@
+-----------------------------------------------------------------------------
+                              MIT License
+  Applies to: 
+  - colorjs.io; Copyright (c) 2021 Lea Verou, Chris Lilley
+  - core-js-pure; Copyright (c) 2014-2023 Denis Pushkarev
+  - css-selector-parser; Copyright (c) 2013 Dulin Marat
+  - doT.js; Copyright (c) 2011 Laura Doktorova
+      Software includes portions from jQote2 Copyright (c) 2010 aefxx,
+      http://aefxx.com/ licensed under the MIT license.
+  - emoji-regex; Copyright (c) Mathias Bynens <https://mathiasbynens.be/>
+  - es6-iterator; Copyright (c) 2013-2017 Mariusz Nowak (www.medikoo.com)
+  - es6-promise;
+      Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors
+  - event-emitter; Copyright (C) 2012-2015 Mariusz Nowak (www.medikoo.com)
+  - is-promise; Copyright (c) 2014 Forbes Lindesay
+  - lru-queue; Copyright (C) 2014 Mariusz Nowak (www.medikoo.com)
+  - typedarray;
+      Copyright (c) 2010, Linden Research, Inc.
+      Copyright (c) 2012, Joshua Bell
+  - weakmap-polyfill; Copyright (c) 2015-2021 polygonplanet
+-----------------------------------------------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+-----------------------------------------------------------------------------
+                              ISC License
+  Applies to: 
+  - d; Copyright (c) 2013-2019, Mariusz Nowak, @medikoo, medikoo.com
+  - es5-ext; Copyright (c) 2011-2022, Mariusz Nowak, @medikoo, medikoo.com
+  - es6-symbol; Copyright (c) 2013-2019, Mariusz Nowak, @medikoo, medikoo.com
+  - es6-weak-map; Copyright (c) 2013-2018, Mariusz Nowak, @medikoo, medikoo.com
+  - ext; Copyright (c) 2011-2022, Mariusz Nowak, @medikoo, medikoo.com
+  - memoizee; Copyright (c) 2012-2018, Mariusz Nowak, @medikoo, medikoo.com
+  - next-tick; Copyright (c) 2012-2020, Mariusz Nowak, @medikoo, medikoo.com
+  - timers-ext; Copyright (c) 2013-2018, Mariusz Nowak, @medikoo, medikoo.com
+  - type; Copyright (c) 2019, Mariusz Nowak, @medikoo, medikoo.com
+-----------------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

node_modules/axe-core/README.md

@@ -0,0 +1,190 @@
+# axe-core
+
+[![License](https://img.shields.io/npm/l/axe-core.svg)](LICENSE)
+[![Version](https://img.shields.io/npm/v/axe-core.svg)](https://www.npmjs.com/package/axe-core)
+[![Total npm downloads](https://img.shields.io/npm/dt/axe-core.svg)](https://www.npmjs.com/package/axe-core)
+[![Commits](https://img.shields.io/github/commit-activity/y/dequelabs/axe-core.svg)](https://github.com/dequelabs/axe-core/commits/develop)
+[![GitHub contributors](https://img.shields.io/github/contributors/dequelabs/axe-core.svg)](https://github.com/dequelabs/axe-core/graphs/contributors)
+[![Join our Slack chat](https://img.shields.io/badge/slack-chat-purple.svg?logo=slack)](https://accessibility.deque.com/axe-community)
+[![Package Quality](https://npm.packagequality.com/shield/axe-core.svg)](https://packagequality.com/#?package=axe-core)
+
+Axe is an accessibility testing engine for websites and other HTML-based user interfaces. It's fast, secure, lightweight, and was built to seamlessly integrate with any existing test environment so you can automate accessibility testing alongside your regular functional testing.
+
+[Sign up for axe news](https://hubs.ly/H0fsN0b0) to get the latest on axe features, future releases, and events.
+
+## The Accessibility Rules
+
+Axe-core has different types of rules, for WCAG 2.0, 2.1, 2.2 on level A, AA and AAA as well as a number of best practices that help you identify common accessibility practices like ensuring every page has an `h1` heading, and to help you avoid "gotchas" in ARIA like where an ARIA attribute you used will get ignored. The complete list of rules, grouped WCAG level and best practice, can found in [doc/rule-descriptions.md](./doc/rule-descriptions.md).
+
+With axe-core, you can find **on average 57% of WCAG issues automatically**. Additionally, axe-core will return elements as "incomplete" where axe-core could not be certain, and manual review is needed.
+
+To catch bugs earlier in the development cycle we recommend using the [axe-linter vscode extension](https://marketplace.visualstudio.com/items?itemName=deque-systems.vscode-axe-linter). To improve test coverage even further we recommend the [intelligent guided tests](https://www.youtube.com/watch?v=AtsX0dPCG_4&feature=youtu.be&ab_channel=DequeSystems) in the [axe Extension](https://www.deque.com/axe/browser-extensions/).
+
+## Getting started
+
+First download the package:
+
+```console
+npm install axe-core --save-dev
+```
+
+Now include the javascript file in each of your iframes in your fixtures or test systems:
+
+```html
+<script src="node_modules/axe-core/axe.min.js"></script>
+```
+
+Now insert calls at each point in your tests where a new piece of UI becomes visible or exposed:
+
+```js
+axe
+  .run()
+  .then(results => {
+    if (results.violations.length) {
+      throw new Error('Accessibility issues found');
+    }
+  })
+  .catch(err => {
+    console.error('Something bad happened:', err.message);
+  });
+```
+
+## Philosophy
+
+The web can only become an accessible, inclusive space if developers are empowered to take responsibility for accessibility testing and accessible coding practices.
+
+Automated accessibility testing is a huge timesaver, it doesn't require special expertise, and it allows teams to focus expert resources on the accessibility issues that really need them. Unfortunately, most accessibility tools are meant to be run on sites and applications that have reached the end of the development process and often don't give clear or consistent results, causing frustration and delays just when you thought your product was ready to ship.
+
+Axe was built to reflect how web development actually works. It works with all modern browsers, tools, and testing environments a dev team might use. With axe, accessibility testing can be performed as part of your unit testing, integration testing, browser testing, and any other functional testing your team already performs on a day-to-day basis. Building accessibility testing into the early development process saves time, resources, and all kinds of frustration.
+
+## About axe - our Manifesto
+
+- Axe is open source.
+- It returns zero false positives (bugs notwithstanding).
+- It's designed to work on all modern browsers and with whatever tools, frameworks, libraries and environments you use today.
+- It's actively supported by [Deque Systems](https://www.deque.com), a major accessibility vendor.
+- It integrates with your existing functional/acceptance automated tests.
+- It automatically determines which rules to run based on the evaluation context.
+- Axe supports in-memory fixtures, static fixtures, integration tests and iframes of infinite depth.
+- Axe is highly configurable.
+
+## Supported Browsers
+
+The [axe-core API](doc/API.md) fully supports the following browsers:
+
+- Microsoft Edge v40 and above
+- Google Chrome v42 and above
+- Mozilla Firefox v38 and above
+- Apple Safari v7 and above
+- Internet Explorer v11 (DEPRECATED)
+
+Support means that we will fix bugs and attempt to test each browser regularly. Only Chrome and Firefox are currently tested on every pull request.
+
+There is limited support for JSDOM. We will attempt to make all rules compatible with JSDOM but where this is not possible, we recommend turning those rules off. Currently the `color-contrast` rule is known not to work with JSDOM.
+
+We can only support environments where features are either natively supported or polyfilled correctly. We do not support the deprecated v0 Shadow DOM implementation.
+
+## Contents of the API Package
+
+The [axe-core API](doc/API.md) package consists of:
+
+- `axe.js` - the JavaScript file that should be included in your web site under test (API)
+- `axe.min.js` - a minified version of the above file
+
+## Localization
+
+Axe can be built using your local language. To do so, a localization file must be added to the `./locales` directory. This file must be named in the following manner: `<langcode>.json`. To build axe using this locale, instead of the default, run axe with the `--lang` flag, like so:
+
+`grunt build --lang=nl`
+
+or equivalently:
+
+`npm run build -- --lang=nl`
+
+This will create a new build for axe, called `axe.<lang>.js` and `axe.<lang>.min.js`. If you want to build all localized versions, simply pass in `--all-lang` instead. If you want to build multiple localized versions (but not all of them), you can pass in a comma-separated list of languages to the `--lang` flag, like `--lang=nl,ja`.
+
+To create a new translation for axe, start by running `grunt translate --lang=<langcode>`. This will create a json file in the `./locales` directory, with the default English text in it for you to translate. Alternatively, you could copy `./locales/_template.json`. We welcome any localization for axe-core. For details on how to contribute, see the Contributing section below. For details on the message syntax, see [Check Message Template](/doc/check-message-template.md).
+
+To update an existing translation file, re-run `grunt translate --lang=<langcode>`. This will add new messages used in English and remove messages which were not used in English.
+
+Additionally, locale can be applied at runtime by passing a `locale` object to `axe.configure()`. The locale object must be of the same shape as existing locales in the `./locales` directory. For example:
+
+```js
+axe.configure({
+  locale: {
+    lang: 'de',
+    rules: {
+      accesskeys: {
+        help: 'Der Wert des accesskey-Attributes muss einzigartig sein.'
+      }
+      // ...
+    },
+    checks: {
+      abstractrole: {
+        fail: 'Abstrakte ARIA-Rollen dürfen nicht direkt verwendet werden.'
+      },
+      'aria-errormessage': {
+        // Note: doT (https://github.com/olado/dot) templates are supported here.
+        fail: 'Der Wert der aria-errormessage ${data.values}` muss eine Technik verwenden, um die Message anzukündigen (z. B., aria-live, aria-describedby, role=alert, etc.).'
+      }
+      // ...
+    }
+  }
+});
+```
+
+### Supported Locales
+
+Axe-core supports the following locales. Do note that since locales are contributed by our community, they are not guaranteed to include all translations needed in a release.
+
+- Basque
+- Danish
+- Dutch
+- French
+- German
+- Hebrew
+- Japanese
+- Korean
+- Norwegian (Bokmål)
+- Polish
+- Portuguese (Brazilian)
+- Spanish
+- Greek
+- Italian
+- Simplified Chinese
+- Traditional Chinese
+
+## Updates & Security
+
+Axe-core has a new minor release every 3 to 5 months, which usually introduces new rules and features. We recommend scheduling time to upgrade to these versions. Security updates will be made available for minor version lines up to **18 months old**.
+
+- See [release and support](doc/release-and-support.md) for details on the frequency of releases, long-term support and recommendations on upgrading axe-core.
+- See [backward compatibility](doc/backwards-compatibility-doc.md) for details on the types of changes different releases may introduce.
+
+## Deque Trademarks Policy
+
+DEQUE, DEQUELABS, AXE®, and AXE-CORE® are trademarks of Deque Systems, Inc. Use of the Deque trademarks must be in accordance with [Deque's trademark policy](https://www.deque.com/legal/trademarks/).
+
+## Supported ARIA Roles and Attributes.
+
+Refer [axe-core ARIA support](./doc/aria-supported.md) for a complete list of ARIA supported roles and attributes by axe.
+
+## Contributing
+
+Read the [Proposing Axe-core Rules guide](./doc/rule-proposal.md)
+
+Read the [documentation on the architecture](./doc/developer-guide.md)
+
+Read the [documentation on contributing](CONTRIBUTING.md)
+
+## Projects using axe-core
+
+[List of projects using axe-core](doc/projects.md)
+
+## Acknowledgements
+
+Thanks to Marat Dulin for his [css-selector-parser](https://www.npmjs.com/package/css-selector-parser) implementation which is included for shadow DOM support. Another thank you to the [Slick Parser](https://github.com/mootools/slick/blob/master/Source/Slick.Parser.js) implementers for their contribution, we have used some of their algorithms in our shadow DOM support code. Thanks to Lea Verou and Chris Lilley for their [colorjs.io](https://colorjs.io/) library which we have used for converting between color formats.
+
+## Licenses
+
+Axe-core is distributed under the [Mozilla Public License, version 2.0](LICENSE). It comes bundled with several dependencies which are distributed under their own terms. (See [LICENSE-3RD-PARTY.txt](LICENSE-3RD-PARTY.txt))

node_modules/axe-core/axe.d.ts

@@ -0,0 +1,624 @@
+// Type definitions for axe-core
+// Project: https://github.com/dequelabs/axe-core
+
+declare namespace axe {
+  type ImpactValue = 'minor' | 'moderate' | 'serious' | 'critical' | null;
+
+  type TagValue = string;
+
+  type ReporterVersion = 'v1' | 'v2' | 'raw' | 'rawEnv' | 'no-passes';
+
+  type RunOnlyType = 'rule' | 'rules' | 'tag' | 'tags';
+
+  type resultGroups = 'inapplicable' | 'passes' | 'incomplete' | 'violations';
+
+  type AriaAttrsType =
+    | 'boolean'
+    | 'nmtoken'
+    | 'mntokens'
+    | 'idref'
+    | 'idrefs'
+    | 'string'
+    | 'decimal'
+    | 'int';
+
+  type AriaRolesType = 'abstract' | 'widget' | 'structure' | 'landmark';
+
+  type DpubRolesType =
+    | 'section'
+    | 'landmark'
+    | 'link'
+    | 'listitem'
+    | 'img'
+    | 'navigation'
+    | 'note'
+    | 'separator'
+    | 'none'
+    | 'sectionhead';
+
+  type HtmlContentTypes =
+    | 'flow'
+    | 'sectioning'
+    | 'heading'
+    | 'phrasing'
+    | 'embedded'
+    | 'interactive';
+
+  // Array of length 2 or greater
+  type MultiArray<T> = [T, T, ...T[]];
+
+  // Selectors within a frame
+  type BaseSelector = string;
+
+  type ShadowDomSelector = MultiArray<BaseSelector>;
+  type CrossTreeSelector = BaseSelector | ShadowDomSelector;
+  type LabelledShadowDomSelector = { fromShadowDom: ShadowDomSelector };
+
+  // Cross-frame selectors
+  type FramesSelector = Array<CrossTreeSelector | LabelledShadowDomSelector>;
+  type UnlabelledFrameSelector = CrossTreeSelector[];
+  type LabelledFramesSelector = { fromFrames: MultiArray<FramesSelector[0]> };
+  /**
+   * @deprecated Use UnlabelledFrameSelector instead
+   */
+  type CrossFrameSelector = UnlabelledFrameSelector;
+
+  // Context options
+  type Selector =
+    | Node
+    | BaseSelector
+    | LabelledShadowDomSelector
+    | LabelledFramesSelector;
+  type SelectorList = Array<Selector | FramesSelector> | NodeList;
+  type ContextProp = Selector | SelectorList;
+  type ContextObject =
+    | {
+        include: ContextProp;
+        exclude?: ContextProp;
+      }
+    | {
+        exclude: ContextProp;
+        include?: ContextProp;
+      };
+  type ContextSpec = ContextProp | ContextObject;
+  /** Synonym to ContextSpec */
+  type ElementContext = ContextSpec;
+
+  type SerialSelector =
+    | BaseSelector
+    | LabelledShadowDomSelector
+    | LabelledFramesSelector;
+  type SerialFrameSelector = SerialSelector | FramesSelector;
+  type SerialSelectorList = Array<SerialFrameSelector>;
+
+  type SerialContextObject =
+    | {
+        include: SerialSelector | SerialSelectorList;
+        exclude?: SerialSelector | SerialSelectorList;
+      }
+    | {
+        exclude: SerialSelector | SerialSelectorList;
+        include?: SerialSelector | SerialSelectorList;
+      };
+
+  interface FrameContextObject {
+    include: UnlabelledFrameSelector[];
+    exclude: UnlabelledFrameSelector[];
+  }
+
+  type RunCallback<T = AxeResults> = (error: Error, results: T) => void;
+
+  interface TestEngine {
+    name: string;
+    version: string;
+  }
+  interface TestRunner {
+    name: string;
+  }
+  interface TestEnvironment {
+    userAgent: string;
+    windowWidth: number;
+    windowHeight: number;
+    orientationAngle?: number;
+    orientationType?: string;
+  }
+  interface RunOnly {
+    type: RunOnlyType;
+    values: TagValue[] | string[];
+  }
+  interface RuleObject {
+    [key: string]: {
+      enabled: boolean;
+    };
+  }
+  interface RunOptions {
+    runOnly?: RunOnly | TagValue[] | string[] | string;
+    rules?: RuleObject;
+    reporter?: ReporterVersion | string;
+    resultTypes?: resultGroups[];
+    selectors?: boolean;
+    ancestry?: boolean;
+    xpath?: boolean;
+    absolutePaths?: boolean;
+    iframes?: boolean;
+    elementRef?: boolean;
+    frameWaitTime?: number;
+    preload?: boolean;
+    performanceTimer?: boolean;
+    pingWaitTime?: number;
+  }
+  interface AxeResults extends EnvironmentData {
+    toolOptions: RunOptions;
+    passes: Result[];
+    violations: Result[];
+    incomplete: Result[];
+    inapplicable: Result[];
+  }
+  interface Result {
+    description: string;
+    help: string;
+    helpUrl: string;
+    id: string;
+    impact?: ImpactValue;
+    tags: TagValue[];
+    nodes: NodeResult[];
+  }
+  interface NodeResult {
+    html: string;
+    impact?: ImpactValue;
+    target: UnlabelledFrameSelector;
+    xpath?: string[];
+    ancestry?: UnlabelledFrameSelector;
+    any: CheckResult[];
+    all: CheckResult[];
+    none: CheckResult[];
+    failureSummary?: string;
+    element?: HTMLElement;
+  }
+  interface CheckResult {
+    id: string;
+    impact: string;
+    message: string;
+    data: any;
+    relatedNodes?: RelatedNode[];
+  }
+  interface RelatedNode {
+    html: string;
+    target: UnlabelledFrameSelector;
+    xpath?: string[];
+    ancestry?: UnlabelledFrameSelector;
+    element?: HTMLElement;
+  }
+  interface RuleLocale {
+    [key: string]: {
+      description: string;
+      help: string;
+    };
+  }
+  interface CheckMessages {
+    pass: string | { [key: string]: string };
+    fail: string | { [key: string]: string };
+    incomplete?: string | { [key: string]: string };
+  }
+  interface CheckLocale {
+    [key: string]: CheckMessages;
+  }
+  interface Locale {
+    lang?: string;
+    rules?: RuleLocale;
+    checks?: CheckLocale;
+  }
+  interface AriaAttrs {
+    type: AriaAttrsType;
+    values?: string[];
+    allowEmpty?: boolean;
+    global?: boolean;
+    unsupported?: boolean;
+  }
+  interface AriaRoles {
+    type: AriaRolesType | DpubRolesType;
+    requiredContext?: string[];
+    requiredOwned?: string[];
+    requiredAttrs?: string[];
+    allowedAttrs?: string[];
+    nameFromContent?: boolean;
+    unsupported?: boolean;
+  }
+  interface HtmlElmsVariant {
+    contentTypes?: HtmlContentTypes[];
+    allowedRoles: boolean | string[];
+    noAriaAttrs?: boolean;
+    shadowRoot?: boolean;
+    implicitAttrs?: { [key: string]: string };
+    namingMethods?: string[];
+  }
+  interface HtmlElms extends HtmlElmsVariant {
+    variant?: { [key: string]: HtmlElmsVariant };
+  }
+  interface Standards {
+    ariaAttrs?: { [key: string]: AriaAttrs };
+    ariaRoles?: { [key: string]: AriaRoles };
+    htmlElms?: { [key: string]: HtmlElms };
+    cssColors?: { [key: string]: number[] };
+  }
+  interface Spec {
+    branding?: string | Branding;
+    reporter?: ReporterVersion | string | AxeReporter;
+    checks?: Check[];
+    rules?: Rule[];
+    standards?: Standards;
+    locale?: Locale;
+    disableOtherRules?: boolean;
+    axeVersion?: string;
+    noHtml?: boolean;
+    allowedOrigins?: string[];
+    // Deprecated - do not use.
+    ver?: string;
+  }
+  /**
+   * @deprecated Use branding: string instead to set the application key in help URLs
+   */
+  interface Branding {
+    brand?: string;
+    application?: string;
+  }
+  interface CheckHelper {
+    async: () => (result: boolean | undefined | Error) => void;
+    data: (data: unknown) => void;
+    relatedNodes: (nodes: Element[]) => void;
+  }
+  interface AfterResult {
+    id: string;
+    data?: unknown;
+    relatedNodes: SerialDqElement[];
+    result: boolean | undefined;
+    node: SerialDqElement;
+  }
+  interface Check {
+    id: string;
+    evaluate?:
+      | string
+      | ((
+          this: CheckHelper,
+          node: Element,
+          options: unknown,
+          virtualNode: VirtualNode
+        ) => boolean | undefined | void);
+    after?:
+      | string
+      | ((results: AfterResult[], options: unknown) => AfterResult[]);
+    options?: any;
+    matches?: string;
+    enabled?: boolean;
+    metadata?: {
+      impact?: ImpactValue;
+      messages?: CheckMessages;
+    };
+  }
+  interface Rule {
+    id: string;
+    selector?: string;
+    impact?: ImpactValue;
+    excludeHidden?: boolean;
+    enabled?: boolean;
+    pageLevel?: boolean;
+    any?: string[];
+    all?: string[];
+    none?: string[];
+    tags?: string[];
+    matches?: string | ((node: Element, virtualNode: VirtualNode) => boolean);
+    reviewOnFail?: boolean;
+    actIds?: string[];
+    metadata?: Omit<RuleMetadata, 'ruleId' | 'tags' | 'actIds'>;
+  }
+  interface AxePlugin {
+    id: string;
+    run(...args: any[]): any;
+    commands: {
+      id: string;
+      callback(...args: any[]): void;
+    }[];
+    cleanup?(callback: Function): void;
+  }
+  interface RuleMetadata {
+    ruleId: string;
+    description: string;
+    help: string;
+    helpUrl: string;
+    tags: string[];
+    actIds?: string[];
+  }
+  interface SerialDqElement {
+    source: string;
+    nodeIndexes: number[];
+    selector: UnlabelledFrameSelector;
+    xpath: string[];
+    ancestry: UnlabelledFrameSelector;
+  }
+  interface DqElement extends SerialDqElement {
+    element: Element;
+    toJSON(): SerialDqElement;
+    mergeSpecs(
+      childSpec: SerialDqElement,
+      parentSpec: SerialDqElement
+    ): SerialDqElement;
+  }
+  interface PartialRuleResult {
+    id: string;
+    result: 'inapplicable';
+    pageLevel: boolean;
+    impact: null;
+    nodes: Array<Record<string, unknown>>;
+  }
+  interface PartialResult {
+    frames: SerialDqElement[];
+    results: PartialRuleResult[];
+    environmentData?: EnvironmentData;
+  }
+  type PartialResults = Array<PartialResult | null>;
+  interface FrameContext {
+    frameSelector: CrossTreeSelector;
+    frameContext: FrameContextObject;
+  }
+
+  interface RawCheckResult extends Omit<CheckResult, 'relatedNodes'> {
+    relatedNodes?: Array<SerialDqElement | DqElement>;
+  }
+
+  interface RawNodeResult<T extends 'passed' | 'failed' | 'incomplete'> {
+    node: SerialDqElement | DqElement;
+    any: RawCheckResult[];
+    all: RawCheckResult[];
+    none: RawCheckResult[];
+    impact: ImpactValue | null;
+    result: T;
+  }
+
+  interface RawResult extends Omit<Result, 'nodes'> {
+    inapplicable: Array<never>;
+    passes: RawNodeResult<'passed'>[];
+    incomplete: RawNodeResult<'incomplete'>[];
+    violations: RawNodeResult<'failed'>[];
+    pageLevel: boolean;
+    result: 'failed' | 'passed' | 'incomplete' | 'inapplicable';
+  }
+
+  type AxeReporter<T = unknown> = (
+    rawResults: RawResult[],
+    option: RunOptions,
+    resolve: (report: T) => void,
+    reject: (error: Error) => void
+  ) => void;
+
+  interface VirtualNode {
+    actualNode?: Node;
+    shadowId?: string;
+    children?: VirtualNode[];
+    parent?: VirtualNode;
+    attr(attr: string): string | null;
+    hasAttr(attr: string): boolean;
+    props: { [key: string]: unknown };
+    boundingClientRect: DOMRect;
+  }
+
+  interface Utils {
+    getFrameContexts: (
+      context?: ElementContext,
+      options?: RunOptions
+    ) => FrameContext[];
+    shadowSelect: (selector: CrossTreeSelector) => Element | null;
+    shadowSelectAll: (selector: CrossTreeSelector) => Element[];
+    getStandards(): Required<Standards>;
+    isContextSpec: (context: unknown) => context is ContextSpec;
+    isContextObject: (context: unknown) => context is ContextObject;
+    isContextProp: (context: unknown) => context is ContextProp;
+    isLabelledFramesSelector: (
+      selector: unknown
+    ) => selector is LabelledFramesSelector;
+    isLabelledShadowDomSelector: (
+      selector: unknown
+    ) => selector is LabelledShadowDomSelector;
+
+    DqElement: new (
+      elm: Element,
+      options?: { absolutePaths?: boolean }
+    ) => DqElement;
+    uuid: (
+      options?: { random?: Uint8Array | Array<number> },
+      buf?: Uint8Array | Array<number>,
+      offset?: number
+    ) => string | Uint8Array | Array<number>;
+  }
+
+  interface Aria {
+    getRoleType: (role: string | Element | VirtualNode | null) => string | null;
+  }
+
+  interface Dom {
+    isFocusable: (node: Element | VirtualNode) => boolean;
+    isNativelyFocusable: (node: Element | VirtualNode) => boolean;
+  }
+
+  type AccessibleTextOptions = {
+    inControlContext?: boolean;
+    inLabelledByContext?: boolean;
+  };
+
+  interface Text {
+    accessibleText: (
+      element: Element,
+      options?: AccessibleTextOptions
+    ) => string;
+  }
+
+  interface Commons {
+    aria: Aria;
+    dom: Dom;
+    text: Text;
+  }
+
+  interface EnvironmentData {
+    testEngine: TestEngine;
+    testRunner: TestRunner;
+    testEnvironment: TestEnvironment;
+    url: string;
+    timestamp: string;
+  }
+
+  let version: string;
+  let plugins: any;
+  let utils: Utils;
+  let commons: Commons;
+
+  /**
+   * Source string to use as an injected script in Selenium
+   */
+  let source: string;
+
+  /**
+   * Object for axe Results
+   */
+  var AxeResults: AxeResults;
+
+  /**
+   * Runs a number of rules against the provided HTML page and returns the resulting issue list
+   *
+   * @param   {ElementContext} context  Optional The `Context` specification object @see Context
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   * @param   {RunCallback}    callback Optional The function to invoke when analysis is complete.
+   * @returns {Promise<AxeResults>|void} If the callback was not defined, axe will return a Promise.
+   */
+  function run<T = AxeResults>(context?: ElementContext): Promise<T>;
+  function run<T = AxeResults>(options: RunOptions): Promise<T>;
+  function run<T = AxeResults>(
+    callback: (error: Error, results: T) => void
+  ): void;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    callback: RunCallback<T>
+  ): void;
+  function run<T = AxeResults>(
+    options: RunOptions,
+    callback: RunCallback<T>
+  ): void;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    options: RunOptions
+  ): Promise<T>;
+  function run<T = AxeResults>(
+    context: ElementContext,
+    options: RunOptions,
+    callback: RunCallback<T>
+  ): void;
+
+  /**
+   * Method for configuring the data format used by axe. Helpful for adding new
+   * rules, which must be registered with the library to execute.
+   * @param  {Spec}       Spec Object with valid `branding`, `reporter`, `checks` and `rules` data
+   */
+  function configure(spec: Spec): void;
+
+  /**
+   * Run axe in the current window only
+   * @param   {ElementContext} context  Optional The `Context` specification object @see Context
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   * @returns {Promise<PartialResult>}  Partial result, for use in axe.finishRun.
+   */
+  function runPartial(
+    context: ElementContext,
+    options: RunOptions
+  ): Promise<PartialResult>;
+
+  /**
+   * Create a report from axe.runPartial results
+   * @param   {PartialResult[]}     partialResults  Results from axe.runPartial, calls in different frames on the page.
+   * @param   {RunOptions}     options  Optional Options passed into rules or checks, temporarily modifying them.
+   */
+  function finishRun(
+    partialResults: PartialResults,
+    options: RunOptions
+  ): Promise<AxeResults>;
+
+  /**
+   * Searches and returns rules that contain a tag in the list of tags.
+   * @param  {Array}  tags  Optional array of tags
+   * @return {Array}  Array of rules
+   */
+  function getRules(tags?: string[]): RuleMetadata[];
+
+  /**
+   * Restores the default axe configuration
+   */
+  function reset(): void;
+
+  /**
+   * Function to register a plugin configuration in document and its subframes
+   * @param  {Object}    plugin    A plugin configuration object
+   */
+  function registerPlugin(plugin: AxePlugin): void;
+
+  /**
+   * Function to clean up plugin configuration in document and its subframes
+   */
+  function cleanup(): void;
+
+  /**
+   * Set up alternative frame communication
+   */
+  function frameMessenger(frameMessenger: FrameMessenger): void;
+
+  /**
+   * Setup axe-core so axe.common functions can work properly.
+   */
+  function setup(node?: Element | Document): VirtualNode;
+
+  /**
+   * Clean up axe-core tree and caches. `axe.run` will call this function at the end of the run so there's no need to call it yourself afterwards.
+   */
+  function teardown(): void;
+
+  /**
+   * Check if a reporter is registered
+   */
+  function hasReporter(reporterName: string): boolean;
+
+  /**
+   * Get a reporter based the name it is registered with
+   */
+  function getReporter<T>(reporterName: string): AxeReporter<T>;
+
+  /**
+   * Register a new reporter, optionally setting it as the default
+   */
+  function addReporter<T>(
+    reporterName: string,
+    reporter: AxeReporter<T>,
+    isDefault?: boolean
+  ): void;
+
+  // axe.frameMessenger
+  type FrameMessenger = {
+    open: (topicHandler: TopicHandler) => Close | void;
+    post: (
+      frameWindow: Window,
+      data: TopicData,
+      replyHandler: ReplyHandler
+    ) => boolean | void;
+  };
+  type Close = Function;
+  type TopicHandler = (data: TopicData, responder: Responder) => void;
+  type ReplyHandler = (
+    message: any | Error,
+    keepalive: boolean,
+    responder: Responder
+  ) => void;
+  type Responder = (
+    message: any | Error,
+    keepalive?: boolean,
+    replyHandler?: ReplyHandler
+  ) => void;
+  type TopicData = { topic: string } & ReplyData;
+  type ReplyData = { channelId: string; message: any; keepalive: boolean };
+}
+
+export = axe;

node_modules/axe-core/locales/README.md

@@ -0,0 +1,9 @@
+# Localizations
+
+We welcome any localization for axe-core. For details on how to contribute, see the [Contributing section](../README.md#contributing) of the main README. For details on the message syntax, see [Check Message Template](../doc/check-message-template.md).
+
+To create a new translation for axe, start by running `grunt translate --lang=<langcode>`. This will create a json file with the default English text in it for you to translate. Alternatively, you could copy `_template.json`.
+
+To update an existing translation file, re-run `grunt translate --lang=<langcode>`. This will add new messages used in English and remove messages which were not used in English.
+
+`_template.json` is a generated file which is created every time axe is built. It's compiled using each rules' `description` and `help` properties as well as each checks' `metadata.messages` property. To update the `_template.json` file you'll need to update the corresponding [rule](../lib/rules) or [check](../lib/checks) metadata file and rebuild.

node_modules/axe-core/locales/da.json

@@ -0,0 +1,799 @@
+{
+  "lang": "da",
+  "rules": {
+    "accesskeys": {
+      "description": "",
+      "help": "Værdien for attributten 'accesskey' skal være unik"
+    },
+    "area-alt": {
+      "description": "",
+      "help": "Aktive <area> elementer skal have alternativ tekst"
+    },
+    "aria-allowed-attr": {
+      "description": "",
+      "help": "Elementer må kun bruge tilladte ARIA-attributter"
+    },
+    "aria-allowed-role": {
+      "description": "",
+      "help": "ARIA-attributten 'role' skal være passende for elementet"
+    },
+    "aria-hidden-body": {
+      "description": "",
+      "help": "aria-hidden='true' må ikke bruges på dokumentets <body> element"
+    },
+    "aria-hidden-focus": {
+      "description": "",
+      "help": "Elementer med ARIA-'hidden' må ikke indeholde fokuserbare elementer"
+    },
+    "aria-input-field-name": {
+      "description": "",
+      "help": "ARIA-input-felter skal have et tilgængeligt navn"
+    },
+    "aria-required-attr": {
+      "description": "",
+      "help": "Krævede ARIA-attributter skal være angivet"
+    },
+    "aria-required-children": {
+      "description": "",
+      "help": "Bestemte ARIA-roller skal indeholde specifikke under-elementer"
+    },
+    "aria-required-parent": {
+      "description": "",
+      "help": "Bestemte ARIA-roller skal være under-element til specifikke over-elementer"
+    },
+    "aria-roledescription": {
+      "description": "",
+      "help": "Brug 'aria-roledescription' på elementer med en semantisk rolle"
+    },
+    "aria-roles": {
+      "description": "",
+      "help": "ARIA-roller skal have en korrekt værdi"
+    },
+    "aria-toggle-field-name": {
+      "description": "",
+      "help": "ARIA afkrydsningsfelter skal have et tilgængeligt navn"
+    },
+    "aria-valid-attr-value": {
+      "description": "",
+      "help": "ARIA-attributter skal have en korrekt værdi"
+    },
+    "aria-valid-attr": {
+      "description": "",
+      "help": "ARIA-attributter skal have et korrekt navn"
+    },
+    "audio-caption": {
+      "description": "",
+      "help": "<audio> elementer skal have en transskription ('captions track')"
+    },
+    "autocomplete-valid": {
+      "description": "",
+      "help": "Attributten 'autocomplete' skal benyttes korrekt"
+    },
+    "avoid-inline-spacing": {
+      "description": "",
+      "help": "Inline tekst-afstande skal være justerbare med brugerdefinerede stylesheets"
+    },
+    "blink": {
+      "description": "",
+      "help": "Elementet <blink> er udfaset og må ikke bruges"
+    },
+    "button-name": {
+      "description": "",
+      "help": "Knapper skal have forståelig (dvs. detekterbar) tekst"
+    },
+    "bypass": {
+      "description": "",
+      "help": "Sider skal have en metode til at springe over gentaget indhold"
+    },
+    "color-contrast": {
+      "description": "",
+      "help": "Elementer skal have tilstrækkelig farvekontrast"
+    },
+    "color-contrast-enhanced": {
+      "description": "",
+      "help": "Elementer skal have tilstrækkelig farvekontrast"
+    },
+    "css-orientation-lock": {
+      "description": "",
+      "help": "'CSS Media queries' bør ikke bruges til at låse skærmretningen ('orientation')"
+    },
+    "definition-list": {
+      "description": "",
+      "help": "<dl> elementer må kun direkte indeholde velsorterede <dt> og <dd> grupper, <script> eller <template> elementer"
+    },
+    "dlitem": {
+      "description": "",
+      "help": "<dt> og <dd> elementer skal være under-element til et <dl> element"
+    },
+    "document-title": {
+      "description": "",
+      "help": "Dokumenter skal have et <title> element for at bidrage til nemmere navigation"
+    },
+    "duplicate-id-active": {
+      "description": "",
+      "help": "'id'-attributten for aktive elementer skal være unik"
+    },
+    "duplicate-id-aria": {
+      "description": "",
+      "help": "'id'-attributten brugt på ARIA-elementer og -labels skal være unik"
+    },
+    "duplicate-id": {
+      "description": "",
+      "help": "Værdien for 'id'-attributen skal være unik"
+    },
+    "empty-heading": {
+      "description": "",
+      "help": "Overskrifter må ikke være tomme"
+    },
+    "focus-order-semantics": {
+      "description": "",
+      "help": "Elementer i fokus-rækkefølgen bør have en 'role'-attribut, som er passende for det interaktive indhold"
+    },
+    "form-field-multiple-labels": {
+      "description": "",
+      "help": "Form-feltet bør ikke have flere label-elementer"
+    },
+    "frame-tested": {
+      "description": "",
+      "help": "Frame-elementer skal være testet med axe-core"
+    },
+    "frame-title-unique": {
+      "description": "",
+      "help": "Frame-elementer skal have en unik 'title'-attribut"
+    },
+    "frame-title": {
+      "description": "",
+      "help": "Frame-elementer skal have 'title'-attribut"
+    },
+    "heading-order": {
+      "description": "",
+      "help": "Overskriftsniveauer bør kun ændres sekventielt"
+    },
+    "hidden-content": {
+      "description": "",
+      "help": "Skjult indhold på siden kan ikke analyseres"
+    },
+    "html-has-lang": {
+      "description": "",
+      "help": "<html> elementet skal have en 'lang'-attribut"
+    },
+    "html-lang-valid": {
+      "description": "",
+      "help": "<html> elementet skal have en korrekt værdi for 'lang'-attributten"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "",
+      "help": "<html> elementer med 'lang' og 'xml:lang' skal have det samme basesprog"
+    },
+    "image-alt": {
+      "description": "",
+      "help": "Billeder skal have en alternativ tekst"
+    },
+    "image-redundant-alt": {
+      "description": "",
+      "help": "Alternativ tekst til billeder (alt-tekst) bør ikke gentages som brødtekst"
+    },
+    "input-button-name": {
+      "description": "",
+      "help": "Input-knapper skal have en forståelig tekst"
+    },
+    "input-image-alt": {
+      "description": "",
+      "help": "Billed-knapper skal have en alternativ tekst"
+    },
+    "label-content-name-mismatch": {
+      "description": "",
+      "help": "Elementers synlige tekst skal være del af deres tilgængelige navn"
+    },
+    "label-title-only": {
+      "description": "",
+      "help": "Form-elementer bør have en synlig label"
+    },
+    "label": {
+      "description": "",
+      "help": "Form-elementer skal have labels"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "",
+      "help": "Et 'banner'-landmark må ikke være indeholdt i et andet landmark"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "",
+      "help": "Et 'aside'- eller 'complimentary'-landmark må ikke være indeholdt i et andet landmark"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "",
+      "help": "Et 'contentinfo'-landmark må ikke være indeholdt i et andet landmark"
+    },
+    "landmark-main-is-top-level": {
+      "description": "",
+      "help": "Et 'main'-landmark må ikke være indeholdt i et andet landmark"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "",
+      "help": "Dokumentet må ikke have mere end ét 'banner'-landmark"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "",
+      "help": "Dokumentet må ikke have mere end ét 'contentinfo'-landmark"
+    },
+    "landmark-one-main": {
+      "description": "",
+      "help": "Dokumentet skal have ét 'main'-landmark"
+    },
+    "landmark-unique": {
+      "description": "",
+      "help": "Sikrer at landmarks er unikke"
+    },
+    "link-in-text-block": {
+      "description": "",
+      "help": "Links skal være fremtrædende fra den omkringliggende tekst på en måde, som ikke afhænger af farve"
+    },
+    "link-name": {
+      "description": "",
+      "help": "Links skal have forståelig (detekterbar) tekst"
+    },
+    "list": {
+      "description": "",
+      "help": "<ul> og <ol> må kun direkte indeholde <li>, <script> eller <template> elementer"
+    },
+    "listitem": {
+      "description": "",
+      "help": "<li> elementer skal være indeholdt i et <ul> eller <ol> element"
+    },
+    "marquee": {
+      "description": "",
+      "help": "<marquee> elementer er udfaset og må ikke bruges"
+    },
+    "meta-refresh": {
+      "description": "",
+      "help": "Tidsindstillet 'refresh' må ikke bruges"
+    },
+    "meta-viewport-large": {
+      "description": "",
+      "help": "Brugere bør kunne zoome og skalere tekst op til 500%"
+    },
+    "meta-viewport": {
+      "description": "",
+      "help": "Zoom og skalering må ikke være slået fra"
+    },
+    "object-alt": {
+      "description": "",
+      "help": "<object> elementer skal have en alternativ tekst"
+    },
+    "p-as-heading": {
+      "description": "",
+      "help": "Fremhævelse med fed, kursiv og skriftstørrelse (font-size) må ikke bruges til at style <p> elementer som en overskrift"
+    },
+    "page-has-heading-one": {
+      "description": "",
+      "help": "Siden skal indeholde en overskrift på øverste niveau"
+    },
+    "region": {
+      "description": "",
+      "help": "Alt indhold på siden skal være indeholdt i landmarks"
+    },
+    "role-img-alt": {
+      "description": "",
+      "help": "Elementer med 'role' attributværdien 'img' skal have en alternativ tekst"
+    },
+    "scope-attr-valid": {
+      "description": "",
+      "help": "'scope'-attributten skal bruges korrekt i tabeller"
+    },
+    "scrollable-region-focusable": {
+      "description": "",
+      "help": "Sørg for, at en scrollbar region er tilgængeligt via keyboard"
+    },
+    "server-side-image-map": {
+      "description": "",
+      "help": "Såkaldte 'server-side image-maps' må ikke bruges"
+    },
+    "skip-link": {
+      "description": "",
+      "help": "Et 'skip-link' skal pege på et eksisterende og fokuserbart element"
+    },
+    "tabindex": {
+      "description": "",
+      "help": "Elementer bør ikke have et 'tabindex' højere end 0"
+    },
+    "table-duplicate-name": {
+      "description": "",
+      "help": "Elementet <caption> bør ikke indeholde samme tekst som 'summary'-attributten"
+    },
+    "table-fake-caption": {
+      "description": "",
+      "help": "Data- eller overskrifts-celler bør ikke bruges til at beskrive indholdet af en data-tabel"
+    },
+    "td-has-header": {
+      "description": "",
+      "help": "Alle ikke-tomme <td> elementer i en tabel større end 3x3 bør have en tabeloverskrift (<th>)"
+    },
+    "td-headers-attr": {
+      "description": "",
+      "help": "Alle celler i en tabel, som  bruger 'header'-attributten må kun referere til andre celler i samme tabel"
+    },
+    "th-has-data-cells": {
+      "description": "",
+      "help": "Alle <th> elementer og elementer med 'role=columnheader/rowheader' skal referere til de data-celler, som de beskriver"
+    },
+    "valid-lang": {
+      "description": "",
+      "help": "'lang'-attributten skal have en korrekt værdi"
+    },
+    "video-caption": {
+      "description": "",
+      "help": "<video> elementer skal have undertekster ('captions')"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "Abstrakte roller er ikke brugt",
+      "fail": "Abstrakte roller bør ikke bruges"
+    },
+    "aria-allowed-attr": {
+      "pass": "ARIA-attribut er brugt korrekt for den angivede rolle",
+      "fail": {
+        "singular": "ARIA-attributterne er ikke tilladt: ${data.values}",
+        "plural": "ARIA-attribut er ikke tilladt: ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "ARIA-rollen er tilladt for det givne element",
+      "fail": {
+        "singular": "ARIA-rollerne ${data.values} er ikke tilladt for det givne element",
+        "plural": "ARIA-rollen ${data.values} er ikke tilladt for det givne element"
+      },
+      "incomplete": {
+        "singular": "ARIA-rollerne ${data.values} skal være fjernet, når elementet er synligt, da de ikke er tilladt for elementet",
+        "plural": "ARIA-rollen ${data.values} skal være fjernet, når elementet er synligt, da det ikke er tilladt for elementet"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "Ingen 'aria-hidden'-attribut er at finde i dokumentets <body> element",
+      "fail": "'aria-hidden=true' bør ikke bruges på dokumentets <body> element"
+    },
+    "aria-roledescription": {
+      "pass": "'aria-roledescription' bruges på en understøttet semantisk rolle",
+      "incomplete": "Tjek at 'aria-roledescription' bliver læst op af understøttet skærmlæser",
+      "fail": "Giv elementet en rolle, som understøtter 'aria-roledescription'"
+    },
+    "aria-errormessage": {
+      "pass": "Bruger en understøttet 'aria-errormessage'-teknik",
+      "fail": {
+        "singular": "'aria-errormessage'-værdier ${data.values}` bør bruge en teknik til at annoncere beskeden (fx 'aria-live', 'aria-describedby', 'role=alert', osv.)",
+        "plural": "'aria-errormessage'-værdi ${data.values}` bør bruge en teknik til at annoncere beskeden (fx 'aria-live', 'aria-describedby', 'role=alert', osv.)"
+      }
+    },
+    "has-widget-role": {
+      "pass": "Elementet har en 'widget'-rolle.",
+      "fail": "Elementet har ikke en 'widget'-rolle."
+    },
+    "invalidrole": {
+      "pass": "ARIA-rollen er korrekt",
+      "fail": "Rollen skal være en af de mulige ARIA-roller"
+    },
+    "no-implicit-explicit-label": {
+      "pass": "Der er uoverensstemmelse mellem <label> og det tilgængelige navn",
+      "incomplete": "Tjek at <label> elementet ikke behøver være en del af ${data}-feltets navn"
+    },
+    "aria-required-attr": {
+      "pass": "Alle krævede ARIA-attributter er tilstede",
+      "fail": {
+        "singular": "Krævet ARIA-attributter er ikke til stede: ${data.values}",
+        "plural": "Krævet ARIA-attribut er ikke til stede: ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Krævet ARIA-under-elementer er til stede"
+      },
+      "fail": {
+        "singular": "Krævet ARIA-under-elementers rolle er ikke til stede: ${data.values}",
+        "plural": "Krævet ARIA-under-elements rolle er ikke til stede: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Forventer at ARIA under-elementers rolle bliver tilføjet: ${data.values}",
+        "plural": "Forventer at ARIA under-elements rolle bliver tilføjet: ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "Krævet ARIA-over-elements rolle er til stede",
+      "fail": {
+        "singular": "Krævet ARIA-over-elementers rolle er ikke til stede: ${data.values}",
+        "plural": "Krævet ARIA-over-elements rolle er ikke til stede: ${data.values}"
+      }
+    },
+    "aria-unsupported-attr": {
+      "pass": "ARIA-attribut er understøttet",
+      "fail": "ARIA-attribut er ikke bredt understøttet i skærmlæsere og tilgængelighedsteknologier:  ${data.values}"
+    },
+    "unsupportedrole": {
+      "pass": "ARIA rollen er understøttet",
+      "fail": "Den brugte rolle er ikke bredt understøttet i skærmlæsere og tilgængelighedsteknologier:  ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "ARIA-attributværdien er valid",
+      "fail": {
+        "singular": "Ikke-korrekt ARIA-attributværdier: ${data.values}",
+        "plural": "Ikke-korrekt ARIA-attributværdi: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "ARIA-attributternes element 'id' er ikke at finde på siden: ${data.values}",
+        "plural": "ARIA-attributtens element 'id' er ikke at finde på siden: ${data.values}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "ARIA-attributnavnene er korrekt",
+        "plural": "ARIA-attributnavnet er korrekt"
+      },
+      "fail": {
+        "singular": "Ikke-korrekt ARIA-attributnavne: ${data.values}",
+        "plural": "Ikke-korrekt ARIA-attributnavn: ${data.values}"
+      }
+    },
+    "valid-scrollable-semantics": {
+      "pass": "Elementet har korrekt semantik for et element i fokus-rækkefølgen.",
+      "fail": "Elementet har ikke korrekt semantik for et element i fokus-rækkefølgen."
+    },
+    "color-contrast": {
+      "pass": "Elementet har stor farvekontrast, den er ${data.contrastRatio}",
+      "fail": "Elementet har ikke nok farvekontrast, den er ${data.contrastRatio} (forgrundsfarve: ${data.fgColor}, baggrundsfarve: ${data.bgColor}, tekststørrelse: ${data.fontSize}, teksttykkelse: ${data.fontWeight}). Forventet kontrastforhold er ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementets baggrundsfarve kunne ikke detekteres på grund af et baggrundsbillede",
+        "bgGradient": "Elementets baggrundsfarve kunne ikke detekteres på grund af en baggrundsgradient",
+        "imgNode": "Elementets baggrundsfarve kunne ikke detekteres, fordi elementet indeholder et billedelement",
+        "bgOverlap": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er overlappet af et andet element",
+        "fgAlpha": "Elementets forgrundsfarve kunne ikke detekteres på grund af dets gennemsigtighed",
+        "elmPartiallyObscured": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er delvist dækket af et andet element",
+        "elmPartiallyObscuring": "Elementets baggrundsfarve kunne ikke detekteres, fordi det delvist dækker et andet element",
+        "outsideViewport": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er udenfor sidens 'viewport'",
+        "equalRatio": "Elementet har et 1:1-kontrastforhold med baggrunden",
+        "shortTextContent": "Elementets indhold er for kort til at kunne afgøre, om indholdet ren faktisk ER tekst",
+        "default": "Kan ikke udregne kontrastforhold"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "Elementet har stor farvekontrast, den er ${data.contrastRatio}",
+      "fail": "Elementet har ikke nok farvekontrast, den er ${data.contrastRatio} (forgrundsfarve: ${data.fgColor}, baggrundsfarve: ${data.bgColor}, tekststørrelse: ${data.fontSize}, teksttykkelse: ${data.fontWeight}). Forventet kontrastforhold er ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementets baggrundsfarve kunne ikke detekteres på grund af et baggrundsbillede",
+        "bgGradient": "Elementets baggrundsfarve kunne ikke detekteres på grund af en baggrundsgradient",
+        "imgNode": "Elementets baggrundsfarve kunne ikke detekteres, fordi elementet indeholder et billedelement",
+        "bgOverlap": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er overlappet af et andet element",
+        "fgAlpha": "Elementets forgrundsfarve kunne ikke detekteres på grund af dets gennemsigtighed",
+        "elmPartiallyObscured": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er delvist dækket af et andet element",
+        "elmPartiallyObscuring": "Elementets baggrundsfarve kunne ikke detekteres, fordi det delvist dækker et andet element",
+        "outsideViewport": "Elementets baggrundsfarve kunne ikke detekteres, fordi det er udenfor sidens 'viewport'",
+        "equalRatio": "Elementet har et 1:1-kontrastforhold med baggrunden",
+        "shortTextContent": "Elementets indhold er for kort til at kunne afgøre, om indholdet ren faktisk ER tekst",
+        "default": "Kan ikke udregne kontrastforhold"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Links kan adskilles fra den omkringliggende tekst på anden måde end med farve",
+      "fail": "Links bør skille sig ud fra den omkringliggende tekst på anden måde end med farve",
+      "incomplete": {
+        "bgContrast": "Elementets kontrastforhold kunne ikke detekteres. Tjek for specifik 'hover'/'focus' styling",
+        "bgImage": "Elementets kontrastforhold kunne ikke detekteres på grund af et baggrundsbillede",
+        "bgGradient": "Elementets kontrastforhold kunne ikke detekteres på grund af en baggrundsgradient",
+        "imgNode": "Elementets kontrastforhold kunne ikke detekteres, fordi elementet indeholder et billedelement",
+        "bgOverlap": "Elementets kontrastforhold kunne ikke detekteres på grund af overlappende elementer",
+        "default": "Kan ikke udregne kontrastforhold"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "'autocomplete'-værdien er brugt på et passende element",
+      "fail": "'autocomplete'-værdien er ikke passende for denne type input"
+    },
+    "autocomplete-valid": {
+      "pass": "'autocomplete'-attributten er korrekt formateret",
+      "fail": "'autocomplete'-attributten er forkert formateret"
+    },
+    "accesskeys": {
+      "pass": "'Accesskey' attributværdien er unik",
+      "fail": "Dokumentet har flere elementer med den samme 'accesskey'-attribut"
+    },
+    "focusable-content": {
+      "pass": "Elementet indeholder fokuserbare elementer",
+      "fail": "Elementet bør have fokuserbart indhold"
+    },
+    "focusable-disabled": {
+      "pass": "Ingen fokuserbare elementer indeholdt i elementet",
+      "fail": "Fokuserbart indhold bør slås fra eller fjernes fra sidens DOM"
+    },
+    "focusable-element": {
+      "pass": "Elementet er fokuserbart",
+      "fail": "Elementet bør være fokuserbart"
+    },
+    "focusable-no-name": {
+      "pass": "Elementet er ikke i sidens tabulerings-rækkefølge ('tab order') eller har tilgængelig tekst",
+      "fail": "Elementet er i sidens tabulerings-rækkefølge ('tab order') og har ikke tilgængelig tekst"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Ingen fokuserbare elementer indeholdt i element",
+      "fail": "Fokuserbart indhold bør have tabindex='-1' eller fjernes fra sidens DOM"
+    },
+    "landmark-is-top-level": {
+      "pass": "${data.role} landmark er på det øverste niveau.",
+      "fail": "${data.role} landmark er indhold i et andet landmark."
+    },
+    "page-has-heading-one": {
+      "pass": "Siden har mindst én overskrift på niveau 1",
+      "fail": "Siden skal have mindst én overskrift på niveau 1"
+    },
+    "page-has-main": {
+      "pass": "Dokumentet har mindst ét 'main'-landmark",
+      "fail": "Dokumentet har ikke et 'main'-landmark"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "Dokumentet har ikke mere end ét 'banner'-landmark",
+      "fail": "Dokumentet har mere end ét 'banner-'landmark"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "Dokumentet har ikke mere end ét 'contentinfo'-landmark",
+      "fail": "Dokumentet har mere end ét 'contentinfo'-landmark"
+    },
+    "page-no-duplicate-main": {
+      "pass": "Dokumentet har ikke mere end ét 'main'-landmark",
+      "fail": "Dokumentet har mere end ét 'main'-landmark"
+    },
+    "tabindex": {
+      "pass": "Elementet har ikke et 'tabindex' større end 0",
+      "fail": "Elementet har et 'tabindex' større end 0"
+    },
+    "alt-space-value": {
+      "pass": "Elementet har en alt-attribut med valid værdi",
+      "fail": "Elementet har en alt-attribut, som kun indeholder et mellemrum, hvilket ikke ignoreres af alle skærmlæsere"
+    },
+    "duplicate-img-label": {
+      "pass": "Elementet duplikerer ikke den eksisterende tekst fra <img> elementets alt-tekst",
+      "fail": "Elementet indeholder et <img> element med alt-tekst, som duplikerer den eksisterende tekst"
+    },
+    "explicit-label": {
+      "pass": "Form-elementet har en eksplicit <label>",
+      "fail": "Form-elementet har ikke en eksplicit <label>"
+    },
+    "help-same-as-label": {
+      "pass": "Hjælpeteksten ('title' eller 'aria-describedby') duplikerer ikke label-teksten",
+      "fail": "Hjælpeteksten ('title' eller 'aria-describedby') er den samme som label-teksten"
+    },
+    "hidden-explicit-label": {
+      "pass": "Form-elementet har en synlig og eksplicit <label>",
+      "fail": "Form-elementet har en eksplicit <label>, som er skjult"
+    },
+    "implicit-label": {
+      "pass": "Form-elementet har en implicit (indeholdt i en) <label>",
+      "fail": "Form-elementet har ikke en implicit (indeholdt i en) <label>"
+    },
+    "label-content-name-mismatch": {
+      "pass": "Elementet indeholder synlig tekst som del af dets tilgængelige navn",
+      "fail": "Tekst i elementet er ikke inkluderet i det tilgængelige navn"
+    },
+    "multiple-label": {
+      "pass": "Form-feltet har ikke flere label-elementer",
+      "incomplete": "Flere label-elementer er ikke bredt understøttet i tilgængelighedsteknologier. Sørg for, at det første label-element indeholder alle de nødvendige informationer."
+    },
+    "title-only": {
+      "pass": "Form-elementet bruger ikke udelukkende 'title'-attributten som label",
+      "fail": "Kun 'title'-attributten er brugt som label for form-elementet"
+    },
+    "landmark-is-unique": {
+      "pass": "Landmarks skal have en unik rolle eller 'role'/'label'/'title'-attribut-kombination (som tilgængeligt navn)",
+      "fail": "Et landmark skal have en unik 'aria-label', 'aria-labelledby', eller 'title' for at gøre landmarks adskillelige"
+    },
+    "has-lang": {
+      "pass": "<html> elementet har en 'lang'-attribut",
+      "fail": "<html> elementet har ikke en 'lang'-attribut"
+    },
+    "valid-lang": {
+      "pass": "'lang'-attributtens værdi er inkluderet i listen over godkendte sprog",
+      "fail": "'lang'-attributtens værdi er ikke inkluderet i listen over godkendte sprog"
+    },
+    "xml-lang-mismatch": {
+      "pass": "Attributterne 'lang' og 'xml:lang' har samme basissprog",
+      "fail": "Attributterne 'lang' og 'xml:lang' har ikke samme basissprog"
+    },
+    "dlitem": {
+      "pass": "Beskrivelsesliste-elementet har et <dl>-over-element",
+      "fail": "Beskrivelsesliste-elementet har ikke et <dl>-over-element"
+    },
+    "listitem": {
+      "pass": "Elementet i listen har et <ul>, <ol> eller 'role=\"list\"'-over-element",
+      "fail": "Elementet i listen har ikke et <ul>, <ol> eller 'role=\"list\"'-over-element"
+    },
+    "only-dlitems": {
+      "pass": "Elementet i listen har kun direkte under-elementer, som er tilladt i <dt> eller <dd> elementer",
+      "fail": "Elementet i listen har direkte under-elementer, som ikke er tilladt inde i <dt> eller <dd> elementer"
+    },
+    "only-listitems": {
+      "pass": "Elementet i listen har kun direkte under-elementer, som er tilladt i <li> elementer",
+      "fail": "Elementet i listen har direkte under-elementer, som ikke er tilladt inde i <li> elementer"
+    },
+    "structured-dlitems": {
+      "pass": "Det ikke-tomme element har både <dt> og <dd> elementer",
+      "fail": "Det ikke-tomme element har ikke mindst ét <dt> element efterfulgt af mindst ét <dd> element"
+    },
+    "caption": {
+      "pass": "Multimedia-elementet har et track med undertekster",
+      "incomplete": "Tjek at undertekster er tilgængelige for elementet"
+    },
+    "frame-tested": {
+      "pass": "Denne <iframe> blev testet af axe-core",
+      "fail": "Denne <iframe> kunne ikke testes af axe-core",
+      "incomplete": "Denne <iframe> er endnu ikke blevet testet af axe-core"
+    },
+    "css-orientation-lock": {
+      "pass": "Skærmen kan styres, og sidens skærmretning er ikke låst med med 'css-orientation-lock'",
+      "fail": "Skærmretningen ('css-orientation-lock') er låst, hvilket gør sidevisning svær at styre på skærmen",
+      "incomplete": "Det kan ikke detekteres om skærmretning er låst (med 'css-orientation-lock')"
+    },
+    "meta-viewport-large": {
+      "pass": "<meta>-tagget begrænser ikke høj zoom på mobile enheder",
+      "fail": "<meta>-tagget begrænser zoom på mobile enheder"
+    },
+    "meta-viewport": {
+      "pass": "<meta>-tagget slår ikke zoom fra på mobile enheder",
+      "fail": "${data} på <meta>-tagget slår zoom fra på mobile enheder"
+    },
+    "header-present": {
+      "pass": "Siden har en overskrift (header)",
+      "fail": "Siden har ikke en overskrift (header)"
+    },
+    "heading-order": {
+      "pass": "Rækkefølgen af overskiftsniveauer er korrekt",
+      "fail": "Rækkefølgen af overskiftsniveauer er ikke korrekt"
+    },
+    "internal-link-present": {
+      "pass": "Passende 'skip link' fundet",
+      "fail": "Intet passende 'skip link' fundet"
+    },
+    "landmark": {
+      "pass": "Siden har en 'landmark' region",
+      "fail": "Siden har ikke en 'landmark' region"
+    },
+    "meta-refresh": {
+      "pass": "<meta>-tagget genindlæser ikke siden med det samme",
+      "fail": "<meta>-tagget genindlæser siden med det samme"
+    },
+    "p-as-heading": {
+      "pass": "<p> elementer er ikke stylet som en overskrift",
+      "fail": "Overskrifts-elementer (<h1>, <h2>, osv.) bør bruges i stedet for stylet <p> elementer"
+    },
+    "region": {
+      "pass": "Al indhold på siden er lagt ind under landmarks",
+      "fail": "Dele af sidens indhold er ikke lagt under et landmark"
+    },
+    "skip-link": {
+      "pass": "Det element, som 'skip link' refererer til, eksisterer",
+      "incomplete": "Det element, som 'skip link' refererer til, bør blive synligt ved aktivering",
+      "fail": "Manglende 'skip link' 'target'-attribut"
+    },
+    "unique-frame-title": {
+      "pass": "Elementets 'title'-attribut er unik",
+      "fail": "Elementets 'title'-attribut er ikke unik"
+    },
+    "duplicate-id-active": {
+      "pass": "Dokumentet har ingen aktive elementer, der deler den samme 'id'-attribut",
+      "fail": "Dokumentet har aktive elementer, der deler den samme 'id'-attribut: ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "Dokumentet har ingen elementer refereret med ARIA eller labels, der deler den samme 'id'-attribut",
+      "fail": "Dokumentet har flere elementer refereret med ARIA med den samme 'id'-attribut: ${data}"
+    },
+    "duplicate-id": {
+      "pass": "Dokumentet har ingen statiske elementer, der deler den samme 'id'-attribut",
+      "fail": "Dokumentet har flere statiske elementer med den samme 'id'-attribut"
+    },
+    "aria-label": {
+      "pass": "'aria-label'-attribut er til stede og er ikke tom",
+      "fail": "'aria-label'-attribut eksisterer ikke eller er tom"
+    },
+    "aria-labelledby": {
+      "pass": "'aria-labelledby'-attribut eksisterer og refererer elementer, der er synlige for skærmlæsere",
+      "fail": "'aria-labelledby'-attribut eksisterer ikke, eller refererer elementer, som ikke eksisterer - eller refererer til elementer, der er tomme"
+    },
+    "avoid-inline-spacing": {
+      "pass": "Ingen inline styling med '!important', som påvirker tekst-mellemrums-afstand er specificeret",
+      "fail": {
+        "singular": "Fjern '!important' fra inline stylings ${data.values}, da overskrivning af dette, ikke er understøttet i de fleste browsere",
+        "plural": "Fjern '!important' fra inline styling ${data.values}, da overskrivning af dette, ikke er understøttet i de fleste browsere"
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "Elementet har indre tekst, som er synlig for skærmlæsere",
+      "fail": "Elementet har ingen indre tekst, som er synlig for skærmlæsere"
+    },
+    "doc-has-title": {
+      "pass": "Dokumentet har et <title> element, der ikke er tomt",
+      "fail": "Dokumentet mangler et <title> element med indhold"
+    },
+    "exists": {
+      "pass": "Elementet eksisterer ikke",
+      "fail": "Elementet eksisterer"
+    },
+    "has-alt": {
+      "pass": "Elementet har en 'alt'-attribut",
+      "fail": "Elementet har ikke en 'alt'-attribut"
+    },
+    "has-visible-text": {
+      "pass": "Elementet har tekst, der er synligt for skærmlæsere",
+      "fail": "Elementet har ikke tekst, der er synligt for skærmlæsere"
+    },
+    "is-on-screen": {
+      "pass": "Elementet er ikke synligt",
+      "fail": "Elementet er synligt"
+    },
+    "non-empty-alt": {
+      "pass": "Elementet har 'alt'-attribut med indhold",
+      "fail": "Elementet har ingen 'alt'-attribut, eller 'alt'-attributten er tom"
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": "Elementet har ikke en 'value'-attribut",
+        "has-label": "Elementet har en 'værdi'-attribut med indhold"
+      },
+      "fail": "Elementet har en 'value'-attribut, og 'værdi'-attributten er tom"
+    },
+    "non-empty-title": {
+      "pass": "Elementet har en 'title'-attribut",
+      "fail": "Elementet har ingen 'title'-attribut, eller 'title'-attributten er tom"
+    },
+    "non-empty-value": {
+      "pass": "Elementet har 'value'-attribut med indhold",
+      "fail": "Elementet har ingen 'value'-attribut, eller 'value'-attributten er tom"
+    },
+    "role-none": {
+      "pass": "Elementets standard semantik blev overskrevet med attributten 'role=\"none\"'",
+      "fail": "Elementets standard semantik blev ikke overskrevet med attributten 'role=\"none\"'"
+    },
+    "role-presentation": {
+      "pass": "Elementets standard semantik blev overskrevet med attributten 'role=\"presentation\"'",
+      "fail": "Elementets standard semantik blev ikke overskrevet med attributten 'role=\"presentation\"'"
+    },
+    "caption-faked": {
+      "pass": "Den første række i tabellen er ikke brugt som en beskrivelse ('caption')",
+      "fail": "Det første element i tabellen bør være en beskrivelse (<caption>) i stedet for en celle"
+    },
+    "html5-scope": {
+      "pass": "'Scope'-attributten bør kun bruges på tabellens header-elementer (<th>)",
+      "fail": "'Scope'-attributten bør kun bruges på tabellens header-elementer (<th>)"
+    },
+    "same-caption-summary": {
+      "pass": "Indholdet af 'summary'-attributten og <caption> elementet er ikke identisk",
+      "fail": "Indholdet af 'summary'-attributten og <caption> elementet er identisk"
+    },
+    "scope-value": {
+      "pass": "'scope'-attributten bruges korrekt",
+      "fail": "Værdien af 'scope'-attributten må kun være 'row' eller 'col'"
+    },
+    "td-has-header": {
+      "pass": "Alle data-celler med indhold har en tabel-header",
+      "fail": "Nogle data-celler med indhold har ikke tabel-headers"
+    },
+    "td-headers-attr": {
+      "pass": "Header-attributten bruges kun til at referere til andre celler i den samme tabel",
+      "fail": "Header-attributten bruges ikke kun til at referere til andre celler i den samme tabel"
+    },
+    "th-has-data-cells": {
+      "pass": "Alle tabellens header-celler refererer til data-celler",
+      "fail": "Ikke alle tabellens header-celler refererer til data-celler",
+      "incomplete": "Nogle af tabellens data-celler mangler eller er tomme"
+    },
+    "hidden-content": {
+      "pass": "Alt indhold på siden er blevet analyseret.",
+      "fail": "Der var problemer med at analysere dele af indholdet på denne side.",
+      "incomplete": "Der er skjult indhold på siden, som ikke blev analyseret. Du skal gøre dette indhold synligt for at kunne analysere det."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Ret en af følgende:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Ret alle de følgende:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "axe kunne ikke give en årsag. Tid til at finde dit udviklingsværktøj frem!"
+}

node_modules/axe-core/locales/es.json

@@ -0,0 +1,790 @@
+{
+  "lang": "es",
+  "rules": {
+    "accesskeys": {
+      "description": "Garantiza que cada valor para el atributo accesskey es único",
+      "help": "El valor del atributo accesskey debe ser único"
+    },
+    "area-alt": {
+      "description": "Garantiza que los elementos <area> de los mapas de imágenes tienen texto alternativo",
+      "help": "Los elementos <area> activos deben tener texto alternativo"
+    },
+    "aria-allowed-attr": {
+      "description": "Garantiza que los atributos ARIA están permitidos para el rol de un elemento",
+      "help": "Los elementos solo deben usar atributos ARIA permitidos"
+    },
+    "aria-allowed-role": {
+      "description": "Garantiza que el atributo role tiene un valor apropiado para el elemento",
+      "help": "ARIA role debe ser apropiado para el elemento"
+    },
+    "aria-hidden-body": {
+      "description": "Garantiza que aria-hidden='true' no está presente en el 'body' del documento.",
+      "help": "aria-hidden='true' no debe estar presente en el 'body' del documento"
+    },
+    "aria-hidden-focus": {
+      "description": "Garantiza que los elementos 'aria-hidden' no contienen elementos que admitan el foco",
+      "help": "Los elementos 'ARIA hidden' no deben contener elementos que admitan el foco"
+    },
+    "aria-input-field-name": {
+      "description": "Garantiza que cada 'ARIA input field' tiene un nombre accesible",
+      "help": "Los 'ARIA input fields' tienen un nombre accesible"
+    },
+    "aria-required-attr": {
+      "description": "Garantiza que los elementos con 'ARIA roles' tienen todos los atributos ARIA requeridos",
+      "help": "Deben proporcionarse los atributos ARIA requeridos"
+    },
+    "aria-required-children": {
+      "description": "Garantiza que los elementos con un 'ARIA role' que requieren 'child roles' los contienen",
+      "help": "Ciertos 'ARIA roles' deben contener determinados hijos"
+    },
+    "aria-required-parent": {
+      "description": "Garantiza que los elementos con un 'ARIA role' que requieren 'parent roles' están contenidos en ellos",
+      "help": "Ciertos 'ARIA roles' deben estar contenidos en determinados padres"
+    },
+    "aria-roles": {
+      "description": "Garantiza que todos los elementos con un atributo role usan un valor válido",
+      "help": "Los 'ARIA roles' usados deben cumplir los requisitos para valores válidos"
+    },
+    "aria-toggle-field-name": {
+      "description": "Garantiza que cada 'ARIA toggle field' tiene un nombre accesible",
+      "help": "Los 'ARIA toggle fields' tienen un nombre accesible"
+    },
+    "aria-valid-attr-value": {
+      "description": "Garantiza que todos los atributos ARIA tienen valores válidos",
+      "help": "Los atributos ARIA deben cumplir los requisitos para valores válidos"
+    },
+    "aria-valid-attr": {
+      "description": "Garantiza que los atributos que empiezan por aria- son atributos ARIA válidos",
+      "help": "Los atributos ARIA deben cumplir los requisitos para nombres válidos"
+    },
+    "audio-caption": {
+      "description": "Garantiza que los elementos <audio> tienen subtítulos",
+      "help": "Los elementos <audio> deben tener una pista de subtítulos"
+    },
+    "autocomplete-valid": {
+      "description": "Garantizar que el atributo autocomplete es correcto y adecuado para el campo de formulario",
+      "help": "El atributo autocomplete debe usarse correctamente"
+    },
+    "avoid-inline-spacing": {
+      "description": "Garantizar que el espaciado de texto establecido mediante atributos style se puede ajustar con hojas de estilo personalizadas",
+      "help": "El espaciado de texto 'inline' debe poder ajustarse mediante hojas de estilo personalizadas"
+    },
+    "blink": {
+      "description": "Garantiza que no se usan elementos <blink>",
+      "help": "Los elementos <blink> están obsoletos y no deben usarse"
+    },
+    "button-name": {
+      "description": "Garantiza que los botones tienen texto discernible",
+      "help": "Los botones deben tener texto discernible"
+    },
+    "bypass": {
+      "description": "Garantiza que cada página tiene al menos un medio para que un usuario pueda saltarse la navegación y pasar directamente al contenido",
+      "help": "Las páginas deben tener medios para saltarse bloques repetidos"
+    },
+    "color-contrast": {
+      "description": "Garantiza que el contraste entre colores de primer plano y fondo cumple los límites de la ratio para contraste WCAG 2 AA",
+      "help": "Los elementos deben tener un contraste de colores suficiente"
+    },
+    "color-contrast-enhanced": {
+      "description": "Garantiza que el contraste entre colores de primer plano y fondo cumple los límites de la ratio para contraste WCAG 2 AAA",
+      "help": "Los elementos deben tener un contraste de colores suficiente"
+    },
+    "css-orientation-lock": {
+      "description": "Garantiza que el contenido no está bloqueado en ninguna orientación de pantalla específica, y que el contenido es manejable en cualquier orientación de pantalla",
+      "help": "Las 'CSS Media queries' no se usan para bloquear la orientación de pantalla"
+    },
+    "definition-list": {
+      "description": "Garantiza que los elementos <dl> están estructurados correctamente",
+      "help": "Los elementos <dl> solo deben contener directamente grupos de <dt> y <dd> debidamente ordenados, o elementos <script> o <template>"
+    },
+    "dlitem": {
+      "description": "Garantiza que los elementos <dt> y <dd> están contenidos en un <dl>",
+      "help": "Los elementos <dt> y <dd> deben estar contenidos en un <dl>"
+    },
+    "document-title": {
+      "description": "Garantiza que cada documento HTML tiene un elemento <title> no vacío",
+      "help": "Los documentos deben tener elementos <title> para ayudar en la navegación"
+    },
+    "duplicate-id-active": {
+      "description": "Garantiza que cada valor para el atributo id de elementos activos es único",
+      "help": "Los 'IDs' de elementos activos deben ser únicos"
+    },
+    "duplicate-id-aria": {
+      "description": "Garantiza que cada valor del atributo id usado en ARIA y en 'labels' es único",
+      "help": "Los 'IDs' usados en ARIA y en 'labels' deben ser únicos"
+    },
+    "duplicate-id": {
+      "description": "Garantiza que cada valor para el atributo id es único",
+      "help": "El valor del atributo id debe ser único"
+    },
+    "empty-heading": {
+      "description": "Garantiza que los encabezados tienen texto discernible",
+      "help": "Los encabezados no deben estar vacíos"
+    },
+    "focus-order-semantics": {
+      "description": "Garantiza que los elementos en orden de foco tienen un rol apropiado",
+      "help": "Los elementos en orden de foco necesitan un rol apropiado para contenido interactivo"
+    },
+    "form-field-multiple-labels": {
+      "description": "Garantiza que el campo de formulario no tiene múltiples elementos label",
+      "help": "El campo de formulario no debe tener múltiples elementos label"
+    },
+    "frame-tested": {
+      "description": "Garantiza que los elementos <iframe> y <frame> contienen el script axe-core",
+      "help": "Los marcos deben probarse con axe-core"
+    },
+    "frame-title-unique": {
+      "description": "Garantiza que los elementos <iframe> y <frame> contienen un atributo título único",
+      "help": "Los marcos deben tener un único atributo title"
+    },
+    "frame-title": {
+      "description": "Garantiza que los elementos <iframe> y <frame> contienen un atributo título no vacío",
+      "help": "Los marcos deben tener el atributo title"
+    },
+    "heading-order": {
+      "description": "Garantiza que el orden de los encabezados es semánticamente correcto",
+      "help": "El nivel de encabezados solo debería incrementarse en 1"
+    },
+    "hidden-content": {
+      "description": "Informa a los usuarios sobre contenido oculto.",
+      "help": "El contenido oculto de la página no se puede analizar"
+    },
+    "html-has-lang": {
+      "description": "Garantiza que cada documento HTML tiene un atributo lang",
+      "help": "El elemento <html> debe tener un atributo lang"
+    },
+    "html-lang-valid": {
+      "description": "Garantiza que el atributo lang del elemento <html> tiene un valor válido",
+      "help": "El elemento <html> debe tener un valor válido para el atributo lang"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "Garantizar que en los elementos HTML con atributos tanto lang como xml:lang válidos haya concordancia en el idioma base de la página",
+      "help": "Los elementos HTML con lang y xml:lang deben tener el mismo idioma base"
+    },
+    "image-alt": {
+      "description": "Garantiza que los elementos <img> tienen texto alternativo o un rol de none o presentation",
+      "help": "Las imágenes deben tener texto alternativo"
+    },
+    "image-redundant-alt": {
+      "description": "Garantiza que la alternativa a la imagen no se repite como texto",
+      "help": "El texto alternativo de las imágenes no debe repetirse como texto"
+    },
+    "input-button-name": {
+      "description": "Garantizar que los 'input buttons' tienen texto discernible",
+      "help": "Los 'Input buttons' deben tener texto discernible"
+    },
+    "input-image-alt": {
+      "description": "Garantiza que los elementos <input type=\"image\"> tienen texto alternativo",
+      "help": "Los 'image buttons' deben tener texto alternativo"
+    },
+    "label-content-name-mismatch": {
+      "description": "Garantiza que, en los elementos etiquetados mediante su contenido, su texto visible debe formar parte de su nombre accesible",
+      "help": "Los elementos deben tener su texto visible como parte de su nombre accesible"
+    },
+    "label-title-only": {
+      "description": "Garantiza que cada elemento de formulario no está etiquetado únicamente mediante los atributos title o aria-describedby ",
+      "help": "Los elementos de formulario deben tener una etiqueta visible"
+    },
+    "label": {
+      "description": "Garantiza que cada elemento de formulario tiene una etiqueta",
+      "help": "Los elementos de formulario deben tener etiquetas"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "Garantiza que el punto de referencia banner está en el nivel superior",
+      "help": "El punto de referencia banner no debe estar contenido en otro punto de referencia"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "Garantiza que el punto de referencia complementary o aside está en el nivel superior",
+      "help": "Aside no debe estar contenido en otro punto de referencia"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "Garantiza que el punto de referencia contentinfo está en el nivel superior",
+      "help": "El punto de referencia contentinfo no debe estar contenido en otro punto de referencia"
+    },
+    "landmark-main-is-top-level": {
+      "description": "Garantiza que el punto de referencia main está en el nivel superior",
+      "help": "El punto de referencia main no debe estar contenido en otro punto de referencia"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "Garantiza que el documento tiene, como mucho, un punto de referencia banner",
+      "help": "El documento no debe tener más de un punto de referencia banner"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "Garantiza que el documento tiene, como mucho, un punto de referencia contentinfo",
+      "help": "El documento no debe tener más de un punto de referencia contentinfo"
+    },
+    "landmark-one-main": {
+      "description": "Garantiza que el documento solo tiene un punto de referencia main y que cada marco incorporado en la página tiene, como mucho, un punto de referencia main",
+      "help": "El documento debe tener un punto de referencia main"
+    },
+    "landmark-unique": {
+      "help": "Garantiza que los puntos de referencia son únicos",
+      "description": "Los puntos de referencia deben tener una única combinación de role o role/label/title (es decir, un nombre accesible único)"
+    },
+    "link-in-text-block": {
+      "description": "Los enlaces pueden distinguirse sin depender del color",
+      "help": "Los enlaces deben distinguirse del texto adyacente por un medio que no dependa del color"
+    },
+    "link-name": {
+      "description": "Garantiza que los enlaces tienen texto discernible",
+      "help": "Los enlaces deben tener texto discernible"
+    },
+    "list": {
+      "description": "Garantiza que las listas están estructuradas correctamente",
+      "help": "<ul> y <ol> solo deben contener directamente elementos <li>, <script> o <template>"
+    },
+    "listitem": {
+      "description": "Garantiza que los elementos <li> se utilizan semánticamente",
+      "help": "Los elementos <li> deben estar contenidos en un <ul> o un <ol>"
+    },
+    "marquee": {
+      "description": "Garantiza que no se usan elementos <marquee>",
+      "help": "Los elementos <marquee> están obsoletos y no deben usarse"
+    },
+    "meta-refresh": {
+      "description": "Garantiza que no se usa <meta http-equiv=\"refresh\">",
+      "help": "El refresco programado no debe existir"
+    },
+    "meta-viewport-large": {
+      "description": "Garantizar que <meta name=\"viewport\"> puede ampliarse en grado significativo",
+      "help": "Los usuarios deben poder hacer zum y ampliar el texto hasta 500%"
+    },
+    "meta-viewport": {
+      "description": "Garantiza que <meta name=\"viewport\"> no impide la ampliación y el zum en el texto",
+      "help": "No debe impedirse el zum y la ampliación"
+    },
+    "object-alt": {
+      "description": "Garantiza que los elementos <object> tienen texto alternativo",
+      "help": "Los elementos <object> deben tener texto alternativo"
+    },
+    "p-as-heading": {
+      "description": "Garantizar que los elementos p no se usan para diseñar encabezados",
+      "help": "No se usa texto en negrita, cursiva o tamaño de fuente para dar estilo de encabezados a elementos p"
+    },
+    "page-has-heading-one": {
+      "description": "Garantizar que la página, o al menos uno de sus marcos, contiene un encabezado de nivel 1",
+      "help": "La página debe contener un encabezado de nivel 1"
+    },
+    "region": {
+      "description": "Garantiza que todo el contenido de la página está incluido en puntos de referencia",
+      "help": "Todo el contenido de la página debe estar incluido en puntos de referencia"
+    },
+    "role-img-alt": {
+      "description": "Garantiza que los elementos [role='img'] tienen texto alternativo",
+      "help": "Los elementos [role='img'] tienen un texto alternativo"
+    },
+    "scope-attr-valid": {
+      "description": "Garantiza que el atributo scope se usa correctamente en las tablas",
+      "help": "El atributo scope debería usarse correctamente"
+    },
+    "scrollable-region-focusable": {
+      "description": "Los elementos que tienen contenido que puede desplazarse verticalmente (en 'scroll') deberían ser accesibles mediante el teclado",
+      "help": "Asegurar que la región de desplazamiento vertical ('scroll') tiene acceso por teclado"
+    },
+    "server-side-image-map": {
+      "description": "Garantiza que no se usan mapas de imágenes del lado del servidor",
+      "help": "No deben usarse mapas de imágenes del lado del servidor"
+    },
+    "skip-link": {
+      "description": "Garantizar que todos los enlaces de salto ('skip') tienen un destino que admite el foco",
+      "help": "El destino del enlace de salto ('skip') debería existir y admitir el foco"
+    },
+    "tabindex": {
+      "description": "Garantiza que los valores del atributo tabindex no son mayores que 0",
+      "help": "Los elementos no deberían tener un tabindex mayor que 0"
+    },
+    "table-duplicate-name": {
+      "description": "Garantizar que las tablas no tienen el mismo summary y caption",
+      "help": "El elemento <caption> no debería contener el mismo texto que el atributo summary"
+    },
+    "table-fake-caption": {
+      "description": "Garantizar que las tablas con título usan el elemento <caption>.",
+      "help": "Las celdas de datos o de encabezados no deberían usarse para dar título a una tabla de datos."
+    },
+    "td-has-header": {
+      "description": "Garantizar que cada celda de datos no vacía de una tabla grande tiene uno o más encabezados de tabla",
+      "help": "Todos los elementos td no vacíos de una tabla mayor que 3 por 3 deben tener un encabezado de tabla asociado"
+    },
+    "td-headers-attr": {
+      "description": "Garantizar que cada celda que use los encabezados en una tabla haga referencia a otra celda de esa tabla",
+      "help": "Todas las celdas de un elemento table que usen el atributo headers deben hacer referencia solo a otras celdas de esa misma tabla"
+    },
+    "th-has-data-cells": {
+      "description": "Garantizar que cada encabezado de tabla en una tabla de datos hace referencia a celdas de datos",
+      "help": "Todos los elementos th y elementos con role=columnheader/rowheader deben tener las celdas de datos que describen"
+    },
+    "valid-lang": {
+      "description": "Garantiza que los atributos lang tienen valores válidos",
+      "help": "El atributo lang debe tener un valor válido"
+    },
+    "video-caption": {
+      "description": "Garantiza que los elementos <video> tienen subtítulos",
+      "help": "Los elementos <video> deben tener subtítulos"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "No se usan 'abstract roles'",
+      "fail": "Los 'abstract roles' no se pueden usar directamente"
+    },
+    "aria-allowed-attr": {
+      "pass": "Los atributos ARIA se usan correctamente para el rol definido",
+      "fail": {
+        "singular": "En ARIA, atributos no están permitidos : ${data.values}",
+        "plural": "En ARIA, atributono está permitido : ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "El rol ARIA está permitido para el elemento proporcionado",
+      "fail": {
+        "singular": "En ARIA, roles ${data.values} no están permitidos para el elemento proporcionado",
+        "plural": "En ARIA, role ${data.values}  no está permitido para el elemento proporcionado"
+      },
+      "incomplete": {
+        "singular": "En ARIA, hay que eliminar roles ${data.values} cuando el elemento se haga visible, ya que no están permitidos para el elemento",
+        "plural": "En ARIA, hay que eliminar role ${data.values} cuando el elemento se haga visible, ya que no está permitido para el elemento"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "No hay ningún atributo aria-hidden presente en el 'body' del documento",
+      "fail": "aria-hidden=true no debe estar presente en el 'body' del documento"
+    },
+    "aria-errormessage": {
+      "pass": "Usa una técnica admitida para aria-errormessage",
+      "fail": {
+        "singular": "En aria-errormessage, valores  ${data.values}`, se debe usar una técnica para anunciar el mensaje (p. ej., aria-live, aria-describedby, role=alert, etc.)",
+        "plural": "En aria-errormessage, valor  ${data.values}`, se debe usar una técnica para anunciar el mensaje (p. ej., aria-live, aria-describedby, role=alert, etc.)"
+      }
+    },
+    "has-widget-role": {
+      "pass": "El elemento tiene un rol de widget.",
+      "fail": "El elemento no tiene un rol de widget."
+    },
+    "invalidrole": {
+      "pass": "El rol ARIA es válido",
+      "fail": "El rol debe ser uno de los roles ARIA válidos"
+    },
+    "no-implicit-explicit-label": {
+      "pass": "No hay discordancia entre un <label> y el nombre accesible",
+      "incomplete": "Comprobar que el <label> no necesita ser parte del ARIA ${data} para el nombre del campo"
+    },
+    "aria-required-attr": {
+      "pass": "Todos los atributos ARIA requeridos están presentes",
+      "fail": {
+        "singular": "Atributos requeridos no presentes: ${data.values}",
+        "plural": "Atributo requerido no presente: ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Los hijos ARIA requeridos están presentes"
+      },
+      "fail": {
+        "singular": "Rol de hijos requerido en ARIA no presente: ${data.values}",
+        "plural": "Rol de hijo requerido en ARIA no presente: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Esperando que se añada rol ARIA para hijos: ${data.values}",
+        "plural": "Esperando que se añada rol ARIA para hijo: ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "Rol de padre requerido en ARIA presente",
+      "fail": {
+        "singular": "Rol de ARIA requerido para padre s no presente: ${data.values}",
+        "plural": "Rol de ARIA requerido para padre  no presente: ${data.values}"
+      }
+    },
+    "aria-unsupported-attr": {
+      "pass": "El atributo ARIA está admitido",
+      "fail": "El atributo ARIA no está ampliamente admitido en lectores de pantalla y tecnologías de apoyo:  ${data.values}"
+    },
+    "unsupportedrole": {
+      "pass": "El rol ARIA está admitido",
+      "fail": "El rol usado no está ampliamente admitido en lectores de pantalla y tecnologías de apoyo:  ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "Los valores de los atributos ARIA son válidos",
+      "fail": {
+        "singular": "Valores no válidos para atributo ARIA: ${data.values}",
+        "plural": "Valor no válido para atributo ARIA: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Atributos ARIA ID de elemento no existe en la página: ${data.values}",
+        "plural": "Atributo ARIA ID de elemento no existe en la página: ${data.values}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "Nombres de atributos ARIA válidos",
+        "plural": "Nombrede atributo ARIA válido"
+      },
+      "fail": {
+        "singular": "Nombres de atributos ARIA no válidos:  ${data.values}",
+        "plural": "Nombre de atributo ARIA no válido:  ${data.values}"
+      }
+    },
+    "valid-scrollable-semantics": {
+      "pass": "El elemento tiene una semántica válida para un elemento en orden de foco.",
+      "fail": "El elemento tiene una semántica no válida para un elemento en orden de foco."
+    },
+    "color-contrast": {
+      "pass": "El elemento tiene un contraste de color suficiente de ${data.contrastRatio}",
+      "fail": "El elemento tiene un contraste de color insuficiente de ${data.contrastRatio} (color de primer plano: ${data.fgColor}, color de fondo: ${data.bgColor}, tamaño de fuente: ${data.fontSize}, grosor de fuente: ${data.fontWeight}). Ratio de contraste esperado: ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "El color de fondo del elemento no se pudo determinar debido a una imagen de fondo",
+        "bgGradient": "El color de fondo del elemento no se pudo determinar debido a un degradado de fondo",
+        "imgNode": "El color de fondo del elemento no se pudo determinar porque el elemento contiene un nodo de imagen",
+        "bgOverlap": "El color de fondo no se pudo determinar porque tiene otro elemento superpuesto",
+        "fgAlpha": "El color de fondo no se pudo determinar debido a una transparencia alfa",
+        "elmPartiallyObscured": "El color de fondo no se pudo determinar porque está parcialmente oculto por otro elemento",
+        "elmPartiallyObscuring": "El color de fondo del elemento no se pudo determinar porque se superpone parcialmente a otros elementos",
+        "outsideViewport": "El color de fondo del elemento no se pudo determinar porque está fuera de la ventana gráfica ('viewport')",
+        "equalRatio": "El elemento tiene una ratio de contraste 1:1 con el fondo",
+        "shortTextContent": "El contenido del elemento es demasiado corto para determinar si es contenido de texto propiamente dicho",
+        "default": "Imposible determinar la ratio de contraste"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "El elemento tiene un contraste de color suficiente de ${data.contrastRatio}",
+      "fail": "El elemento tiene un contraste de color insuficiente de ${data.contrastRatio} (color de primer plano: ${data.fgColor}, color de fondo: ${data.bgColor}, tamaño de fuente: ${data.fontSize}, grosor de fuente: ${data.fontWeight}). Ratio de contraste esperado: ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "El color de fondo del elemento no se pudo determinar debido a una imagen de fondo",
+        "bgGradient": "El color de fondo del elemento no se pudo determinar debido a un degradado de fondo",
+        "imgNode": "El color de fondo del elemento no se pudo determinar porque el elemento contiene un nodo de imagen",
+        "bgOverlap": "El color de fondo no se pudo determinar porque tiene otro elemento superpuesto",
+        "fgAlpha": "El color de fondo no se pudo determinar debido a una transparencia alfa",
+        "elmPartiallyObscured": "El color de fondo no se pudo determinar porque está parcialmente oculto por otro elemento",
+        "elmPartiallyObscuring": "El color de fondo del elemento no se pudo determinar porque se superpone parcialmente a otros elementos",
+        "outsideViewport": "El color de fondo del elemento no se pudo determinar porque está fuera de la ventana gráfica ('viewport')",
+        "equalRatio": "El elemento tiene una ratio de contraste 1:1 con el fondo",
+        "shortTextContent": "El contenido del elemento es demasiado corto para determinar si es contenido de texto propiamente dicho",
+        "default": "Imposible determinar la ratio de contraste"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Los enlaces se pueden distinguir respecto al texto adyacente de forma ajena al color",
+      "fail": "Es necesario distinguir los enlaces respecto al texto adyacente de una forma ajena al color",
+      "incomplete": {
+        "bgContrast": "No se pudo determinar la ratio de contraste del elemento. Comprobar si existe un estilo hover/focus distinto",
+        "bgImage": "La ratio de contraste del elemento no se pudo determinar debido a una imagen de fondo",
+        "bgGradient": "La ratio de contraste del elemento no se pudo determinar debido a un degradado de fondo",
+        "imgNode": "La ratio de contraste del elemento no se pudo determinar porque el elemento contiene un nodo de imagen",
+        "bgOverlap": "La ratio de contraste del elemento no se pudo determinar debido a superposición de elementos",
+        "default": "Imposible determinar la ratio de contraste"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "el valor de autocomplete está en un elemento apropiado",
+      "fail": "el valor de autocomplete es inapropiado para este tipo de input"
+    },
+    "autocomplete-valid": {
+      "pass": "el atributo autocomplete está formateado correctamente",
+      "fail": "el atributo autocomplete está formateado incorrectamente"
+    },
+    "accesskeys": {
+      "pass": "El valor del atributo accesskey es único",
+      "fail": "El documento tiene múltiples elementos con el mismo accesskey"
+    },
+    "focusable-content": {
+      "pass": "El elemento contiene elementos que admiten el foco",
+      "fail": "El elemento debería tener contenido que admita el foco"
+    },
+    "focusable-disabled": {
+      "pass": "Dentro del elemento no hay elementos que admitan el foco",
+      "fail": "El contenido que admita el foco debería ser desactivado o eliminado del DOM"
+    },
+    "focusable-element": {
+      "pass": "El elemento admite el foco",
+      "fail": "El elemento debería admitir el foco"
+    },
+    "focusable-no-name": {
+      "pass": "El elemento no está en orden de tabulación o tiene texto accesible",
+      "fail": "El elemento está en orden de tabulación y no tiene texto accesible"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Dentro del elemento no hay elementos que admitan el foco",
+      "fail": "El contenido que admita el foco debería tener tabindex='-1' o ser eliminado del DOM"
+    },
+    "landmark-is-top-level": {
+      "pass": "El punto de referencia ${data.role} está en el nivel superior.",
+      "fail": "El punto de referencia ${data.role} está contenido en otro punto de referencia."
+    },
+    "page-has-heading-one": {
+      "pass": "La página tiene al menos un encabezado de nivel 1",
+      "fail": "La página debe tener un encabezado de nivel 1"
+    },
+    "page-has-main": {
+      "pass": "El documento tiene al menos un punto de referencia main",
+      "fail": "El documento no tiene punto de referencia main"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "El documento no tiene más de un punto de referencia banner",
+      "fail": "El documento tiene más de un punto de referencia banner"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "El documento no tiene más de un punto de referencia contentinfo",
+      "fail": "El documento tiene más de un punto de referencia contentinfo"
+    },
+    "page-no-duplicate-main": {
+      "pass": "El documento no tiene más de un punto de referencia main",
+      "fail": "El documento tiene más de un punto de referencia main"
+    },
+    "tabindex": {
+      "pass": "El elemento no tiene un tabindex mayor que 0",
+      "fail": "El elemento tiene un tabindex mayor que 0"
+    },
+    "alt-space-value": {
+      "pass": "El elemento tiene un valor válido para el atributo alt",
+      "fail": "El elemento tiene un atributo alt que contiene solo un carácter de espacio, que no es ignorado por todos los lectores de pantalla"
+    },
+    "duplicate-img-label": {
+      "pass": "El elemento no duplica texto existente en el texto alternativo de <img>",
+      "fail": "El elemento contiene un elemento <img> con texto alternativo que duplica texto existente"
+    },
+    "explicit-label": {
+      "pass": "El elemento de formulario tiene un <label> explícito",
+      "fail": "El elemento de formulario no tiene un <label> explícito"
+    },
+    "help-same-as-label": {
+      "pass": "El texto de ayuda (title o aria-describedby) no duplica el texto de label",
+      "fail": "El texto de ayuda (title o aria-describedby) es el mismo que el texto de label"
+    },
+    "hidden-explicit-label": {
+      "pass": "El elemento de formulario tiene un <label> explícito visible",
+      "fail": "El elemento de formulario tiene un <label> explícito oculto"
+    },
+    "implicit-label": {
+      "pass": "El elemento de formulario tiene un <label> implícito ('envuelto')",
+      "fail": "El elemento de formulario no tiene un <label> implícito ('envuelto')"
+    },
+    "label-content-name-mismatch": {
+      "pass": "El elemento contiene texto visible como parte de su nombre accesible",
+      "fail": "El texto contenido en el elemento no está incluido en el nombre accesible"
+    },
+    "multiple-label": {
+      "pass": "El campo de formulario no tiene múltiples elementos label",
+      "fail": "Múltiples elementos label no son ampliamente admitidos en las tecnologías de apoyo"
+    },
+    "title-only": {
+      "pass": "El elemento de formulario no usa únicamente el atributo title para su etiqueta",
+      "fail": "Solo se usó title para generar la etiqueta de un elemento de formulario"
+    },
+    "landmark-is-unique": {
+      "pass": "Los puntos de referencia deben tener una combinación única de role o role/label/title (es decir, un nombre accesible único)",
+      "fail": "El punto de referencia debe tener un aria-label, aria-labelledby o title único para que los puntos de referencia sean distinguibles"
+    },
+    "has-lang": {
+      "pass": "El elemento <html> tiene un atributo lang",
+      "fail": "El elemento <html> no tiene un atributo lang"
+    },
+    "valid-lang": {
+      "pass": "El valor del atributo lang está incluido en la lista de idiomas válidos",
+      "fail": "Valor del atributo lang no incluido en la lista de idiomas válidos"
+    },
+    "xml-lang-mismatch": {
+      "pass": "Los atributos lang y xml:lang tienen el mismo idioma base",
+      "fail": "Los atributos lang y xml:lang no tienen el mismo idioma base"
+    },
+    "dlitem": {
+      "pass": "El elemento de lista de descripción tiene un elemento <dl> padre",
+      "fail": "El elemento de lista de descripción no tiene un elemento <dl> padre"
+    },
+    "listitem": {
+      "pass": "El elemento de lista tiene un elemento padre <ul>, <ol> o role=\"list\"",
+      "fail": "El elemento de lista no tiene un elemento padre <ul>, <ol> o role=\"list\""
+    },
+    "only-dlitems": {
+      "pass": "El elemento de lista solo tiene hijos directos que están permitidos dentro de elementos <dt> o <dd>",
+      "fail": "El elemento de lista tiene hijos directos que no están permitidos dentro de elementos <dt> o <dd>"
+    },
+    "only-listitems": {
+      "pass": "El elemento de lista solo tiene hijos directos que están permitidos dentro de elementos <li>",
+      "fail": "El elemento de lista tiene hijos directos que no están permitidos dentro de elementos <li>"
+    },
+    "structured-dlitems": {
+      "pass": "Cuando no está vacío, el elemento tiene tanto elementos <dt> como <dd>",
+      "fail": "Cuando no está vacío, el elemento no tiene al menos un elemento <dt> seguido por, al menos, un elemento <dd>"
+    },
+    "caption": {
+      "pass": "El elemento multimedia tiene una pista de subtítulos",
+      "incomplete": "Comprobar que hay disponibles subtítulos para el elemento"
+    },
+    "frame-tested": {
+      "pass": "El marco incorporado fue probado con axe-core",
+      "fail": "El marco incorporado no se pudo probar con axe-core",
+      "incomplete": "El marco incorporado aún tiene que probarse con axe-core"
+    },
+    "css-orientation-lock": {
+      "pass": "La pantalla es manejable y no existe bloqueo de orientación",
+      "fail": "Se aplica bloqueo de orientación CSS y hace que la pantalla sea inmanejable",
+      "incomplete": "No se puede determinar  si hay bloqueo de orientación CSS"
+    },
+    "meta-viewport-large": {
+      "pass": "La etiqueta <meta> no impide un zum significativo en dispositivos móviles",
+      "fail": "La etiqueta <meta> limita el zum en dispositivos móviles"
+    },
+    "meta-viewport": {
+      "pass": "La etiqueta <meta> no impide el zum en dispositivos móviles",
+      "fail": "${data} en la etiqueta <meta> impide el zum en dispositivos móviles"
+    },
+    "header-present": {
+      "pass": "La página tiene un 'header'",
+      "fail": "La página no tiene un 'header'"
+    },
+    "heading-order": {
+      "pass": "Horden de encabezados válido",
+      "fail": "Orden de encabezados no válido"
+    },
+    "internal-link-present": {
+      "pass": "Encontrado enlace de salto ('skip') válido",
+      "fail": "No se han encontrado enlaces de salto ('skip') válidos"
+    },
+    "landmark": {
+      "pass": "La página tiene una región punto de referencia",
+      "fail": "La página no tiene una región punto de referencia"
+    },
+    "meta-refresh": {
+      "pass": "La etiqueta <meta> no refresca la página inmediatamente",
+      "fail": "La etiqueta <meta> fuerza el refresco programado de la página"
+    },
+    "p-as-heading": {
+      "pass": "Los elementos <p> no se han diseñado como encabezados",
+      "fail": "Deberían usarse elementos de encabezado en vez de elementos <p> con estilos"
+    },
+    "region": {
+      "pass": "Todo el contenido de la página está incluido en puntos de referencia",
+      "fail": "La página tiene contenido no incluido en puntos de referencia"
+    },
+    "skip-link": {
+      "pass": "Existe el destino del enlace de salto ('skip')",
+      "incomplete": "El destino del enlace de salto ('skip') debería volverse visible en la activación",
+      "fail": "No hay destino para el enlace de salto ('skip')"
+    },
+    "unique-frame-title": {
+      "pass": "El atributo title del elemento es único",
+      "fail": "El atributo title del elemento no es único"
+    },
+    "duplicate-id-active": {
+      "pass": "El documento no tiene elementos activos que compartan el mismo atributo id",
+      "fail": "El documento tiene elementos activos con el mismo atributo id: ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "El documento no tiene elementos referidos con ARIA o etiquetas que compartan el mismo atributo id",
+      "fail": "El documento tiene múltiples elementos referidos con ARIA con el mismo atributo id: ${data}"
+    },
+    "duplicate-id": {
+      "pass": "El documento no tiene elementos estáticos que compartan el mismo atributo id",
+      "fail": "El documento tiene múltiples elementos estáticos con el mismo atributo id"
+    },
+    "aria-label": {
+      "pass": "El atributo aria-label existe y no está vacío",
+      "fail": "El atributo aria-label no existe o está vacío"
+    },
+    "aria-labelledby": {
+      "pass": "El atributo aria-labelledby existe y hace referencia a elementos visibles para lectores de pantalla",
+      "fail": "El atributo aria-labelledby no existe, hace referencia a elementos inexistentes o hace referencia a elementos vacíos"
+    },
+    "avoid-inline-spacing": {
+      "pass": "No se han especificado estilos 'inline' con '!important' que afecten al espaciado de texto",
+      "fail": {
+        "singular": "Eliminar '!important' de inline styles ${data.values}, porque su anulación no está admitida en la mayoría de navegadores",
+        "plural": "Eliminar '!important' de inline style ${data.values}, porque su anulación no está admitida en la mayoría de navegadores"
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "El elemento tiene texto interno visible para lectores de pantalla",
+      "fail": "El elemento no tiene texto interno visible para lectores de pantalla"
+    },
+    "doc-has-title": {
+      "pass": "El documento tiene un elemento <title> no vacío",
+      "fail": "El documento no tiene un elemento <title> no vacío"
+    },
+    "exists": {
+      "pass": "El elemento no existe",
+      "fail": "El elemento existe"
+    },
+    "has-alt": {
+      "pass": "El elemento tiene un atributo alt",
+      "fail": "El elemento no tiene un atributo alt"
+    },
+    "has-visible-text": {
+      "pass": "El elemento tiene texto visible para lectores de pantalla",
+      "fail": "El elemento no tiene texto visible para lectores de pantalla"
+    },
+    "is-on-screen": {
+      "pass": "El elemento no es visible",
+      "fail": "El elemento es visible"
+    },
+    "non-empty-alt": {
+      "pass": "El elemento tiene un atributo alt no vacío",
+      "fail": "El elemento no tiene atributo alt o el atributo alt está vacío"
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": "El elemento no tiene un atributo de valor",
+        "has-label": "El elemento tiene un atributo de valor no vacío"
+      },
+      "fail": "El elemento tiene un atributo de valor y el atributo de valor está vacío"
+    },
+    "non-empty-title": {
+      "pass": "El elemento tiene un atributo title",
+      "fail": "El elemento no tiene atributo title o el atributo title está vacío"
+    },
+    "non-empty-value": {
+      "pass": "El elemento tiene un atributo de valor no vacío",
+      "fail": "El elemento no tiene un atributo de valor o el atributo de valor está vacío"
+    },
+    "role-none": {
+      "pass": "La semántica predeterminada del elemento se anuló mediante role=\"none\"",
+      "fail": "La semántica predeterminada del elemento no se anuló mediante role=\"none\""
+    },
+    "role-presentation": {
+      "pass": "La semántica predeterminada del elemento se anuló mediante role=\"presentation\"",
+      "fail": "La semántica predeterminada del elemento no se anuló mediante role=\"presentation\""
+    },
+    "caption-faked": {
+      "pass": "La primera fila de una tabla no se usa como título ('caption')",
+      "fail": "La primera fila de la tabla debería ser un título ('caption') en vez de una celda de tabla"
+    },
+    "html5-scope": {
+      "pass": "El atributo scope solo se usa en elementos de encabezados de tabla (<th>)",
+      "fail": "En HTML 5, los atributos scope solo se pueden usar en elementos de encabezados de tabla (<th>)"
+    },
+    "same-caption-summary": {
+      "pass": "El contenido del atributo summary y de <caption> no están duplicados",
+      "fail": "El contenido del atributo summary y del elemento <caption> son idénticos"
+    },
+    "scope-value": {
+      "pass": "El atributo scope se usa correctamente",
+      "fail": "El valor del atributo scope solo puede ser 'row' o 'col'"
+    },
+    "td-has-header": {
+      "pass": "Todas las celdas de datos no vacías tienen encabezados de tabla",
+      "fail": "Algunas celdas de datos no vacías no tienen encabezados de tabla"
+    },
+    "td-headers-attr": {
+      "pass": "El atributo headers se usa exclusivamente para hacer referencia a otras celdas de la tabla",
+      "fail": "El atributo headers no se usa exclusivamente para hacer referencia a otras celdas de la tabla"
+    },
+    "th-has-data-cells": {
+      "pass": "Todas las celdas de encabezados de tabla hacen referencia a celdas de datos",
+      "fail": "No todas las celdas de encabezados de tabla hacen referencia a celdas de datos",
+      "incomplete": "Hay celdas de datos de la tabla ausentes o vacías"
+    },
+    "hidden-content": {
+      "pass": "Se ha analizado todo el contenido de la página.",
+      "fail": "Hubo problemas al analizar el contenido de esta página.",
+      "incomplete": "Hay contenido oculto en la página que no fue analizado. Necesitarás activar la visualización de este contenido a fin de analizarlo."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Corregir cualquiera de las siguientes incidencias:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Corregir (todas) las siguientes incidencias:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "Corregir (todas) las siguientes incidencias:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+}

node_modules/axe-core/locales/eu.json

@@ -0,0 +1,789 @@
+{
+  "lang": "eu",
+  "rules": {
+    "accesskeys": {
+      "description": "Accesskey atributurako balio bakoitza bakarra dela bermatzen du",
+      "help": "Accesskey atributuaren balioak bakarra izan behar du"
+    },
+    "area-alt": {
+      "description": "Irudi-mapetako <area> elementuek ordezko testua dutela bermatzen du",
+      "help": "<area> elementu aktiboek ordezko testua izan behar dute"
+    },
+    "aria-allowed-attr": {
+      "description": "ARIA atributuak elementu baten rolerako baimenduta daudela bermatzen du",
+      "help": "Elementuek atributu ARIA baimenduak baino ez dituzte erabili behar"
+    },
+    "aria-allowed-role": {
+      "description": "rol atributuak elementuarentzat balio egokia duela bermatzen du",
+      "help": "ARIA role egokia izan behar da elementuarentzat"
+    },
+    "aria-hidden-body": {
+      "description": "Bermatzen du aria-hidden = 'true' ez dagoela dokumentuaren 'body'an.",
+      "help": "aria-hidden = 'true' ez da dokumentuaren 'body'an egon behar"
+    },
+    "aria-hidden-focus": {
+      "description": "Bermatzen du 'aria-hidden' elementuek ez dutela fokua onartzen duen elementurik",
+      "help": "'ARIA hidden' elementuek ez dute fokua onartzen duen elementurik izan behar"
+    },
+    "aria-input-field-name": {
+      "description": "Bermatzen du 'ARIA input field' bakoitzak izen irisgarria duela",
+      "help": "'ARIA input fields' ek izen erabilerraza dute"
+    },
+    "aria-required-attr": {
+      "description": "Bermatzen du 'ARIA role' duten elementuek eskatzen diren atributu guztiak dituztela",
+      "help": "Eskatzen diren ARIA atributuak eman behar dira"
+    },
+    "aria-required-children": {
+      "description": "Bermatzen du 'ARIA role' bat duten eta 'child rol' bat behar duten elementuek",
+      "help": "Zenbait 'ARIA rolak' seme jakin batzuk izan behar dituzte"
+    },
+    "aria-required-parent": {
+      "description": "Bermatzen du 'ARIA role' bat duten eta 'parent rol'ak eskatzen dituzten elementuak haietan jasota daudela",
+      "help": "Zenbait 'ARIA rol' aita jakin batzuengan eduki behar dira"
+    },
+    "aria-roles": {
+      "description": "Role atributua duten elementu guztiek balio balioduna erabiltzen dutela bermatzen du",
+      "help": "Erabilitako 'ARIA rol'ek baliozko balioetarako baldintzak bete behar dituzte"
+    },
+    "aria-toggle-field-name": {
+      "description": "Bermatzen du 'ARIA toggle field' bakoitzak izen irisgarria duela",
+      "help": "'ARIA toggle fields'ek izen erabilerraza dute"
+    },
+    "aria-valid-attr-value": {
+      "description": "Atributu ARIA guztiek balio baliodunak dituztela bermatzen du",
+      "help": "ARIA Atributuek baliozko balioetarako baldintzak bete behar dituzte"
+    },
+    "aria-valid-attr": {
+      "description": "aria-z hasten diren atributuak baliozko atributu ARIA direla bermatzen du",
+      "help": "ARIA atributuek izen baliodunen baldintzak bete behar dituzte"
+    },
+    "audio-caption": {
+      "description": "<audio> elementuek azpitituluak dituztela bermatzen du",
+      "help": "<audio> elementuek azpititulu-pista bat izan behar dute"
+    },
+    "autocomplete-valid": {
+      "description": "autocomplete atributua formulario-eremurako zuzena eta egokia dela bermatzea",
+      "help": "autocomplete atributua behar bezala erabili behar da"
+    },
+    "avoid-inline-spacing": {
+      "description": "style atributuen bidez ezarritako testu-tartea estilo-orri pertsonalizatuekin doitu daitekeela bermatzea",
+      "help": "'inline' testu-tartea doitu egin behar da, estilo-orri pertsonalizatuen bidez."
+    },
+    "blink": {
+      "description": "Bermatzen du ez direla <blink> elementuak erabiltzen",
+      "help": "<blink> elementuak zaharkituta daude eta ez dira erabili behar"
+    },
+    "button-name": {
+      "description": "Botoiek testu bereizgarria dutela bermatzen du",
+      "help": "Botoiek testu bereizgarria izan behar dute"
+    },
+    "bypass": {
+      "description": "Orrialde bakoitzak gutxienez bitarteko bat duela bermatzen du, erabiltzaile batek nabigazioa gainditu eta edukira zuzenean pasatzeko aukera izan dezan",
+      "help": "Orriek bloke errepikatuak saltatzeko baliabideak izan behar dituzte"
+    },
+    "color-contrast": {
+      "description": "Lehen planoko eta hondoko koloreen arteko kontrasteak WCAG 2 AA kontrasterako ratioaren mugak betetzen dituela bermatzen du.",
+      "help": "Elementuek kolore-kontraste nahikoa izan behar dute"
+    },
+    "color-contrast-enhanced": {
+      "description": "Lehen planoko eta hondoko koloreen arteko kontrasteak WCAG 2 AAA kontrasterako ratioaren mugak betetzen dituela bermatzen du.",
+      "help": "Elementuek kolore-kontraste nahikoa izan behar dute"
+    },
+    "css-orientation-lock": {
+      "description": "Bermatzen du edukia ez dagoela blokeatuta pantailako orientazio espezifiko batean, eta edukia maneiagarria dela pantailako edozein orientabidetan.",
+      "help": "'CSS Media query'ak ez dira erabiltzen pantailaren orientazioa blokeatzeko "
+    },
+    "definition-list": {
+      "description": "<dl> elementuak behar bezala egituratuta daudela bermatzen du",
+      "help": "<dl> elementuek zuzenean eduki behar dituzte <dt> eta <dd> multzoak , behar bezala ordenatuta , edo <script> edo <tenplate> elementuak"
+    },
+    "dlitem": {
+      "description": "Bermatzen du <dt> eta <dd> elementuak <dl> batean daudela.",
+      "help": "<dt> eta <dd> elementuek < dl> batean egon behar dute"
+    },
+    "document-title": {
+      "description": "HTML dokumentu bakoitzak <title> hutsik ez duen elementu bat duela bermatzen du",
+      "help": "Dokumentuek <title> elementuak izan behar dituzte nabigazioan laguntzeko"
+    },
+    "duplicate-id-active": {
+      "description": "Elementu aktiboen id atributurako balio bakoitza bakarra dela bermatzen du",
+      "help": "Elementu aktiboen 'ID'ak bakarrak izan behar dira"
+    },
+    "duplicate-id-aria": {
+      "description": "ARIAn eta 'label'etan erabilitako id atributuaren balio bakoitza bakarra dela bermatzen du",
+      "help": "ARIA eta labelet-an erabiltzen diren 'ID'ak bakarrak izan behar dira"
+    },
+    "duplicate-id": {
+      "description": "id atributurako balio bakoitza bakarra dela bermatzen du",
+      "help": "id atributuaren balioak bakarra izan behar du"
+    },
+    "empty-heading": {
+      "description": "Goiburuek testu bereizgarria dutela bermatzen du",
+      "help": "Goiburuak ez dira hutsik egon behar"
+    },
+    "focus-order-semantics": {
+      "description": "Foku ordenako elementuek rol egokia dutela bermatzen du",
+      "help": "Foku ordenako elementuek rol egokia behar dute eduki interaktiborako"
+    },
+    "form-field-multiple-labels": {
+      "description": "Formulario-eremuak label elementu ugari ez dituela bermatzen du",
+      "help": "Formulario-eremuak ez du label elementu ugari izan behar"
+    },
+    "frame-tested": {
+      "description": "Bermatzen du <iframe> eta <frame> elementuek axe-core scripta dutela",
+      "help": "Markoak axe-core bidez probatu behar dira"
+    },
+    "frame-title-unique": {
+      "description": "Bermatzen du <iframe> eta <frame> elementuek izenburu bakarreko atributua dutela",
+      "help": "Markoek title atributu bakarra izan behar dute"
+    },
+    "frame-title": {
+      "description": "Bermatzen du <iframe> eta <frame> elementuek hutsik ez dagoen izenburuaren atributua dutela",
+      "help": "Markoek title atributua izan behar dute"
+    },
+    "heading-order": {
+      "description": "Goiburuen ordena semantikoki zuzena dela bermatzen du",
+      "help": "Goiburuen maila soilik 1 gehitu beharko litzateke"
+    },
+    "hidden-content": {
+      "description": "Erabiltzaileei ezkutuko edukiari buruzko informazioa ematen die.",
+      "help": "Orriaren ezkutuko edukia ezin da aztertu"
+    },
+    "html-has-lang": {
+      "description": "HTML dokumentu bakoitzak lang atributu bat duela bermatzen du",
+      "help": "<html> elementuak lang atributua izan behar du"
+    },
+    "html-lang-valid": {
+      "description": "Bermatzen du <html> elementuaren lang atributuak balio balioduna duela",
+      "help": "<html> elementuak balio balioduna izan behar du lang atributurako"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "Lang zein xml:lang atributuak dituzten HTML elementuetan  orrialdearen oinarrizko hizkuntzan komunztadura dagoela bermatzea",
+      "help": "lang eta xml:lang duten HTML elementuek oinarrizko hizkuntza bera izan behar dute"
+    },
+    "image-alt": {
+      "description": "Bermatzen du <img> elementuek ordezko testua edo none edo presentation rola dutela",
+      "help": "Irudiek ordezko testua izan behar dute"
+    },
+    "image-redundant-alt": {
+      "description": "Bermatzen du irudiaren alternatiba ez dela testu gisa errepikatuko",
+      "help": "Irudien testu alternatiboa ez da testu gisa errepikatu behar"
+    },
+    "input-button-name": {
+      "description": "'input button'ek testu bereizgarria dutela bermatzea",
+      "help": "'input button'ek testu bereizgarria izan behar dute"
+    },
+    "input-image-alt": {
+      "description": "Bermatzen du <input type =\"image\" > elementuek ordezko testua dutela",
+      "help": "'image buttons'ek testu alternatiboa izan behar dute"
+    },
+    "label-content-name-mismatch": {
+      "description": "Bere edukiaren bidez etiketatutako elementuetan, bere testu ikusgarriak bere izen irisgarriaren parte izan behar duela bermatzen du.",
+      "help": "Elementuek beren testua ikusgai izan behar dute, beren izenaren zati irisgarri gisa."
+    },
+    "label-title-only": {
+      "description": "Bermatzen du inprimakiko elementu bakoitza ez dagoela etiketatuta title edo aria-describedby atributuen bidez soilik.",
+      "help": "Formularioko elementuek etiketa bat izan behar dute ikusgai"
+    },
+    "label": {
+      "description": "Formularioko elementu bakoitzak etiketa bat duela bermatzen du",
+      "help": "Formularioko elementuek etiketak izan behar dituzte"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "Banner erreferentzia-puntua goiko mailan dagoela bermatzen du",
+      "help": "Banner erreferentzia-puntuak ez du beste erreferentzia-puntu batean egon behar"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "Erreferentzia-puntu osagarria edo asidea goiko mailan dagoela bermatzen du ",
+      "help": "aside-k ez du beste erreferentzia-puntu batean egon behar"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "contentinfo erreferentzia-puntua goiko mailan dagoela bermatzen du",
+      "help": "contentinfo erreferentzia-puntuak ez du beste erreferentzia-puntu batean egon behar"
+    },
+    "landmark-main-is-top-level": {
+      "description": "Main erreferentzia puntua goi mailan dagoela bermatzen du",
+      "help": "main erreferentzia-puntuak ez du beste erreferentzia-puntu batean egon behar"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "Dokumentuak, gehienez ere, banner erreferentzia-puntu bat duela bermatzen du",
+      "help": "Dokumentuak ezin du banner erreferentzia-puntu bat baino gehiago izan"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "Dokumentuak, gehienez ere, contentinfo erreferentzia-puntu bat duela bermatzen du",
+      "help": "Dokumentuak ez du izan behar contentinfo erreferentzia-puntu bat baino gehiago"
+    },
+    "landmark-one-main": {
+      "description": "Bermatzen du dokumentuak main erreferentzia-puntu bakarra duela, eta orrialdean sartutako esparru bakoitzak, gehienez ere, main erreferentzia-puntu bat duela.",
+      "help": "Dokumentuak main erreferentzia-puntu bat izan behar du"
+    },
+    "landmark-unique": {
+      "help": "Erreferentziazko puntuak bakarrak direla bermatzen du",
+      "description": "Erreferentzia-puntuek role edo role/label/title konbinazio bakarra izan behar dute (hau da, izen irisgarri bakarra)"
+    },
+    "link-in-text-block": {
+      "description": "Estekak kolorearen menpe egon gabe bereiz daitezke",
+      "help": "Estekak ondoko testutik bereizi behar dira, kolorearen menpe ez dagoen bitarteko batez."
+    },
+    "link-name": {
+      "description": "Estekek testu bereizgarria dutela bermatzen du",
+      "help": "Estekek testu bereizgarria izan behar dute"
+    },
+    "list": {
+      "description": "Zerrendak behar bezala egituratuta daudela bermatzen du",
+      "help": "<ul> eta <ol> zuzenean <li>, < script> edo < template> elementuak izan behar dituzte"
+    },
+    "listitem": {
+      "description": "<li> elementuak semantikoki erabiltzen direla bermatzen du",
+      "help": "< li> elementuek < ul> edo < ol> batean egon behar dute"
+    },
+    "marquee": {
+      "description": "Bermatzen du ez dela elementurik erabiltzen <marquee>",
+      "help": "<marquee> elementuak zaharkituta daude eta ez dira erabili behar"
+    },
+    "meta-refresh": {
+      "description": "Bermatzen du ez dela erabiltzen <meta http-equiv =\"refresh\" >",
+      "help": "Programatutako freskagarriak ez du egon behar"
+    },
+    "meta-viewport-large": {
+      "description": "Bermatzea <meta name =\"viewport\" > maila esanguratsuan zabal daitekeela",
+      "help": "Erabiltzaileek zooma egiteko eta testua %500era arte zabaltzeko aukera izan behar dute"
+    },
+    "meta-viewport": {
+      "description": "Bermatzen du <meta name =\"viewport\" > ez duela eragozten testua zabaltzea eta zooma egitea",
+      "help": "Zooma eta handitzea ez dira eragotzi behar"
+    },
+    "object-alt": {
+      "description": "Bermatzen du <object> elementuek ordezko testua dutela",
+      "help": "<object> elementuek testu alternatiboa izan behar dute"
+    },
+    "p-as-heading": {
+      "description": "p elementuak goiburuak diseinatzeko erabiltzen ez direla bermatzea",
+      "help": "Ez da letra lodiz, letra etzanez edo letra-iturri tamainaz idatzitako testurik erabiltzen p elementuei goiburu-estiloa emateko."
+    },
+    "page-has-heading-one": {
+      "description": "Orrialdeak, edo gutxienez bere esparruetako batek, 1. mailako goiburu bat duela bermatzea",
+      "help": "Orrialdeak 1. mailako goiburu bat izan behar du"
+    },
+    "region": {
+      "description": "Orrialdeko eduki guztia erreferentzia-puntuetan sartuta dagoela bermatzen du.",
+      "help": "Orrialdeko eduki guztiak erreferentzia-puntuetan sartuta egon behar du"
+    },
+    "role-img-alt": {
+      "description": "Elementuek [role = 'img'] testu alternatiboa dutela bermatzen du",
+      "help": "[role = 'img'] elementuek testu alternatibo bat dute"
+    },
+    "scope-attr-valid": {
+      "description": "scope atributua tauletan behar bezala erabiltzen dela bermatzen du",
+      "help": "Scope atributua behar bezala erabili beharko litzateke"
+    },
+    "scrollable-region-focusable": {
+      "description": "Bertikalki mugi daitekeen edukia duten elementuak ('scroll' formatuan) teklatuaren bidez eskuratu ahal izango lirateke.",
+      "help": "Joan-etorri bertikaleko eremuak ('scroll') teklatu bidezko sarbidea duela ziurtatzea"
+    },
+    "server-side-image-map": {
+      "description": "Zerbitzariaren aldeko irudi-maparik ez dela erabiltzen bermatzen du.",
+      "help": "Ez dira erabili behar zerbitzariaren aldeko irudi-mapak"
+    },
+    "skip-link": {
+      "description": "Salto-esteka guztiek ('skip') fokua onartzen duen helmuga dutela bermatzea",
+      "help": "Jauziko loturaren ('skip') helmugak egon beharko luke eta fokua onartu"
+    },
+    "tabindex": {
+      "description": "tabindex atributuaren balioak 0 baino handiagoak ez direla bermatzen du",
+      "help": "Elementuek ez lukete 0 baino tabindex handiagoa izan behar"
+    },
+    "table-duplicate-name": {
+      "description": "Taulek summary eta caption bera ez dutela bermatzea",
+      "help": "<caption> elementuak ez luke summary atributuaren testu bera izan behar"
+    },
+    "table-fake-caption": {
+      "description": "Titulua duten taulek <caption> elementua erabiltzen dutela bermatzea.",
+      "help": "Datuen edo goiburuen gelaxkak ez lirateke erabili behar datu-taula bati izenburua emateko."
+    },
+    "td-has-header": {
+      "description": "Taula handi batean hutsik ez dagoen datu-gelaxka bakoitzak taula-goiburu bat edo gehiago dituela bermatzea",
+      "help": "3 bider 3 baino taula handiagoko td elementu ez huts guztiek lotutako taula-goiburu bat izan behar dute"
+    },
+    "td-headers-attr": {
+      "description": "Taula bateko goiburuak erabiltzen dituen gelaxka bakoitzak taula horretako beste gelaxka bati erreferentzia egiten diola bermatzea",
+      "help": "headers atributua erabiltzen duten elementu table baten gelaxka guztiek taula bereko beste gelaxka batzuei bakarrik egin behar diete erreferentzia"
+    },
+    "th-has-data-cells": {
+      "description": "Datu-taula bateko taula-goiburu bakoitzak datu-gelaxkak aipatzen dituela bermatzea",
+      "help": "th eta 'role = columnheader/rowheader 'duten elementu guztiek deskribatzen duten datu-gelaxkak izan behar dituzte:"
+    },
+    "valid-lang": {
+      "description": "lang atributuek balio baliodunak dituztela bermatzen du",
+      "help": "lang atributuak balio balioduna izan behar du"
+    },
+    "video-caption": {
+      "description": "Bermatzen du <video> elementuek azpitituluak dituztela",
+      "help": "<bideo> elementuek azpitituluak izan behar dituzte"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "Ez dira 'abstract rolak' erabiltzen",
+      "fail": "'abstract rolak 'ezin dira zuzenean erabili"
+    },
+    "aria-allowed-attr": {
+      "pass": "ARIA atributuak behar bezala erabiltzen dira zehaztutako rolerako",
+      "fail": {
+        "singular": "ARIAn, atributuak ez daude baimenduta : ${data.values}",
+        "plural": "ARIAn, atributua ez dago baimenduta : ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "ARIA rola baimenduta dago emandako elementurako",
+      "fail": {
+        "singular": "ARIAn, rolak ${data.values} -ak ez daude baimenduta emandako elementurako",
+        "plural": "ARIAn, rola ${data.values} -a ez dago baimenduta emandako elementurako"
+      },
+      "incomplete": {
+        "singular": "AREAN, rolak kendu behar dira ${data.values} elementua ikusgai egiten denean, zeren elementurako  ez daude baimenduta",
+        "plural": "AREAN, rola kendu behar da ${data.values} elementua ikusgai egiten denean, zeren elementurako  ez dago baimenduta"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "Ez dago dokumentuko 'body'ean agertzen den aria-hidden atributurik",
+      "fail": "aria-hidden = true ez da dokumentuaren 'body'ean egon behar"
+    },
+    "aria-errormessage": {
+      "pass": "Teknika onartu bat erabiltzen du aria-errormessagerako",
+      "fail": {
+        "singular": "aria-errormessagen, bailioaes  ${data.values}`, mezua iragartzeko teknika bat erabili behar da (adibidez: aria-live, aria-describedby, role = alert, etab.).",
+        "plural": "aria-errormessagen, bailioa  ${data.values}`, mezua iragartzeko teknika bat erabili behar da (adibidez: aria-live, aria-describedby, role = alert, etab.)."
+      }
+    },
+    "has-widget-role": {
+      "pass": "Elementuak widget rola du.",
+      "fail": "Elementuak ez du widget rolik."
+    },
+    "invalidrole": {
+      "pass": "ARIA rola baliozkoa da",
+      "fail": "Rolak baliozko ARIA rola izan behar du"
+    },
+    "no-implicit-explicit-label": {
+      "pass": "Ez dago desadostasunik <label> baten eta izen irisgarriaren artean",
+      "incomplete": "Egiaztatu < label> zenbakiak ez duela zertan ARIAren ${data} parte izan eremuaren izenerako"
+    },
+    "aria-required-attr": {
+      "pass": "ARIA atributu guztiak daude",
+      "fail": {
+        "singular": "Eskatutako atributuak ez daude: ${data.values}",
+        "plural": "Eskatutako atributua ez dago: ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Eskatutako ARIA semeak bertan daude"
+      },
+      "fail": {
+        "singular": "Esktatutako ARIARren semeak ez daude : ${data.values}",
+        "plural": "Esktatutako ARIARren semeaez dago : ${data.values}"
+      },
+      "incomplete": {
+        "singular": "ARIA rola semeentzako: ${data.values}",
+        "plural": "ARIA rola semearentzako: ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "ARIAn eskatzen den aitaren rola bertan dago",
+      "fail": {
+        "singular": "ARIAn eskatutako aitentzako rola  ez dago: ${data.values}",
+        "plural": "ARIAn eskatutako aitarentzako rola ez dago: ${data.values}"
+      }
+    },
+    "aria-unsupported-attr": {
+      "pass": "ARIA atributua onartuta dago",
+      "fail": "ARIA atributua ez dago oso onartuta pantaila-irakurgailuetan eta laguntza-teknologietan:  ${data.values}"
+    },
+    "unsupportedrole": {
+      "pass": "ARIA rola onartuta dago",
+      "fail": "Erabilitako rola ez dago oso onartuta pantaila-irakurgailuetan eta laguntza-teknologietan:  ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "ARIA atributuen balioak baliozkoak dira",
+      "fail": {
+        "singular": "Balioak ez dira baliozkoak ARIA atributorako: ${data.values}",
+        "plural": "Balioa ez da baliozkoa ARIA atributorako: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Elementuen atributua  ARIA ID ez dago orrian: ${data.values}",
+        "plural": "Elementuaren atributua  ARIA ID ez dago orrian: ${data.values}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "Baliozko ARIA atributuen izenak",
+        "plural": "Baliozko ARIA atributuen izena"
+      },
+      "fail": {
+        "singular": "Baliogabeko ARIA atributuen izenak:  ${data.values}",
+        "plural": "Baliogabeko ARIA atributuen izenak:  ${data.values}"
+      }
+    },
+    "valid-scrollable-semantics": {
+      "pass": "Elementuak semantika balioduna du foku-ordenan dagoen elementu batentzat.",
+      "fail": "Elementuak foku-ordenan dagoen elementu batentzat baliozkoa ez den semantika bat du.."
+    },
+    "color-contrast": {
+      "pass": "Elementuak ${data.contrastRatio}-ko kolore-kontraste nahikoa du",
+      "fail": "Elementuaren ${data.contrastRatio}-ko kolore-kontrastea ez da nahikoa (ehen planoaren kolorea: ${data.fgColor}, hondoaren kolorea: ${data.bgColor}, letra-iturriaren tamaina: ${data.fontSize}, letra-iturriaren lodiera: ${data.fontWeight}). Espero den kontraste-ratioa: ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementuaren hondoko kolorea ezin izan da zehaztu, hondoko irudi batengatik",
+        "bgGradient": "Elementuaren hondoko kolorea ezin izan da zehaztu hondoko degradatu baten ondorioz",
+        "imgNode": "Elementuaren hondoaren kolorea ezin izan da zehaztu, elementuak irudi-nodo bat duelako.",
+        "bgOverlap": "Hondoko kolorea ezin izan da zehaztu, gainjarritako beste elementu bat duelako",
+        "fgAlpha": "Hondoko kolorea ezin izan da zehaztu alfa gardentasun baten ondorioz",
+        "elmPartiallyObscured": "Hondoaren kolorea ezin izan da zehaztu, beste elementu batek partzialki ezkutatzen duelako",
+        "elmPartiallyObscuring": "Elementuaren hondoaren kolorea ezin izan da zehaztu, beste elementu batzuei partzialki gainjartzen baitzaie.",
+        "outsideViewport": "Elementuaren hondoko kolorea ezin izan da zehaztu, leiho grafikotik kanpo dagoelako ('viewport')",
+        "equalRatio": "Elementuak 1:1 kontraste-ratioa du hondoarekin",
+        "shortTextContent": "Elementuaren edukia laburregia da testu-edukia bera den zehazteko",
+        "default": "Ezinezkoa da kontraste-ratioa zehaztea"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "Elementuak ${data.contrastRatio}-ko kolore-kontraste nahikoa du",
+      "fail": "Elementuaren ${data.contrastRatio}-ko kolore-kontrastea ez da nahikoa (ehen planoaren kolorea: ${data.fgColor}, hondoaren kolorea: ${data.bgColor}, letra-iturriaren tamaina: ${data.fontSize}, letra-iturriaren lodiera: ${data.fontWeight}). Espero den kontraste-ratioa: ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementuaren hondoko kolorea ezin izan da zehaztu, hondoko irudi batengatik",
+        "bgGradient": "Elementuaren hondoko kolorea ezin izan da zehaztu hondoko degradatu baten ondorioz",
+        "imgNode": "Elementuaren hondoaren kolorea ezin izan da zehaztu, elementuak irudi-nodo bat duelako.",
+        "bgOverlap": "Hondoko kolorea ezin izan da zehaztu, gainjarritako beste elementu bat duelako",
+        "fgAlpha": "Hondoko kolorea ezin izan da zehaztu alfa gardentasun baten ondorioz",
+        "elmPartiallyObscured": "Hondoaren kolorea ezin izan da zehaztu, beste elementu batek partzialki ezkutatzen duelako",
+        "elmPartiallyObscuring": "Elementuaren hondoaren kolorea ezin izan da zehaztu, beste elementu batzuei partzialki gainjartzen baitzaie.",
+        "outsideViewport": "Elementuaren hondoko kolorea ezin izan da zehaztu, leiho grafikotik kanpo dagoelako ('viewport')",
+        "equalRatio": "Elementuak 1:1 kontraste-ratioa du hondoarekin",
+        "shortTextContent": "Elementuaren edukia laburregia da testu-edukia bera den zehazteko",
+        "default": "Ezinezkoa da kontraste-ratioa zehaztea"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Estekak ondoko testuarekiko bereiz daitezke, koloretik kanpo",
+      "fail": "Alboko testuarekiko loturak koloretik kanpo bereizi behar dira",
+      "incomplete": {
+        "bgContrast": "Ezin izan da elementuaren kontraste-ratioa zehaztu. Hover/focus estilo desberdina dagoen egiaztatzea",
+        "bgImage": "Elementuaren kontraste-ratioa ezin izan da zehaztu, hondoko irudi batengatik",
+        "bgGradient": "Elementuaren kontraste-ratioa ezin izan da zehaztu hondoko degradatu baten ondorioz",
+        "imgNode": "Elementuaren kontraste-ratioa ezin izan da zehaztu, elementuak irudi-nodo bat duelako.",
+        "bgOverlap": "Elementuaren kontraste-ratioa ezin izan da zehaztu elementuen gainjartzeagatik",
+        "default": "Ezinezkoa da kontraste-ratioa zehaztea"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "autocompleteren balioa elementu egoki batean dago",
+      "fail": "autocompleteren balioa ez da egokia input mota horretarako"
+    },
+    "autocomplete-valid": {
+      "pass": "autocompleteren atributua behar bezala formateatuta dago",
+      "fail": "autocompleteren atributua gaizki formateatuta dago"
+    },
+    "accesskeys": {
+      "pass": "Accesskey atributuaren balioa bakarra da",
+      "fail": "Dokumentuak elementu ugari ditu accesskey berarekin"
+    },
+    "focusable-content": {
+      "pass": "Elementuak fokua onartzen duten elementuak ditu",
+      "fail": "Elementuak fokua onartzen duen edukia izan beharko luke"
+    },
+    "focusable-disabled": {
+      "pass": "Elementuaren barruan ez dago fokua onartzen duen elementurik",
+      "fail": "Fokuak onartzen duen edukia desaktibatu edo ezabatu egin beharko litzateke"
+    },
+    "focusable-element": {
+      "pass": "Elementuak fokua onartzen du",
+      "fail": "Elementuak fokua onartu beharko luke"
+    },
+    "focusable-no-name": {
+      "pass": "Elementua ez dago tabulazio-ordenan edo testu irisgarria du",
+      "fail": "Elementua tabulazio-ordenan dago eta ez du testu eskuragarririk"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Elementuaren barruan ez dago fokua onartzen duen elementurik",
+      "fail": "Fokuak onartzen duen edukiak tabindex = '-1' izan beharko luke edo DOMetik ezabatu beharko litzateke"
+    },
+    "landmark-is-top-level": {
+      "pass": "${data.role} erreferentzia-puntua goiko mailan dago",
+      "fail": "${data.role} erreferentzia-puntua beste erreferentzia-puntu batean dago."
+    },
+    "page-has-heading-one": {
+      "pass": "Orrialdeak 1. mailako goiburu bat du, gutxienez.",
+      "fail": "Orrialdeak 1. mailako goiburu bat izan behar du"
+    },
+    "page-has-main": {
+      "pass": "Dokumentuak gutxienez main erreferentzia-puntu bat du",
+      "fail": "Dokumentuak ez du main erreferentzia-punturik"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "Dokumentuak banner erreferentzia-puntu bat baino ez du",
+      "fail": "Dokumentuak banner erreferentzia-puntu bat baino gehiago du"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "Dokumentuak contentinfo erreferentzia-puntu bat baino ez du",
+      "fail": "Dokumentuak contentinfo erreferentzia-puntu bat baino gehiago du"
+    },
+    "page-no-duplicate-main": {
+      "pass": "Dokumentuak ez du main erreferentzia-puntu bat baino gehiago",
+      "fail": "Dokumentuak main erreferentzia-puntu bat baino gehiago du"
+    },
+    "tabindex": {
+      "pass": "Elementuak ez du 0 baino tabindex handiagoa",
+      "fail": "Elementuak 0 baino tabindex handiagoa du"
+    },
+    "alt-space-value": {
+      "pass": "Elementuak balio balioduna du alt atributurako",
+      "fail": "Elementuak espazio-karaktere bat soilik duen alt atributua du, pantaila-irakurgailu guztiek alde batera uzten ez dutena."
+    },
+    "duplicate-img-label": {
+      "pass": "Elementuak ez du bikoizten < img>-ren testu alternatiboan dagoen testua.",
+      "fail": "Elementuak <img> elementu bat dauka, lehendik dagoen testua bikoizten duen testu alternatiboarekin"
+    },
+    "explicit-label": {
+      "pass": "Formularioko elementuak <label> dauka ",
+      "fail": "Formularioko elementuak ez dauka <label> "
+    },
+    "help-same-as-label": {
+      "pass": "Laguntza-testuak (title o aria-describedby) ez du label testua bikoizten",
+      "fail": "Laguntza-testuak (title o aria-describedby) label testuaren bera da"
+    },
+    "hidden-explicit-label": {
+      "pass": "Formularioko elementuak badu <label> ageriko bat",
+      "fail": "Formularioko elementuak <label> esplizitu ezkutua dauka"
+    },
+    "implicit-label": {
+      "pass": "Formularioko elementuak <label> inplizitua du ('bilduta')",
+      "fail": "Formularioko elementuak ez dauka <label> inplizitu bat ('bilduta')"
+    },
+    "label-content-name-mismatch": {
+      "pass": "Elementuak testu ikusgarri bat dauka, bere izen irisgarriaren zati gisa.",
+      "fail": "Elementuko testua ez dago sartuta izen irisgarrian"
+    },
+    "multiple-label": {
+      "pass": "Formulario-eremuak ez du label elementu askorik",
+      "fail": "Label elementu asko ez dira asko onartzen laguntza-teknologietan"
+    },
+    "title-only": {
+      "pass": "Formularioko elementuak ez du soilik title atributua erabiltzen bere etiketarako",
+      "fail": "Formularioko elementu baten etiketa sortzeko baino ez da erabili title"
+    },
+    "landmark-is-unique": {
+      "pass": "Erreferentzia-puntuek role edo role/label/title konbinazio bakarra izan behar dute (hau da, izen irisgarri bakarra)",
+      "fail": "Erreferentzia-puntuak aria-label, aria-labelledby edo title bakarra izan behar du, erreferentzia-puntuak bereizgarriak izan daitezen."
+    },
+    "has-lang": {
+      "pass": "<html> elementuak lang atributua du",
+      "fail": "<html> elementuak ez du lang atributurik"
+    },
+    "valid-lang": {
+      "pass": "lang atributuaren balioa hizkuntza baliodunen zerrendan sartuta dago",
+      "fail": "lang atributuaren balioa ez dago hizkuntza baliodunen zerrendan"
+    },
+    "xml-lang-mismatch": {
+      "pass": "lang eta xml: lang atributuek oinarrizko hizkuntza bera dute",
+      "fail": "lang eta xml: lang atributuek ez dute oinarrizko hizkuntza bera"
+    },
+    "dlitem": {
+      "pass": "Deskribapen-zerrendako elementuak <dl> aita elementua du",
+      "fail": "Deskribapen-zerrendako elementuak ez dauka <dl> aita elementurik"
+    },
+    "listitem": {
+      "pass": "Zerrendaren elementuak < ul>, < ol> edo role=\"list\" duen elementu bat du",
+      "fail": "Zerrendaren elementuak ez du <ul>, <ol> o role=\"list\" elementu aitarik "
+    },
+    "only-dlitems": {
+      "pass": "Zerrendaren elementuak zuzeneko semeak baino ez ditu, <dt> edo <dd> elementuen barruan baimenduta daudenak.",
+      "fail": "Zerrendaren elementuak zuzeneko semeak ditu, <dt> edo <dd> elementuen barruan baimenduta ez daudenak"
+    },
+    "only-listitems": {
+      "pass": "Zerrendako elementuak zuzeneko seme-alabak baino ez ditu, <li> elementuen barruan baimenduta daudenak.",
+      "fail": "Zerrendako elementuak zuzeneko seme-alabak ditu, <li> elementuen barruan baimenduta ez daudenak"
+    },
+    "structured-dlitems": {
+      "pass": "Hutsik ez dagoenean, elementuak <dt> eta < dd> ditu.",
+      "fail": "Hutsik ez dagoenean, elementuak ez du gutxienez <dt> elementurik, eta ondoren, gutxienez <dd> elementurik."
+    },
+    "caption": {
+      "pass": "Multimedia-elementuak azpititulu-pista bat du",
+      "incomplete": "Elementurako azpitituluak daudela egiaztatu"
+    },
+    "frame-tested": {
+      "pass": "Sartutako markoa axe-core bidez probatu da",
+      "fail": "Sartutako markoa ezin izan da probatu axe-core bidez",
+      "incomplete": "Sartutako markoa axe-core bidez probatu behar da oraindik"
+    },
+    "css-orientation-lock": {
+      "pass": "Pantaila maneiagarria da eta ez dago orientazio-blokeorik",
+      "fail": "CSSak orientazioa blokeatzen du, eta pantaila ezin da orientatu.",
+      "incomplete": "Ezin da zehaztu CSS orientazio-blokeorik dagoen"
+    },
+    "meta-viewport-large": {
+      "pass": "<meta> etiketak ez du zum esanguratsurik eragozten gailu mugikorretan",
+      "fail": "<meta> etiketak gailu mugikorretan mugatzen du zooma"
+    },
+    "meta-viewport": {
+      "pass": "<meta> etiketak ez du zoom eragozten gailu mugikorretan",
+      "fail": "${data} < meta> etiketan, gailu mugikorretan zoom-a eragozten du"
+    },
+    "header-present": {
+      "pass": "Orriak 'header' bat dauka",
+      "fail": "Orriak ez dauka 'header' bat"
+    },
+    "heading-order": {
+      "pass": "Goiburuen hurrenkera zuzena da",
+      "fail": "Goiburuen hurrenkera ez da zuzena"
+    },
+    "internal-link-present": {
+      "pass": "Aurkitutako jauzi esteka ('skip') baliozkoa da",
+      "fail": "Ez dira aurkitu jauzi esteka ('skip') baliozkorik"
+    },
+    "landmark": {
+      "pass": "Orrialdeak herrialde bat du erreferentzia-puntu",
+      "fail": "Orrialdeak ez du herrialde erreferentzia-punturik"
+    },
+    "meta-refresh": {
+      "pass": "<meta> etiketak ez du orria freskatzen",
+      "fail": "<meta> etiketak orria freskatzen du"
+    },
+    "p-as-heading": {
+      "pass": "<p> elementuak ez dira goiburu gisa diseinatus",
+      "fail": "Goiburuko elementuak erabili beharko lirateke <p> estiloko elementuak erabili beharrean"
+    },
+    "region": {
+      "pass": "Orriaren eduki guztia erreferentzia-puntuetan sartuta dago.",
+      "fail": "Erreferentzia-puntuetan sartu gabeko edukia du orriak"
+    },
+    "skip-link": {
+      "pass": "Badago jauziko loturaren helmuga ('skip')",
+      "incomplete": "Jauzi-loturaren ('skip') helmuga agerian geratu beharko litzateke aktibazioan ",
+      "fail": "Ez dago helmugarik jauziko estekarako ('skip')"
+    },
+    "unique-frame-title": {
+      "pass": "Elementuaren title atributua bakarra da",
+      "fail": "Elementuaren title atributua ez da bakarra"
+    },
+    "duplicate-id-active": {
+      "pass": "Dokumentuak ez dauka id atributu bera partekatzen duen elementu aktiborik",
+      "fail": "Dokumentuak elementu aktiboak ditu, id atributu berarekin: ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "Dokumentuak ez dauka id atributu bera partekatzen duen Aari edo etiketekin lotutako elementurik",
+      "fail": "Dokumentuak hainbat elementu ditu, id atributu bereko aria batekin lotuta: ${data}"
+    },
+    "duplicate-id": {
+      "pass": "Dokumentuak ez dauka id atributu bera partekatzen duen elementu estatikorik",
+      "fail": "Dokumentuak hainbat elementu estatiko ditu, id atributu berarekin"
+    },
+    "aria-label": {
+      "pass": "aria-label atributua existitzen da eta ez dago hutsik",
+      "fail": "aria-label atributua ez da existitzen edo hutsik dago"
+    },
+    "aria-labelledby": {
+      "pass": "aria-labelledby atributua existitzen da eta pantaila-irakurgailuetarako ikus daitezkeen elementuei egiten die erreferentzia",
+      "fail": "aria-labelledby atributua ez da existitzen, existitzen ez diren elementuei egiten die erreferentzia edo elementu hutsei egiten die erreferentzia"
+    },
+    "avoid-inline-spacing": {
+      "pass": "Ez da testu-tarteari eragiten dion '!important' estilorik zehaztu.",
+      "fail": {
+        "singular": "Ezabatu '!important' inline styleetatik ${data.values}, nabigatzaile gehienetan ez delako onartzen baliogabetzea.",
+        "plural": "Ezabatu '!important' inline styletik ${data.values}, nabigatzaile gehienetan ez delako onartzen baliogabetzea."
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "Elementuak pantaila-irakurgailuek ikusteko moduko barne-testua du.",
+      "fail": "Elementuak ez du pantaila-irakurgailuek ikusteko moduko barne-testurik"
+    },
+    "doc-has-title": {
+      "pass": "Dokumentuak badu elementu bat <title> ez hutsik",
+      "fail": "Dokumentuak ez dauka <title> elementurik hutsik"
+    },
+    "exists": {
+      "pass": "Elementua ez da existitzen",
+      "fail": "Elementua existitzen da"
+    },
+    "has-alt": {
+      "pass": "Elementuak alt atributua du",
+      "fail": "Elementuak ez dauka alt atributurik"
+    },
+    "has-visible-text": {
+      "pass": "Elementuak pantaila-irakurgailuetarako testua du ikusgai",
+      "fail": "Elementuak ez du pantaila-irakurgailuetarako testu ikusgarririk"
+    },
+    "is-on-screen": {
+      "pass": "Elementua ez da ikusten",
+      "fail": "Elementua ikusten da"
+    },
+    "non-empty-alt": {
+      "pass": "Elementuak alt atributua du, eta ez dago hutsik",
+      "fail": "Elementuak ez du alt atributurik edo alt atributua hutsik dago"
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": ", eta ez du  balio-atributurik",
+        "has-label": "elementuak hutsik ez dagoen balio-atributua du  balio-atributurik"
+      },
+      "fail": "Elementuak balio-atributua du, eta balio-atributua hutsik dago"
+    },
+    "non-empty-title": {
+      "pass": "Elementuak title atributua du",
+      "fail": "Elementuak ez du title atributurik edo title atributua hutsik dago"
+    },
+    "non-empty-value": {
+      "pass": "Elementuak hutsik ez dagoen balio-atributua du",
+      "fail": "Elementuak ez dauka balio-atributurik edo balio-atributua hutsik dago"
+    },
+    "role-none": {
+      "pass": "Elementuaren semantika lehenetsia role =\"none\" bidez deuseztatu da.",
+      "fail": "Elementuaren semantika lehenetsia ez da baliogabetu role bidez =\"none\""
+    },
+    "role-presentation": {
+      "pass": "Elementuaren semantika lehenetsia role =\"presentation\" bidez deuseztatu da.",
+      "fail": "Elementuaren semantika lehenetsia ez da ezeztatu role =\"presentation\" bidez"
+    },
+    "caption-faked": {
+      "pass": "Taula baten lehen lerroa ez da izenburu gisa erabiltzen ('caption')",
+      "fail": "Taularen lehen ilarak izenburu bat izan beharko luke ('caption'), taula-gelaxka baten ordez"
+    },
+    "html5-scope": {
+      "pass": "Scope atributua taulako goiburuen elementuetan bakarrik erabiltzen da (<th>)",
+      "fail": "HTML5en, scope atributuak taula-goiburuen elementuetan bakarrik erabil daitezke (<th>) "
+    },
+    "same-caption-summary": {
+      "pass": "Summary eta <caption> atributuaren edukia ez dago bikoiztuta",
+      "fail": "Summary atributuaren eta <caption> elementuaren edukia berdinak dira"
+    },
+    "scope-value": {
+      "pass": "Scope atributua ondo erabiltzen da",
+      "fail": "Scope atributuaren balioa 'row' edo 'col' bakarrik izan daiteke"
+    },
+    "td-has-header": {
+      "pass": "Hutsik ez dauden datu-gelaxka guztiek taula-goiburuak dituzte",
+      "fail": "Hutsik ez dauden datu-gelaxka batzuek ez dute taula-goibururik"
+    },
+    "td-headers-attr": {
+      "pass": "Headers atributua taulako beste gelaxka batzuei erreferentzia egiteko baino ez da erabiltzen",
+      "fail": "Headers atributua ez da soilik erabiltzen taulako beste gelaxka batzuei erreferentzia egiteko"
+    },
+    "th-has-data-cells": {
+      "pass": "Taulako goiburuen gelaxka guztiak datu-gelaxkak dira.",
+      "fail": "Taulako goiburuen gelaxka guztiak ez dira datu-gelaxkak.",
+      "incomplete": "Taulako datu-gelaxkak ez daude edo hutsik daude"
+    },
+    "hidden-content": {
+      "pass": "Orriaren eduki osoa aztertu da.",
+      "fail": "Arazoak egon ziren orrialde honen edukia aztertzean.",
+      "incomplete": "Orrian ezkutuko edukia dago, baina ez da aztertu. Eduki horren bistaratzea aktibatu beharko duzu, aztertzeko."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Gorabehera hauetako edozein zuzentzea::{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Gorabehera hauek zuzentzea (guztiak):{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  }
+}

node_modules/axe-core/locales/fr.json

@@ -0,0 +1,994 @@
+{
+  "lang": "fr",
+  "rules": {
+    "accesskeys": {
+      "description": "Vérifier que chaque valeur de l’attribut accesskey est unique",
+      "help": "La valeur de l’attribut accesskey doit être unique"
+    },
+    "area-alt": {
+      "description": "Vérifier que les éléments <area> d’une image réactive ont une alternative textuelle",
+      "help": "Les éléments <area> actifs doivent avoir une alternative textuelle"
+    },
+    "aria-allowed-attr": {
+      "description": "Vérifier que les attributs ARIA sont autorisés pour le rôle d’un élément",
+      "help": "Les éléments doivent seulement utiliser les attributs ARIA autorisés"
+    },
+    "aria-allowed-role": {
+      "description": "Vérifier que l’attribut role a une valeur valide pour cet élément",
+      "help": "Le rôle ARIA doit être valide pour cet élément"
+    },
+    "aria-command-name": {
+      "description": "Vérifier que chaque \"button\", \"link\" et \"menuitem\" ARIA a un nom accessible",
+      "help": "Les commandes ARIA doivent avoir un nom accessible"
+    },
+    "aria-dialog-name": {
+      "description": "Vérifier que chaque nœud ARIA \"dialog\" et \"alertdialog\" a un nom accessible",
+      "help": "Les nœuds ARIA \"dialog\" and \"alertdialog\" doivent avoir un nom accessible"
+    },
+    "aria-hidden-body": {
+      "description": "Vérifier qu’aria-hidden='true' n’est pas présent sur le corps du document (élément body)",
+      "help": "aria-hidden='true' ne doit pas être présent sur <body>"
+    },
+    "aria-hidden-focus": {
+      "description": "Vérifier qu’aria-hidden n’est pas assigné aux éléments qui reçoivent le focus au clavier",
+      "help": "aria-hidden n’est pas assigné aux éléments qui reçoivent le focus au clavier"
+    },
+    "aria-input-field-name": {
+      "description": "Vérifier que chaque champ de formulaire avec ARIA est doté d’un intitulé accessible",
+      "help": "Les champs de formulaire ARIA ont un intitulé accessible"
+    },
+    "aria-meter-name": {
+      "description": "Vérifier que chaque nœud ARIA \"meter\" a un nom accessible",
+      "help": "Les nœuds ARIA \"meter\" doivent avoir un nom accessible"
+    },
+    "aria-progressbar-name": {
+      "description": "Vérifier que chaque nœud ARIA \"progressbar\" a un nom accessible",
+      "help": "Les nœuds ARIA \"progressbar\" doivent avoir un nom accessible"
+    },
+    "aria-required-attr": {
+      "description": "Vérifier que les éléments avec des rôles ARIA ont les attributs ARIA requis",
+      "help": "Les attributs ARIA requis doivent être présents"
+    },
+    "aria-required-children": {
+      "description": "Vérifier que les éléments avec un rôle ARIA comportent aussi des rôles pour les descendants directs",
+      "help": "Certains rôles ARIA doivent comporter des descendants directs spécifiques"
+    },
+    "aria-required-parent": {
+      "description": "Vérifier que les éléments avec un rôle ARIA requérant des rôles parents y sont contenus",
+      "help": "Certains rôles ARIA doivent être contenus par des parents spécifiques"
+    },
+    "aria-roledescription": {
+      "description": "Vérifier qu’aria-roledescription n’est utilisé que sur des éléments qui ont un rôle implicite ou explicite",
+      "help": "Utiliser aria-roledescription sur les éléments dont le rôle a une valeur sémantique"
+    },
+    "aria-roles": {
+      "description": "Vérifier que les éléments avec un attribut role utilisent une valeur valide",
+      "help": "Les rôles ARIA doivent se conformer aux valeurs valides"
+    },
+    "aria-text": {
+      "description": "Vérifier que \"role=text\" est uniquement utilisé sur des éléments sans descendants focalisables",
+      "help": "\"role=text\" ne doit pas avoir de descendant focalisable"
+    },
+    "aria-toggle-field-name": {
+      "description": "Vérifier que chaque champ de basculement ARIA a un libellé accessible",
+      "help": "Les champs de basculement ARIA ont un libellé accessible"
+    },
+    "aria-tooltip-name": {
+      "description": "Vérifier que chaque nœud ARIA \"tooltip\" a un nom accessible",
+      "help": "Les nœuds ARIA \"tooltip\" doivent avoir un nom accessible"
+    },
+    "aria-treeitem-name": {
+      "description": "Vérifier que chaque nœud ARIA \"treeitem\" a un nom accessible",
+      "help": "Les nœuds ARIA \"treeitem\" doivent avoir un nom accessible"
+    },
+    "aria-valid-attr-value": {
+      "description": "Vérifier que tous les attributs ARIA comportent des valeurs valides",
+      "help": "Les attributs ARIA doivent comporter des valeurs valides"
+    },
+    "aria-valid-attr": {
+      "description": "Vérifier que les attributs commençant par aria- sont des attributs ARIA valides",
+      "help": "Les attributs ARIA doivent se conformer aux noms valides"
+    },
+    "audio-caption": {
+      "description": "Vérifier que les éléments <audio> ont des sous-titres",
+      "help": "Les éléments <audio> doivent avoir une piste de sous-titres"
+    },
+    "autocomplete-valid": {
+      "description": "Vérifier que l’attribut autocomplete est correctement adapté au champ de formulaire",
+      "help": "L’attribut autocomplete doit être utilisé correctement"
+    },
+    "avoid-inline-spacing": {
+      "description": "Vérifier que l’espacement du texte défini à travers une attribution de styles peut être ajusté via une feuille de style personnalisée",
+      "help": "L’espacement du texte inline peut être ajusté avec des feuilles de style personnalisées"
+    },
+    "blink": {
+      "description": "Vérifier que l’élément <blink> n’est pas utilisé",
+      "help": "L’élément <blink> est déprécié et ne doit pas être utilisé"
+    },
+    "button-name": {
+      "description": "Vérifier que les boutons ont un texte perceptible",
+      "help": "Les boutons doivent avoir un texte perceptible"
+    },
+    "bypass": {
+      "description": "Vérifier que chaque page dispose au minimum d’un mécanisme de contournement de la navigation pour accéder directement au contenu",
+      "help": "Chaque page doit fournir des moyens de contourner les contenus répétés"
+    },
+    "color-contrast-enhanced": {
+      "description": "Vérifier que les contrastes entre le premier plan et l’arrière-plan rencontrent les seuils de contrastes exigés par les WCAG 2 AAA",
+      "help": "Les éléments doivent avoir un contraste de couleurs suffisant"
+    },
+    "color-contrast": {
+      "description": "Vérifier que les contrastes entre le premier plan et l’arrière-plan rencontrent les seuils de contrastes exigés par les WCAG 2 AA",
+      "help": "Les éléments doivent avoir un contraste de couleurs suffisant"
+    },
+    "css-orientation-lock": {
+      "description": "Vérifier que les contenus ne sont pas limités à une orientation spécifique de l’écran, et que le contenu est utilisable sous toutes les orientations de l’écran",
+      "help": "Les CSS Media queries ne sont pas utilisées pour verrouiller l’orientation de l’écran"
+    },
+    "definition-list": {
+      "description": "Vérifier que les éléments <dl> sont correctement structurés",
+      "help": "Les éléments <dl> ne doivent contenir directement que des groupes d’éléments <dt> et <dd> correctement ordonnés, ou des éléments <script> ou <template>"
+    },
+    "dlitem": {
+      "description": "Vérifier que les éléments <dt> et <dd> sont contenus dans un élément <dl>",
+      "help": "Les éléments <dt> et <dd> doivent être contenus dans un élément <dl>"
+    },
+    "document-title": {
+      "description": "Vérifier que chaque document HTML contient un élément <title> non vide",
+      "help": "Chaque document doit avoir un élément <title> pour aider à la navigation"
+    },
+    "duplicate-id-active": {
+      "description": "Vérifier que la valeur d’attribut id de chaque élément actif est unique",
+      "help": "Les IDs des éléments actifs doivent être uniques"
+    },
+    "duplicate-id-aria": {
+      "description": "Vérifier que chaque valeur d’attribut id utilisée avec ARIA et dans les étiquettes est unique",
+      "help": "Les IDs utilisés avec ARIA et dans les étiquettes doivent être uniques"
+    },
+    "duplicate-id": {
+      "description": "Vérifier que la valeur de chaque attribut id est unique",
+      "help": "La valeur de l’attribut id doit être unique"
+    },
+    "empty-heading": {
+      "description": "Vérifier que les niveaux de titre ont un texte perceptible",
+      "help": "Les niveaux de titre ne doivent pas être vides"
+    },
+    "empty-table-header": {
+      "description": "Vérifier que les entêtes de tableaux ont un texte perceptible",
+      "help": "Les textes d’entêtes de tableaux ne doivent pas être vides"
+    },
+    "focus-order-semantics": {
+      "description": "Vérifier que les éléments dans le parcours du focus ont un rôle approprié",
+      "help": "Les éléments dans le parcours du focus doivent avoir un rôle approprié pour le contenu interactif"
+    },
+    "form-field-multiple-labels": {
+      "description": "Vérifier que le champ de formulaire n’a pas plusieurs éléments d’étiquettes",
+      "help": "Le champ de formulaire ne devrait pas comporter plusieurs éléments d’étiquettes"
+    },
+    "frame-focusable-content": {
+      "description": "Vérifier que les éléments <frame> et <iframe> avec du contenu focalisable n’ont pas de tabindex=-1",
+      "help": "Les cadres avec du contenu focalisable ne doivent pas avoir tabindex=-1"
+    },
+    "frame-tested": {
+      "description": "Vérifier que les éléments <iframe> et <frame> contiennent le script axe-core",
+      "help": "Les cadres doivent être testés avec axe-core"
+    },
+    "frame-title-unique": {
+      "description": "Vérifier que les éléments <iframe> et <frame> ont un attribut title unique",
+      "help": "Chaque cadre doit avoir un attribut title unique"
+    },
+    "frame-title": {
+      "description": "Vérifier que les éléments <iframe> et <frame> ont un attribut title non vide",
+      "help": "Chaque cadre doit avoir un attribut title"
+    },
+    "heading-order": {
+      "description": "Vérifier que la hiérarchie des niveaux de titre est sémantiquement correcte",
+      "help": "Les niveaux de titre doivent s’incrémenter d’un seul niveau à la fois"
+    },
+    "hidden-content": {
+      "description": "Informer les utilisateurs sur les contenus cachés",
+      "help": "Le contenu caché sur la page ne peut pas être analysé"
+    },
+    "html-has-lang": {
+      "description": "Vérifier que chaque document HTML a un attribut lang",
+      "help": "L’élément <html> doit avoir un attribut lang"
+    },
+    "html-lang-valid": {
+      "description": "Vérifier que l’attribut lang sur l’élément <html> a une valeur valide",
+      "help": "L’élément <html> doit avoir une valeur valide pour l’attribut lang"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "Vérifier que les éléments HTML avec les attributs lang et xml:lang valides indiquent la même langue de base pour la page",
+      "help": "Les éléments HTML avec les attributs lang et xml:lang doivent avoir la même langue de base"
+    },
+    "identical-links-same-purpose": {
+      "description": "Vérifier que les liens qui ont le même nom accessible ont la même finalité",
+      "help": "Les liens avec le même nom ont la même finalité"
+    },
+    "image-alt": {
+      "description": "Vérifier que les éléments <img> ont une alternative textuelle, ou un rôle de type 'none' ou 'presentation'",
+      "help": "Les images doivent avoir une alternative textuelle"
+    },
+    "image-redundant-alt": {
+      "description": "Vérifier que l’intitulé des liens et boutons n’est pas répété dans l’alternative de l’image",
+      "help": "L’intitulé des liens et boutons ne doit pas être répété dans l’alternative de l’image"
+    },
+    "input-button-name": {
+      "description": "Vérifier que la valeur textuelle des contrôles de boutons est perceptible",
+      "help": "La valeur textuelle des contrôles de boutons doit être perceptible"
+    },
+    "input-image-alt": {
+      "description": "Vérifier que les éléments <input type=\"image\"> ont une alternative textuelle",
+      "help": "Les boutons images doivent avoir une alternative textuelle"
+    },
+    "label-content-name-mismatch": {
+      "description": "Vérifier que dans le cas d’éléments identifiés par leur contenu textuel, le texte visible fait partie de l’intitulé accessible",
+      "help": "Le contenu textuel des éléments doit aussi se retrouver dans leur intitulé accessible"
+    },
+    "label-title-only": {
+      "description": "Vérifier que chaque élément de formulaire n’est pas labellisé uniquement par les attributs title ou aria-describedby",
+      "help": "Chaque élément de formulaire doit avoir un label visible"
+    },
+    "label": {
+      "description": "Vérifier que chaque élément de formulaire a une étiquette",
+      "help": "Chaque élément de formulaire doit avoir une étiquette"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "La région banner ne devrait pas être contenue dans une autre région",
+      "help": "La région banner doit être au niveau le plus haut"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "Vérifier que les landmarks complementary ou aside se retrouvent au plus haut niveau",
+      "help": "Aside ne doit pas être contenu dans un autre landmark"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "La région contentinfo ne devrait pas être contenue dans une autre région",
+      "help": "La région contentinfo doit être au niveau le plus haut"
+    },
+    "landmark-main-is-top-level": {
+      "description": "La région main ne devrait pas être contenue dans une autre région",
+      "help": "La région main doit être au niveau le plus haut"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "Vérifier que le document n’a pas plus d’une région banner",
+      "help": "Le document contient au plus une région banner"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "Vérifier que le document n’a pas plus d’une région contentinfo",
+      "help": "Le document contient au plus une région contentinfo"
+    },
+    "landmark-no-duplicate-main": {
+      "description": "Vérifier que le document a tout au plus, un seul landmark main",
+      "help": "Le document ne doit pas contenir plus d’un landmark main"
+    },
+    "landmark-one-main": {
+      "description": "Vérifier qu’une navigation pointe vers le contenu principal de la page. Si la page contient des iframes, chaque iframe ne doit contenir au plus qu’une région main",
+      "help": "La page doit contenir une région main"
+    },
+    "landmark-unique": {
+      "help": "Vérifier que chaque landmark est unique",
+      "description": "Les landmarks doivent comporter un rôle unique, ou une étiquette accessible par la combinaison de role/label/title"
+    },
+    "link-in-text-block": {
+      "description": "Les liens doivent pouvoir être distingués autrement que par la couleur",
+      "help": "Les liens doivent pouvoir être distingués du texte environnant d’une façon qui ne repose pas sur la couleur"
+    },
+    "link-name": {
+      "description": "Vérifier que les liens ont un texte perceptible",
+      "help": "Les liens doivent avoir un texte perceptible"
+    },
+    "list": {
+      "description": "Vérifier que les listes sont structurées correctement",
+      "help": "<ul> et <ol> ne doivent contenir directement que des éléments <li>, <script> ou <template>"
+    },
+    "listitem": {
+      "description": "Vérifier que les éléments <li> sont utilisés sémantiquement",
+      "help": "Les éléments <li> doivent être contenus dans un élément <ul> ou <ol>"
+    },
+    "marquee": {
+      "description": "Vérifier que l’élément <marquee> n’est pas utilisé",
+      "help": "L’élément <marquee> est déprécié et ne doit pas être utilisé"
+    },
+    "meta-refresh-no-exceptions": {
+      "description": "Vérifier que <meta http-equiv=\"refresh\"> n’est pas utilisé pour une actualisation différée",
+      "help": "L'actualisation différée ne doit pas être utilisée"
+    },
+    "meta-refresh": {
+      "description": "Vérifier que <meta http-equiv=\"refresh\"> n’est pas utilisé pour une actualisation différée",
+      "help": "L'actualisation différée en dessous de 20 heures ne doit pas être utilisée"
+    },
+    "meta-viewport-large": {
+      "description": "Vérifier que <meta name=\"viewport\"> permet un agrandissement significatif",
+      "help": "Les utilisateurs devraient pouvoir zoomer et agrandir le texte jusqu’à 500%"
+    },
+    "meta-viewport": {
+      "description": "Vérifier que <meta name=\"viewport\"> ne désactive pas le zoom ni l’agrandissement",
+      "help": "Le zoom et l’agrandissement ne doivent pas être désactivés"
+    },
+    "nested-interactive": {
+      "description": "Les éléments interactifs imbriqués ne sont pas annoncés par les lecteurs d’écrans",
+      "help": "Verifier que les éléments interactifs ne sont pas imbriqués"
+    },
+    "no-autoplay-audio": {
+      "description": "Vérifier que les éléments <video> ou <audio> ne jouent pas de son automatiquement pendant plus de 3 secondes sans mécanisme de contrôle pour stopper la lecture ou couper le son.",
+      "help": "Les éléments <video> ou <audio> ne jouent pas de son automatiquement"
+    },
+    "object-alt": {
+      "description": "Vérifier que les éléments <object> ont une alternative textuelle",
+      "help": "Les éléments <object> doivent avoir une alternative textuelle"
+    },
+    "p-as-heading": {
+      "description": "Vérifier que les éléments p ne sont pas utilisés pour styler des niveaux de titres",
+      "help": "La graisse, le style et le corps du texte ne doivent pas être utilisés pour styler les éléments p comme des niveaux de titres"
+    },
+    "page-has-heading-one": {
+      "description": "Vérifier que la page, ou au moins une de ses iframes, contient un titre de niveau 1",
+      "help": "La page doit contenir un titre de niveau 1"
+    },
+    "presentation-role-conflict": {
+      "description": "Signaler les éléments dont le rôle est 'none' ou 'presentation' et qui déclenchent la résolution de conflits de rôles.",
+      "help": "Les éléments avec un rôle 'none' ou 'presentation' doivent être signalés"
+    },
+    "region": {
+      "description": "Vérifier que tout le contenu est localisé dans une région",
+      "help": "Le contenu doit être localisé dans une région"
+    },
+    "role-img-alt": {
+      "description": "Vérifier que les éléments avec [role='img'] ont une équivalence textuelle",
+      "help": "Les éléments avec [role='img'] ont une équivalence textuelle"
+    },
+    "scope-attr-valid": {
+      "description": "Vérifier que l’attribut scope est utilisé correctement dans les tableaux",
+      "help": "L’attribut scope doit être utilisé correctement"
+    },
+    "scrollable-region-focusable": {
+      "description": "Les éléments dont le contenu défile devraient être accessibles au clavier",
+      "help": "Vérifier que les régions défilantes sont accessibles au clavier"
+    },
+    "select-name": {
+      "description": "Vérifier que l’élément 'select' a un nom accessible",
+      "help": "L’élément 'select' doit avoir un nom accessible"
+    },
+    "server-side-image-map": {
+      "description": "Vérifier que les images réactives côté serveur ne sont pas utilisées",
+      "help": "Les images réactives côté serveur ne devraient pas être utilisées"
+    },
+    "skip-link": {
+      "description": "Vérifier que tous les liens d’évitement ont une cible pouvant recevoir le focus",
+      "help": "La cible d’un lien d’évitement doit exister et pouvoir recevoir le focus"
+    },
+    "svg-img-alt": {
+      "description": "Vérifier que les éléments svg avec un rôle 'img', 'graphics-document', ou 'graphics-symbol' ont un texte accessible",
+      "help": "Les éléments svg avec un rôle 'img' ont un texte alternatif"
+    },
+    "tabindex": {
+      "description": "Vérifier que les valeurs de l’attribut tabindex ne sont pas supérieures à 0",
+      "help": "Aucun élément ne devrait avoir un tabindex avec une valeur supérieure à zéro"
+    },
+    "table-duplicate-name": {
+      "description": "Vérifier que chaque tableau n’ait pas un summary et un caption identiques",
+      "help": "L’élément <caption> ne devrait pas contenir le même texte que l’attribut summary"
+    },
+    "table-fake-caption": {
+      "description": "Vérifier que les tableaux avec une légende utilisent l’élément <caption>",
+      "help": "Les données ou les cellules d’entête ne devraient pas être utilisées pour légender un tableau de données"
+    },
+    "target-size": {
+      "description": "Vérifier que la cible tactile a une taille et un espace suffisants",
+      "help": "Toutes les cibles tactiles doivent faire 24px de large, ou être suffisamment grandes"
+    },
+    "td-has-header": {
+      "description": "Vérifier que chaque cellule de données non vide dans un tableau de données a une ou plusieurs cellules d’entête",
+      "help": "Chaque élément td non vide dans un tableau plus grand que 3 × 3 doit avoir une cellule d’entête associée"
+    },
+    "td-headers-attr": {
+      "description": "Vérifier que chaque cellule utilisant l’attribut headers fait référence à une autre cellule du même tableau",
+      "help": "Les cellules utilisant l’attribut headers ne doivent faire référence qu’à d’autres cellules du même tableau"
+    },
+    "th-has-data-cells": {
+      "description": "Vérifier que chaque cellule d’entête dans un tableau de données fait référence à des cellules de données",
+      "help": "Tous les éléments th et ceux avec role=columnheader/rowheader doivent décrire des cellules de données"
+    },
+    "valid-lang": {
+      "description": "Vérifier que les attributs lang ont des valeurs valides",
+      "help": "L’attribut lang doit avoir une valeur valide"
+    },
+    "video-caption": {
+      "description": "Vérifier que les éléments <video> ont des sous-titres",
+      "help": "Les éléments <video> doivent avoir des sous-titres"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "Les rôles abstraits ne sont pas utilisés",
+      "fail": {
+        "singular": "Le rôle abstrait ne peut pas être utilisé directement : ${data.values}",
+        "plural": "Les rôles abstraits ne peuvent pas être utilisés directement : ${data.values}"
+      }
+    },
+    "aria-allowed-attr": {
+      "pass": "Les attributs ARIA sont utilisés correctement pour le rôle défini",
+      "fail": {
+        "singular": "L’attribut ARIA n’est pas autorisé : ${data.values}",
+        "plural": "Les attributs ARIA ne sont pas autorisés : ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "Le rôle ARIA est autorisé pour l’élément donné",
+      "fail": {
+        "singular": "Le rôle ARIA ${data.values} n’est pas autorisé pour l’élément donné",
+        "plural": "Les rôles ARIA ${data.values} ne sont pas autorisés pour l’élément donné"
+      },
+      "incomplete": {
+        "singular": "Le rôle ARIA ${data.values} doit être retiré lorsque l’élément est rendu visible, car il n’est pas autorisé pour cet élément",
+        "plural": "Les rôles ARIA ${data.values} doivent être retirés lorsque l’élément est rendu visible, car ils ne sont pas autorisés pour cet élément"
+      }
+    },
+    "aria-errormessage": {
+      "pass": "Utiliser une technique prise en charge pour aria-errormessage",
+      "fail": {
+        "singular": "La valeur d’aria-errormessage `${data.values}` doit recourir à une technique pour annoncer le message (aria-live, aria-describedby, role=alert, etc.)",
+        "plural": "Les valeurs aria-errormessage `${data.values}` doivent recourir à une technique pour annoncer le message (aria-live, aria-describedby, role=alert, etc.)"
+      },
+      "incomplete": {
+        "singular": "Vérifier que la valeur de l’attribut 'aria-errormessage' `${data.values}` se réfère à un élément existant",
+        "plural": "Vérifier que les valeurs de l’attribut 'aria-errormessage' `${data.values}` se réfèrent à des éléments existants",
+        "idrefs": "Impossible de déterminer si l’élément référencé par 'aria-errormessage' existe dans la page : ${data.values}"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "Aucun attribut aria-hidden n’est présent sur body",
+      "fail": "aria-hidden=true ne devrait pas être présent sur body"
+    },
+    "aria-level": {
+      "pass": "Les valeurs d’aria-level sont valides",
+      "incomplete": "Les valeurs d’aria-level supérieures à 6 ne sont pas supportées par toutes les combinaisons de navigateurs et de lecteurs d’écrans"
+    },
+    "aria-prohibited-attr": {
+      "pass": "L’attribut ARIA est autorisé",
+      "fail": "L’attribut ARIA ne peut pas être utilisé, ajoutez un attribut role ou utilisez un élément différent : ${data.values}",
+      "incomplete": "L’attribut ARIA n’est pas bien supporté sur l’élément et le contenu texte sera utilisé à la place : ${data.values}"
+    },
+    "aria-required-attr": {
+      "pass": "Tous les attributs ARIA requis sont présents",
+      "fail": {
+        "singular": "L’attribut ARIA requis est manquant : ${data.values}",
+        "plural": "Les attributs ARIA requis sont manquants : ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Les descendants ARIA requis sont présents"
+      },
+      "fail": {
+        "singular": "Le descendant ARIA requis est manquant : ${data.values}",
+        "plural": "Les descendants ARIA requis sont manquants : ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Le rôle du descendant ARIA attendu doit être ajouté : ${data.values}",
+        "plural": "Les rôles des descendants ARIA attendus doivent être ajoutés : ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "Les rôles parents ARIA requis sont présents",
+      "fail": {
+        "singular": "Le rôle parent ARIA requis est manquant : ${data.values}",
+        "plural": "Les rôles parents ARIA requis sont manquants : ${data.values}"
+      }
+    },
+    "aria-roledescription": {
+      "pass": "aria-roledescription utilisé sur un élément sémantique supporté",
+      "incomplete": "Vérifier que la valeur d’aria-roledescription est annoncée par les lecteurs d’écran supportés",
+      "fail": "Attribuer à l’élément un rôle qui supporte aria-roledescription"
+    },
+    "aria-unsupported-attr": {
+      "pass": "L’attribut ARIA est supporté",
+      "fail": "L’attribut ARIA n’est pas suffisamment supporté par les lecteurs d’écran et autres technologies d’assistance : ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "Les valeurs d’attribut ARIA sont valides",
+      "fail": {
+        "singular": "La valeur d’attribut ARIA est invalide : ${data.values}",
+        "plural": "Les valeurs d’attribut ARIA sont invalides : ${data.values}"
+      },
+      "incomplete": {
+        "noId": "L’ID d’élément référencé par l’attribut ARIA n’existe pas dans la page : ${data.needsReview}",
+        "ariaCurrent": "La valeur de l’attribut ARIA est invalide et sera traitée comme \"aria-current=true\" : ${data.needsReview}",
+        "idrefs": "Impossible de vérifier si l’ID d’élément référencé par l’attribut ARIA existe dans la page : ${data.needsReview}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "Les noms d’attributs ARIA sont valides",
+        "plural": "Le nom d’attribut ARIA est valide"
+      },
+      "fail": {
+        "singular": "Le nom d’attribut ARIA est invalide : ${data.values}",
+        "plural": "Les noms d’attributs ARIA sont invalides : ${data.values}"
+      }
+    },
+    "fallbackrole": {
+      "pass": "Une seule valeur de rôle utilisée",
+      "fail": "Utiliser une seule valeur de rôle, dans la mesure où les rôles de secours ne sont pas supportés par les navigateurs anciens",
+      "incomplete": "Utiliser seulement les rôles 'presentation' ou 'none' puisqu’ils sont synonymes."
+    },
+    "has-global-aria-attribute": {
+      "pass": {
+        "singular": "L’élément a un attribut ARIA global : ${data.values}",
+        "plural": "L’élément a des attributs ARIA globaux : ${data.values}"
+      },
+      "fail": "L’élément n’a pas d’attribut ARIA global"
+    },
+    "has-widget-role": {
+      "pass": "L’élément a un rôle widget.",
+      "fail": "L’élément n’a pas de rôle widget."
+    },
+    "invalidrole": {
+      "pass": "Le rôle ARIA est valide",
+      "fail": {
+        "singular": "Le rôle doit être un rôle ARIA valide : ${data.values}",
+        "plural": "Les rôles doivent être des rôles ARIA valides : ${data.values}"
+      }
+    },
+    "is-element-focusable": {
+      "pass": "L’élément est focalisable.",
+      "fail": "L’élément n’est pas focalisable."
+    },
+    "no-implicit-explicit-label": {
+      "pass": "Il n’y a pas de décalage entre le <label> et l’intitulé accessible",
+      "incomplete": "Vérifier que le <label> n’a pas à faire partie du nom du champ de formulaire ARIA ${data}"
+    },
+    "unsupportedrole": {
+      "pass": "Le rôle ARIA est supporté",
+      "fail": "Le rôle utilisé n’est pas suffisamment supporté par les technologies d’assistance"
+    },
+    "valid-scrollable-semantics": {
+      "pass": "L’élément a une sémantique valide pour un élément dans l’ordre de tabulation.",
+      "fail": "L’élément n’a pas une sémantique valide pour un élément dans l’ordre de tabulation."
+    },
+    "color-contrast": {
+      "pass": "L’élément a un contraste de couleurs suffisant de ${data.contrastRatio}",
+      "fail": {
+        "default": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} (couleur d’avant plan : ${data.fgColor}, couleur d’arrière plan : ${data.bgColor}, taille de police : ${data.fontSize}, graisse : ${data.fontWeight}). Contraste de couleur attendu : ${data.expectedContrastRatio}",
+        "fgOnShadowColor": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} entre l’avant plan et la couleur de l’ombre de texte (couleur d’avant plan : ${data.fgColor}, couleur de l’ombre de texte : ${data.shadowColor}, taille de police : ${data.fontSize}, graisse: ${data.fontWeight}). Contraste de couleurs attendu : ${data.expectedContrastRatio}",
+        "shadowOnBgColor": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} entre la couleur de l’ombre de texte et l’arrière plan (couleur de l’ombre de texte : ${data.shadowColor}, couleur d’arrière plan : ${data.bgColor}, taille de police : ${data.fontSize}, graisse: ${data.fontWeight}). Contraste de couleurs attendu : ${data.expectedContrastRatio}"
+      },
+      "incomplete": {
+        "default": "Impossible de déterminer le rapport de contraste",
+        "bgImage": "La couleur d’arrière-plan de l’élément n’a pu être déterminée à cause d’une image d’arrière-plan",
+        "bgGradient": "La couleur d’arrière-plan de l’élément n’a pu être déterminée à cause d’un dégradé d’arrière-plan",
+        "imgNode": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car l’élément contient une balise image",
+        "bgOverlap": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car un autre élément le chevauche",
+        "fgAlpha": "La couleur du texte de l’élément n’a pu être déterminée à cause d’une opacité réduite",
+        "elmPartiallyObscured": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car l’élément est partiellement masqué par un autre élément",
+        "elmPartiallyObscuring": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car il chevauche partiellement un autre élément",
+        "outsideViewport": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car il est à l’extérieur du viewport",
+        "equalRatio": "L’élément a un rapport de contraste de 1:1 avec son arrière-plan",
+        "shortTextContent": "Le contenu de l’élément est trop court pour déterminer s’il s’agit réellement d’un contenu textuel",
+        "nonBmp": "Le contenu de l’élément contient seulement des caractères non textuels",
+        "pseudoContent": "La couleur d’arrière plan de l’élément n’a pu être déterminée à cause d’un pseudo-élément"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "L’élément a un contraste de couleurs suffisant de ${data.contrastRatio}",
+      "fail": {
+        "default": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} (couleur d’avant plan : ${data.fgColor}, couleur d’arrière plan : ${data.bgColor}, taille de police : ${data.fontSize}, graisse : ${data.fontWeight}). Contraste de couleur attendu : ${data.expectedContrastRatio}",
+        "fgOnShadowColor": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} entre l’avant plan et la couleur de l’ombre de texte (couleur d’avant plan : ${data.fgColor}, couleur de l’ombre de texte : ${data.shadowColor}, taille de police : ${data.fontSize}, graisse: ${data.fontWeight}). Contraste de couleurs attendu : ${data.expectedContrastRatio}",
+        "shadowOnBgColor": "L’élément a un contraste de couleurs insuffisant de ${data.contrastRatio} entre la couleur de l’ombre de texte et l’arrière plan (couleur de l’ombre de texte : ${data.shadowColor}, couleur d’arrière plan : ${data.bgColor}, taille de police : ${data.fontSize}, graisse: ${data.fontWeight}). Contraste de couleurs attendu : ${data.expectedContrastRatio}"
+      },
+      "incomplete": {
+        "default": "Impossible de déterminer le rapport de contraste",
+        "bgImage": "La couleur d’arrière-plan de l’élément n’a pu être déterminée à cause d’une image d’arrière-plan",
+        "bgGradient": "La couleur d’arrière-plan de l’élément n’a pu être déterminée à cause d’un dégradé d’arrière-plan",
+        "imgNode": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car l’élément contient une balise image",
+        "bgOverlap": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car un autre élément le chevauche",
+        "fgAlpha": "La couleur du texte de l’élément n’a pu être déterminée à cause d’une opacité réduite",
+        "elmPartiallyObscured": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car l’élément est partiellement masqué par un autre élément",
+        "elmPartiallyObscuring": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car il chevauche partiellement un autre élément",
+        "outsideViewport": "La couleur d’arrière-plan de l’élément n’a pu être déterminée, car il est à l’extérieur du viewport",
+        "equalRatio": "L’élément a un rapport de contraste de 1:1 avec son arrière-plan",
+        "shortTextContent": "Le contenu de l’élément est trop court pour déterminer s’il s’agit réellement d’un contenu textuel",
+        "nonBmp": "Le contenu de l’élément contient seulement des caractères non textuels",
+        "pseudoContent": "La couleur d’arrière plan de l’élément n’a pu être déterminée à cause d’un pseudo-élément"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Les liens peuvent être distingués du texte environnant par un autre moyen que la couleur",
+      "fail": "Les liens doivent se distinguer du texte environnant par un autre moyen que la couleur",
+      "incomplete": {
+        "default": "Impossible de déterminer le rapport de contraste",
+        "bgContrast": "Le rapport de contraste de l’élément n’a pu être déterminé. Recherchez un style différent pour le hover/focus.",
+        "bgImage": "Le rapport de contraste de l’élément n’a pu être déterminé à cause d’une image d’arrière-plan",
+        "bgGradient": "Le rapport de contraste de l’élément n’a pu être déterminé à cause d’un dégradé d’arrière-plan",
+        "imgNode": "Le rapport de contraste de l’élément n’a pu être déterminé, car l’élément contient une balise image",
+        "bgOverlap": "Le rapport de contraste de l’élément n’a pu être déterminé à cause d’un chevauchement"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "La valeur autocomplete est sur un élément approprié",
+      "fail": "La valeur autocomplete est inappropriée sur ce type de champ de formulaire"
+    },
+    "autocomplete-valid": {
+      "pass": "L’attribut autocomplete est formaté correctement",
+      "fail": "L’attribut autocomplete n’est pas formaté correctement"
+    },
+    "accesskeys": {
+      "pass": "La valeur de l’attribut accesskey est unique",
+      "fail": "Plusieurs éléments ont le même accesskey au sein du document"
+    },
+    "focusable-content": {
+      "pass": "L’élément contient des éléments focalisables",
+      "fail": "L’élément devrait avoir du contenu focalisable"
+    },
+    "focusable-disabled": {
+      "pass": "Aucun élément focalisable contenu dans l’élément",
+      "fail": "Le contenu focalisable devrait être désactivé ou retiré du DOM"
+    },
+    "focusable-element": {
+      "pass": "L’élément est focalisable",
+      "fail": "L’élément devrait être focalisable"
+    },
+    "focusable-modal-open": {
+      "pass": "Pas d’élément focalisable quand une modale est ouverte",
+      "incomplete": "Vérifiez que les éléments focalisables ne sont pas atteignables via la tabulation dans l’état actuel"
+    },
+    "focusable-no-name": {
+      "pass": "L’élément n’est pas dans l’ordre de tabulation ou a un intitulé accessible",
+      "fail": "L’élément est dans l’ordre de tabulation et n’a pas d’intitulé accessible",
+      "incomplete": "Impossible de déterminer si l’élément a un nom accessible"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Aucun élément focalisable contenu dans l’élément",
+      "fail": "Le contenu focalisable devrait se voir assigné un tabindex='-1' ou être retiré du DOM"
+    },
+    "frame-focusable-content": {
+      "pass": "L’élément n’a pas de descendants focalisables",
+      "fail": "L’élément a des descendants focalisables",
+      "incomplete": "Impossible de déterminer si l’élément a des descendants"
+    },
+    "landmark-is-top-level": {
+      "pass": "La région ${data.role} est au niveau le plus haut.",
+      "fail": "La région ${data.role} est contenue dans une autre région."
+    },
+    "no-focusable-content": {
+      "pass": "L’élément n’a pas de descendants focalisables",
+      "fail": "L’élément a des descendants focalisables",
+      "incomplete": "Impossible de déterminer si l’élément a des descendants"
+    },
+    "page-has-heading-one": {
+      "pass": "La page a au moins un titre de niveau un",
+      "fail": "La page doit avoir un titre de niveau un"
+    },
+    "page-has-main": {
+      "pass": "La page a au moins une région main",
+      "fail": "La page doit avoir une région main"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "Le document n’a pas plus d’une région banner",
+      "fail": "Le document a plus d’une région banner"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "Le document n’a pas plus d’une région contentinfo",
+      "fail": "Le document a plus d’une région contentinfo"
+    },
+    "page-no-duplicate-main": {
+      "pass": "Le document n’a pas plus d’une région main",
+      "fail": "Le document a plus d’une région banner"
+    },
+    "tabindex": {
+      "pass": "L’élément n’a pas de tabindex supérieur à 0",
+      "fail": "L’élément a un tabindex supérieur à 0"
+    },
+    "alt-space-value": {
+      "pass": "L’élément a une valeur d’attribut alt valide",
+      "fail": "L’élément a un attribut alt qui contient un caractère d’espacement qui n’est pas ignoré par les lecteurs d’écran"
+    },
+    "duplicate-img-label": {
+      "pass": "L’élément ne duplique pas un texte existant dans l’alternative textuelle de l’élément <img>",
+      "fail": "L’élément contient un élément <img> dont l’alternative textuelle duplique un texte existant"
+    },
+    "explicit-label": {
+      "pass": "L’élément de formulaire a un <label> explicite",
+      "fail": "L’élément de formulaire n’a pas de <label> explicite",
+      "incomplete": "Impossible de déterminer si l’élément de formulaire a un <label> explicite"
+    },
+    "help-same-as-label": {
+      "pass": "L’aide à la saisie (title ou aria-describedby) ne duplique pas le contenu du label",
+      "fail": "L’aide à la saisie (title ou aria-describedby) est identique au contenu du label"
+    },
+    "hidden-explicit-label": {
+      "pass": "L’élément de formulaire a un <label> visible et explicite",
+      "fail": "L’élément de formulaire a un <label> explicite qui est masqué",
+      "incomplete": "Impossible de déterminer si l’élément de formulaire a un <label> explicite qui est masqué"
+    },
+    "implicit-label": {
+      "pass": "L’élément de formulaire a un <label> implicite (imbriqué)",
+      "fail": "L’élément de formulaire n’a pas de <label> implicite (imbriqué)",
+      "incomplete": "Impossible de déterminer si l’élément de formulaire a un <label> implicite (imbriqué)"
+    },
+    "label-content-name-mismatch": {
+      "pass": "L’élément contient du texte visible qui n’est pas inclus dans l’intitulé accessible",
+      "fail": "Le texte contenu dans l’élément n’est pas inclus dans l’intitulé accessible"
+    },
+    "multiple-label": {
+      "pass": "L’élément de formulaire n’a pas plusieurs éléments <label>",
+      "incomplete": "Des éléments associés à plusieurs étiquettes ne sont pas suffisamment supportés par les technologies d’assistance. Vérifier que la première étiquette contient toute l’information nécessaire."
+    },
+    "title-only": {
+      "pass": "L’élément de formulaire n’a pas uniquement l’attribut title comme étiquette",
+      "fail": "Seul l’attribut title est utilisé comme étiquette pour l’élément de formulaire"
+    },
+    "landmark-is-unique": {
+      "pass": "Les landmarks doivent comporter un rôle unique, ou une étiquette accessible par la combinaison de role/label/title",
+      "fail": "L’attribut landmark doit comporter une valeur d’attribut aria-label, aria-labelledby, ou title unique pour rendre le landmark distinct"
+    },
+    "has-lang": {
+      "pass": "L’élément <html> a un attribut lang",
+      "fail": {
+        "noXHTML": "L’attribut xml:lang n’est pas valide sur les pages HTML, utiliser l’attribut lang.",
+        "noLang": "L’élément <html> n’a pas d’attribut lang"
+      }
+    },
+    "valid-lang": {
+      "pass": "La valeur de l’attribut lang fait partie des codes de langues valides",
+      "fail": "La valeur de l’attribut lang ne fait pas partie des codes de langues valides"
+    },
+    "xml-lang-mismatch": {
+      "pass": "Les attributs lang et xml:lang indiquent la même langue de base",
+      "fail": "Les attributs lang et xml:lang indiquent des langues de base différentes"
+    },
+    "dlitem": {
+      "pass": "L’item de liste de description a un élément <dl> parent",
+      "fail": "L’item de liste de description n’a pas d’élément <dl> parent"
+    },
+    "listitem": {
+      "pass": "L’item de liste a un élément <ul>, <ol> ou role=\"list\" parent",
+      "fail": {
+        "default": "L’item de liste n’a pas d’élément <ul> ou <ol> parent",
+        "roleNotValid": "L’item de liste n’a pas d’élément <ul> ou <ol> parent sans un role ou un role=\"list\""
+      }
+    },
+    "only-dlitems": {
+      "pass": "L’élément de liste n’a que des descendants directs qui sont autorisés dans les éléments <dt> ou <dd>",
+      "fail": "L’élément de liste a des descendants directs qui ne sont pas autorisés dans les éléments <dt> ou <dd>"
+    },
+    "only-listitems": {
+      "pass": "L’élément de liste n’a que des descendants directs qui sont autorisés dans les éléments <li>",
+      "fail": {
+        "default": "L’élément de liste comporte des descendants directs qui ne sont pas autorisés à l’intérieur de l’élément <li>",
+        "roleNotValid": "L’élément de liste comporte des descendants directs avec un rôle qui n’est pas autorisé : ${data.roles}"
+      }
+    },
+    "structured-dlitems": {
+      "pass": "S’il n’est pas vide, l’élément contient au moins un élément <dt> et un élément <dd>",
+      "fail": "S’il n’est pas vide, l’élément doit contenir au moins un élément <dt> et un élément <dd>"
+    },
+    "caption": {
+      "pass": "L’élément multimédia a une piste de sous-titres",
+      "incomplete": "Aucune piste de sous-titres n’a pu être trouvée pour cet élément"
+    },
+    "frame-tested": {
+      "pass": "L’iframe a été testée avec axe-core",
+      "fail": "L’iframe n’a pu être testée avec axe-core",
+      "incomplete": "L’iframe doit encore être testée avec axe-core"
+    },
+    "no-autoplay-audio": {
+      "pass": "<video> ou <audio> ne produit pas de son pour une durée plus grande que celle permise ou a un mécanisme de contrôle",
+      "fail": "<video> ou <audio> produisent du son pour une durée plus grande que celle permise et n’ont pas de mécanisme de contrôle",
+      "incomplete": "Verifier que l’élément <video> ou <audio> ne produit pas de son pour une durée plus grande que celle permise ou a un mécanisme de contrôle"
+    },
+    "css-orientation-lock": {
+      "pass": "L’utilisation de l’écran est indépendante de l’orientation et n’est pas limitée à un mode d’affichage donné",
+      "fail": "L’utilisation de l’écran est limitée à une orientation donnée par CSS, rendant l’affichage inutilisable",
+      "incomplete": "Le verrouillage de l’orientation d’affichage par CSS ne peut être déterminé"
+    },
+    "meta-viewport-large": {
+      "pass": "La balise <meta> ne limite pas l’agrandissement sur les appareils mobiles",
+      "fail": "La balise <meta> limite l’agrandissement sur les appareils mobiles"
+    },
+    "meta-viewport": {
+      "pass": "La balise <meta> n’empêche pas l’agrandissement sur les appareils mobiles",
+      "fail": "La balise <meta> empêche l’agrandissement sur les appareils mobiles"
+    },
+    "header-present": {
+      "pass": "La page a un entête",
+      "fail": "La page n’a pas d’entête"
+    },
+    "heading-order": {
+      "pass": "Hiérarchie entre les titres valide",
+      "fail": "Hiérarchie entre les titres invalide",
+      "incomplete": "Impossible de déterminer le titre précédent"
+    },
+    "identical-links-same-purpose": {
+      "pass": "Il n’y a pas d’autre lien avec le même nom qui a pour destination une URL différente",
+      "incomplete": "Vérifier que les liens ont la même finalité ou sont volontairement ambigus."
+    },
+    "internal-link-present": {
+      "pass": "Lien d’évitement valide trouvé",
+      "fail": "Aucun lien d’évitement valide trouvé"
+    },
+    "landmark": {
+      "pass": "La page a une région",
+      "fail": "La page n’a pas de région"
+    },
+    "meta-refresh": {
+      "pass": "Aucune balise <meta> ne rafraîchit immédiatement la page",
+      "fail": "La balise <meta> force le rafraîchissement minuté de la page"
+    },
+    "p-as-heading": {
+      "pass": "Les éléments <p> ne sont pas stylés comme des titres",
+      "fail": "Des titres doivent être utilisés au lieu de styler des éléments <p>"
+    },
+    "region": {
+      "pass": "Contenu imbriqué dans une région ARIA",
+      "fail": "Contenu non imbriqué dans une région ARIA"
+    },
+    "skip-link": {
+      "pass": "La cible du lien d’évitement existe",
+      "incomplete": "La cible du lien d’évitement devrait devenir visible lors de l’activation",
+      "fail": "Lien d’évitement sans cible"
+    },
+    "unique-frame-title": {
+      "pass": "L’attribut title de l’élément est unique",
+      "fail": "L’attribut title de l’élément n’est pas unique"
+    },
+    "duplicate-id-active": {
+      "pass": "Le document ne comporte aucun élément actif partageant la même valeur d’attribut id",
+      "fail": "Le document comporte ou un plusieurs éléments actifs partageant la même valeur d’attribut id : ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "Le document ne comporte aucun élément référencé par ARIA ou étiquettes partageant la même valeur d’attribut id",
+      "fail": "Le document comporte un ou plusieurs éléments référencés par ARIA partageant la même valeur d’attribut id : ${data}"
+    },
+    "duplicate-id": {
+      "pass": "Le document n’a pas d’éléments qui partagent le même attribut id",
+      "fail": "Le document a plusieurs éléments avec le même attribut id : ${data}"
+    },
+    "aria-label": {
+      "pass": "L’attribut aria-label existe et n’est pas vide",
+      "fail": "L’attribut aria-label n’existe pas ou est vide"
+    },
+    "aria-labelledby": {
+      "pass": "L’attribut aria-labelledby existe et fait référence à des éléments visibles par les lecteurs d’écran",
+      "fail": "L’attribut aria-labelledby n’existe pas, fait référence à des éléments qui n’existent pas ou à des éléments vides ou non visibles",
+      "incomplete": "S’assurer que l’attribut aria-labelledby fait référence à un élément existant"
+    },
+    "avoid-inline-spacing": {
+      "pass": "Aucun style inline affectant l’espacement du texte avec '!important' n’a été spécifié",
+      "fail": {
+        "singular": "Retirer '!important' du style inline ${data.values}, car le remplacement n’est pas pris en charge par la plupart des navigateurs",
+        "plural": "Retirer '!important' des styles inline ${data.values}, car le remplacement n’est pas pris en charge par la plupart des navigateurs"
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "L’élément a un contenu textuel visible par les lecteurs d’écran",
+      "fail": "L’élément n’a aucun contenu textuel visible par les lecteurs d’écran",
+      "incomplete": "Impossible de vérifier si l’élément a des enfants"
+    },
+    "doc-has-title": {
+      "pass": "Le document a un élément <title> non vide",
+      "fail": "Le document n’a pas d’élément <title> non vide"
+    },
+    "exists": {
+      "pass": "L’élément n’existe pas",
+      "incomplete": "L’élément existe"
+    },
+    "has-alt": {
+      "pass": "L’élément a un attribut alt",
+      "fail": "L’élément n’a pas d’attribut alt"
+    },
+    "has-visible-text": {
+      "pass": "L’élément a un contenu textuel visible par les lecteurs d’écran",
+      "fail": "L’élément n’a aucun contenu textuel visible par les lecteurs d’écran",
+      "incomplete": "Impossible de vérifier si l’élément a des enfants"
+    },
+    "is-on-screen": {
+      "pass": "L’élément n’est pas visible",
+      "fail": "L’élément est visible"
+    },
+    "non-empty-alt": {
+      "pass": "L’élément a un attribut alt non vide",
+      "fail": {
+        "noAttr": "L’élément n’a pas d’attribut alt",
+        "emptyAttr": "L’élément a un attribut alt vide"
+      }
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": "L’élément n’a pas d’attribut value",
+        "has-label": "L’élément a un attribut value non-vide"
+      },
+      "fail": "L’élément a un attribut value, et cet attribut est vide"
+    },
+    "non-empty-placeholder": {
+      "pass": "L’élément a un attribut placeholder",
+      "fail": {
+        "noAttr": "L’élément n’a pas d’attribut placeholder",
+        "emptyAttr": "L’élément a un attribut placeholder vide"
+      }
+    },
+    "non-empty-title": {
+      "pass": "L’élément a un attribut title",
+      "fail": {
+        "noAttr": "L’élément n’a pas d’attribut title",
+        "emptyAttr": "L’élément a un attribut title vide"
+      }
+    },
+    "non-empty-value": {
+      "pass": "L’élément a un attribut value non vide",
+      "fail": {
+        "noAttr": "L’élément n’a pas d’attribut value",
+        "emptyAttr": "L’élément a un attribut value vide"
+      }
+    },
+    "presentational-role": {
+      "pass": "La sémantique par défaut de l’élément a été remplacée par role=\"${data.role}\"",
+      "fail": {
+        "default": "La sémantique par défaut de l’élément n’a pas été remplacée par role=\"none\" ou role=\"presentation\"",
+        "globalAria": "Le rôle de l’élément n’est pas un rôle de présentation car il a un attribut ARIA global",
+        "focusable": "Le rôle de l’élément n’est pas un rôle de présentation car il est focalisable",
+        "both": "Le rôle de l’élément n’est pas un rôle de présentation car il a un attribut ARIA global et est focalisable"
+      }
+    },
+    "role-none": {
+      "pass": "La sémantique par défaut de l’élément est annulée avec role=\"none\"",
+      "fail": "La sémantique par défaut de l’élément n’est pas annulée avec role=\"none\""
+    },
+    "role-presentation": {
+      "pass": "La sémantique par défaut de l’élément est annulée avec role=\"presentation\"",
+      "fail": "La sémantique par défaut de l’élément n’est pas annulée avec role=\"presentation\""
+    },
+    "svg-non-empty-title": {
+      "pass": "L’élément a un enfant qui est un titre",
+      "fail": {
+        "noTitle": "L’élément n’a pas d’enfant qui est un titre",
+        "emptyTitle": "Le titre qui est enfant de cet élément est vide"
+      },
+      "incomplete": "Impossible de déterminer si l’élément a un enfant qui est un titre"
+    },
+    "caption-faked": {
+      "pass": "La première ligne d’un tableau n’est pas utilisée en guise de légende",
+      "fail": "La première ligne d’un tableau devrait être un caption et non des cellules de tableau"
+    },
+    "html5-scope": {
+      "pass": "L’attribut scope est utilisé uniquement sur des cellules d’entête de tableau",
+      "fail": "En HTML 5, l’attribut scope ne peut être utilisé que sur des cellules d’entête de tableau"
+    },
+    "same-caption-summary": {
+      "pass": "Les contenus de l’attribut summary et de <caption> ne sont pas identiques",
+      "fail": "Les contenus de l’attribut summary et de <caption> sont identiques"
+    },
+    "scope-value": {
+      "pass": "L’attribut scope est utilisé correctement",
+      "fail": "La valeur de l’attribut scope ne peut être que 'row' ou 'col'"
+    },
+    "td-has-header": {
+      "pass": "Toutes les cellules de données non vides ont un entête de tableau",
+      "fail": "Certaines cellules de données non vides n’ont pas d’entête de tableau"
+    },
+    "td-headers-attr": {
+      "pass": "L’attribut headers est utilisé exclusivement pour faire référence à d’autres cellules dans le tableau",
+      "incomplete": "L’attribut headers est vide",
+      "fail": "L’attribut headers n’est pas utilisé exclusivement pour faire référence à d’autres cellules dans le tableau"
+    },
+    "th-has-data-cells": {
+      "pass": "Toutes les cellules d’entête de tableau font référence à des cellules de données",
+      "fail": "Toutes les cellules d’entête de tableau ne font pas référence à des cellules de données",
+      "incomplete": "Les cellules de données sont absentes ou vides"
+    },
+    "hidden-content": {
+      "pass": "Tout le contenu de la page a été analysé.",
+      "fail": "Il y a eu des problèmes pour analyser le contenu de cette page.",
+      "incomplete": "Il y a du contenu caché sur la page qui n’a pas été analysé. Vous allez devoir modifier l’affichage de ce contenu afin de l’analyser."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Corriger l’un des éléments suivants : {{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Corriger tous les éléments suivants : {{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "axe n’a pu en déterminer la raison. Il est temps de sortir l’inspecteur d’éléments !"
+}

node_modules/axe-core/locales/nl.json

@@ -0,0 +1,48 @@
+{
+  "lang": "nl",
+  "checks": {
+    "abstractrole": {
+      "pass": "Er zijn geen abstracte rollen (role) gebruikt",
+      "fail": "Gebruik geen abstracte rollen (role)"
+    },
+    "color-contrast": {
+      "pass": "Element heeft voldoende contrast, namelijk ${data.contrastRatio}",
+      "fail": "Element heeft onvoldoende contrast, ${data.contrastRatio} (Voorgrondkleur: ${data.fgColor}, achtergrondkleur: ${data.bgColor}, tekstgrootte: ${data.fontSize}, tekstdikte: ${data.fontWeight})",
+      "incomplete": {
+        "bgImage": "Element's achtergrondkleur kon niet worden bepaald vanwegen een achtergrondafbeelding",
+        "bgGradient": "Element's achtergrondkleur kon niet worden bepaald vanwegen een gradient kleur",
+        "imgNode": "Element's achtergrondkleur kon niet worden bepaald vanwegen een image node",
+        "bgOverlap": "Element's achtergrondkleur kon niet worden bepaald vanwegen een overlappend element",
+        "fgAlpha": "Element's achtergrondkleur kon niet worden bepaald vanwegen alpha transparency",
+        "default": "Contrastkleur kon niet bepaald worden"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "Element heeft voldoende contrast, namelijk ${data.contrastRatio}",
+      "fail": "Element heeft onvoldoende contrast, ${data.contrastRatio} (Voorgrondkleur: ${data.fgColor}, achtergrondkleur: ${data.bgColor}, tekstgrootte: ${data.fontSize}, tekstdikte: ${data.fontWeight})",
+      "incomplete": {
+        "bgImage": "Element's achtergrondkleur kon niet worden bepaald vanwegen een achtergrondafbeelding",
+        "bgGradient": "Element's achtergrondkleur kon niet worden bepaald vanwegen een gradient kleur",
+        "imgNode": "Element's achtergrondkleur kon niet worden bepaald vanwegen een image node",
+        "bgOverlap": "Element's achtergrondkleur kon niet worden bepaald vanwegen een overlappend element",
+        "fgAlpha": "Element's achtergrondkleur kon niet worden bepaald vanwegen alpha transparency",
+        "default": "Contrastkleur kon niet bepaald worden"
+      }
+    }
+  },
+  "rules": {
+    "aria-required-attr": {
+      "description": "Zorg dat elementen met ARIA rollen (role) de vereiste ARIA attributen hebben",
+      "help": "Voorzien de vereiste ARIA attributen"
+    }
+  },
+  "failureSummaries": {
+    "none": {
+      "failureMessage": "Los al het volgende op:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "any": {
+      "failureMessage": "Gebruik een van de volgende oplossingen:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "axe kon de reden niet vertellen. Tijd om de element inspecteur uit te breken!"
+}

node_modules/axe-core/locales/no_NB.json

@@ -0,0 +1,799 @@
+{
+  "lang": "nb-no",
+  "rules": {
+    "accesskeys": {
+      "description": "",
+      "help": "Verdien for hver 'accesskey' attributt skal være unik"
+    },
+    "area-alt": {
+      "description": "",
+      "help": "Aktive <area> elementer skal ha alternativ tekst"
+    },
+    "aria-allowed-attr": {
+      "description": "",
+      "help": "Elementer må kun bruke tillate ARIA-attributter"
+    },
+    "aria-allowed-role": {
+      "description": "",
+      "help": "ARIA-attributtet 'role' skal være passende for elementet"
+    },
+    "aria-hidden-body": {
+      "description": "",
+      "help": "aria-hidden='true' skal ikke brukes på dokumentets <body> element"
+    },
+    "aria-hidden-focus": {
+      "description": "",
+      "help": "Elementer med ARIA-'hidden' skal ikke inneholde fokuserbare elementer"
+    },
+    "aria-input-field-name": {
+      "description": "",
+      "help": "ARIA-input-felter skal ha et tilgjengelig navn"
+    },
+    "aria-required-attr": {
+      "description": "",
+      "help": "Alle påkrevde ARIA-attributter skal være angitt i henhold til elementets rolle"
+    },
+    "aria-required-children": {
+      "description": "",
+      "help": "Bestemte ARIA-roller skal inneholde spesifikke under-elementer"
+    },
+    "aria-required-parent": {
+      "description": "",
+      "help": "Bestemte ARIA-roller skal være under-element til spesifikke over-elementer"
+    },
+    "aria-roledescription": {
+      "description": "",
+      "help": "Bruk 'aria-roledescription' på elementer med en semantisk rolle"
+    },
+    "aria-roles": {
+      "description": "",
+      "help": "ARIA-roller skal ha en korrekt verdi"
+    },
+    "aria-toggle-field-name": {
+      "description": "",
+      "help": "ARIA avkrysningsboks skal ha et tilgjengelig navn"
+    },
+    "aria-valid-attr-value": {
+      "description": "",
+      "help": "ARIA-attributter skal ha en gyldig verdi"
+    },
+    "aria-valid-attr": {
+      "description": "",
+      "help": "ARIA-attributter skal ha et gyldig navn"
+    },
+    "audio-caption": {
+      "description": "",
+      "help": "<audio> elementer skal ha en transkripsjon ('captions track')"
+    },
+    "autocomplete-valid": {
+      "description": "",
+      "help": "Attributtet 'autocomplete' skal benyttes korrekt"
+    },
+    "avoid-inline-spacing": {
+      "description": "",
+      "help": "Inline tekst-avstand skal være justerbare med brukerdefinerte stylesheets"
+    },
+    "blink": {
+      "description": "",
+      "help": "Elementet <blink> er utfaset og skal ikke brukes"
+    },
+    "button-name": {
+      "description": "",
+      "help": "Knapper skal ha forståelig (dvs. detekterbar) tekst"
+    },
+    "bypass": {
+      "description": "",
+      "help": "Sider skal ha en metode for å hoppe over navigasjon og komme direkte til innholdet"
+    },
+    "color-contrast": {
+      "description": "",
+      "help": "Elementer skal ha tilstrekkelig fargekontrast"
+    },
+    "color-contrast-enhanced": {
+      "description": "",
+      "help": "Elementer skal ha tilstrekkelig fargekontrast"
+    },
+    "css-orientation-lock": {
+      "description": "",
+      "help": "'CSS Media queries' skal ikke brukes til å låse skjermretningen ('orientation')"
+    },
+    "definition-list": {
+      "description": "",
+      "help": "<dl> elementer skal kun direkte inneholde velsorterte <dt> og <dd> grupper, <script> eller <template> elementer"
+    },
+    "dlitem": {
+      "description": "",
+      "help": "<dt> og <dd> elementer skal være under-element til et <dl> element"
+    },
+    "document-title": {
+      "description": "",
+      "help": "Dokumenter skal ha et <title> element med en verdi som ikke er tom"
+    },
+    "duplicate-id-active": {
+      "description": "",
+      "help": "'id'-attributtet for aktive elementer skal være unik"
+    },
+    "duplicate-id-aria": {
+      "description": "",
+      "help": "'id'-attributtet brukt på ARIA-elementer og -labels skal være unikt"
+    },
+    "duplicate-id": {
+      "description": "",
+      "help": "Verdien for 'id'-attributtet skal være unik"
+    },
+    "empty-heading": {
+      "description": "",
+      "help": "Overskrifter skal ikke være tomme"
+    },
+    "focus-order-semantics": {
+      "description": "",
+      "help": "Elementer i fokus-rekkefølgen skal ha en 'role'-attributt, som er passende for det interaktive innholdet"
+    },
+    "form-field-multiple-labels": {
+      "description": "",
+      "help": "Form-feltet skal ikke ha flere label-elementer"
+    },
+    "frame-tested": {
+      "description": "",
+      "help": "Frame-elementer skal være testet med axe-core"
+    },
+    "frame-title-unique": {
+      "description": "",
+      "help": "Frame-elementer skal ha en unik 'title'-attributt"
+    },
+    "frame-title": {
+      "description": "",
+      "help": "Frame-elementer skal ha 'title'-attributt"
+    },
+    "heading-order": {
+      "description": "",
+      "help": "Rekkefølgen for overksriftsnivåer skal være semtantisk korrekt"
+    },
+    "hidden-content": {
+      "description": "",
+      "help": "Skjult innhold på siden kunne ikke analyseres"
+    },
+    "html-has-lang": {
+      "description": "",
+      "help": "<html> elementet skal ha en 'lang'-attributt"
+    },
+    "html-lang-valid": {
+      "description": "",
+      "help": "<html> elementet skal ha en gyldig verdi for 'lang'-attributtet"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "",
+      "help": "<html> elementer med 'lang' og 'xml:lang' skal ha samme språk / dialekt"
+    },
+    "image-alt": {
+      "description": "",
+      "help": "Bilder skal ha en alternativ tekst"
+    },
+    "image-redundant-alt": {
+      "description": "",
+      "help": "Alternativ tekst til bilder (alt-tekst) skal ikke gjentas som tekst"
+    },
+    "input-button-name": {
+      "description": "",
+      "help": "Input-knapper skal ha en forståelig tekst"
+    },
+    "input-image-alt": {
+      "description": "",
+      "help": "Bilde-knapper skal ha en alternativ tekst"
+    },
+    "label-content-name-mismatch": {
+      "description": "",
+      "help": "Elementer sin synlige tekst skal være del av deres tilgjengelige navn"
+    },
+    "label-title-only": {
+      "description": "",
+      "help": "Skjemaalement skal ha en synlig ledetekst"
+    },
+    "label": {
+      "description": "",
+      "help": "Alle skjemaelement skal ha en tilknyttet ledetekst eller instruksjon"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "",
+      "help": "Et 'banner'-landemerke skal ikke være inne i et annet landemerke"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "",
+      "help": "Et 'aside'- eller 'complimentary'-landemerke skal ikke være inne i et annet landemerke"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "",
+      "help": "Et 'contentinfo'-landemerke skal ikke være inne i et annet landemerke"
+    },
+    "landmark-main-is-top-level": {
+      "description": "",
+      "help": "Et 'main'-landemerke skal ikke være inne i et annet landemerke"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "",
+      "help": "Dokumentet skal ikke ha mer enn ett 'banner'-landemerke"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "",
+      "help": "Dokumentet skal ikke ha mer enn ett 'contentinfo'-landemerke"
+    },
+    "landmark-one-main": {
+      "description": "",
+      "help": "Dokumentet skal ha ett 'main'-landemerke"
+    },
+    "landmark-unique": {
+      "description": "",
+      "help": "Sikre at landemerker er unike"
+    },
+    "link-in-text-block": {
+      "description": "",
+      "help": "Lenker skal være fremtredende fra den omkringliggende teksten på en måte som ikke avhenger av farge"
+    },
+    "link-name": {
+      "description": "",
+      "help": "Lenker skal ha forståelig (detekterbar) tekst"
+    },
+    "list": {
+      "description": "",
+      "help": "<ul> og <ol> skal kun direkte inneholde <li>, <script> eller <template> elementer"
+    },
+    "listitem": {
+      "description": "",
+      "help": "<li> elementer skal være inne i et <ul> eller <ol> element"
+    },
+    "marquee": {
+      "description": "",
+      "help": "<marquee> elementer er utfaset og skal ikke brukes"
+    },
+    "meta-refresh": {
+      "description": "",
+      "help": "Tidsinnstilt 'refresh' skal ikke brukes"
+    },
+    "meta-viewport-large": {
+      "description": "",
+      "help": "Brukere skal kunne zoome og skalere tekst opp til 500%"
+    },
+    "meta-viewport": {
+      "description": "",
+      "help": "Zoom og skalering skal ikke være slått av"
+    },
+    "object-alt": {
+      "description": "",
+      "help": "<object> elementer skal ha en alternativ tekst"
+    },
+    "p-as-heading": {
+      "description": "",
+      "help": "Fremhevelse med fet, kursiv og skriftstørrelse (font-size) skal ikke brukes til å 'style' <p> elementer som en overskrift"
+    },
+    "page-has-heading-one": {
+      "description": "",
+      "help": "Siden skal inneholde en overskrift på øverste nivå"
+    },
+    "region": {
+      "description": "",
+      "help": "Alt innholdet på siden skal være inne i landemerker"
+    },
+    "role-img-alt": {
+      "description": "",
+      "help": "Elementer med 'role' attributtverdien 'img' skal ha en alternativ tekst"
+    },
+    "scope-attr-valid": {
+      "description": "",
+      "help": "'scope'-attributtet skal brukes korrekt i tabeller"
+    },
+    "scrollable-region-focusable": {
+      "description": "",
+      "help": "Sørg for at en scrollbar region er tilgjengelig via tastatur"
+    },
+    "server-side-image-map": {
+      "description": "",
+      "help": "Såkalte 'server-side image-maps' skal ikke brukes"
+    },
+    "skip-link": {
+      "description": "",
+      "help": "En 'skip-link' skal peke på et eksisterende og fokuserbart element"
+    },
+    "tabindex": {
+      "description": "",
+      "help": "Elementer skal ikke ha et 'tabindex' høyere enn 0"
+    },
+    "table-duplicate-name": {
+      "description": "",
+      "help": "Elementet <caption> skal ikke inneholde samme tekst som 'summary'-attributtet"
+    },
+    "table-fake-caption": {
+      "description": "",
+      "help": "Data- eller overskrifts-celler skal ikke brukes til å beskrive innholdet av en data-tabell"
+    },
+    "td-has-header": {
+      "description": "",
+      "help": "Alle ikke-tomme <td> elementer i en tabel større enn 3x3 skal ha en tabelloverskrift (<th>)"
+    },
+    "td-headers-attr": {
+      "description": "",
+      "help": "Alle celler i en tabel, som  bruker 'header'-attributtet skal kun referere til andre celler i samme tabel"
+    },
+    "th-has-data-cells": {
+      "description": "",
+      "help": "Alle <th> elementer og elementer med 'role=columnheader/rowheader' skal referere til de data-celler, som de beskriver"
+    },
+    "valid-lang": {
+      "description": "",
+      "help": "'lang'-attributtet skal ha en gyldig verdi"
+    },
+    "video-caption": {
+      "description": "",
+      "help": "<video> elementer skal ha undertekster ('captions')"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "Abstrakte roller er ikke brukt",
+      "fail": "Abstrakte roller skal ikke brukes"
+    },
+    "aria-allowed-attr": {
+      "pass": "ARIA-attributt er brukt korrekt for den angitte rolle",
+      "fail": {
+        "singular": "ARIA-attributtet er ikke tillatt: ${data.values}",
+        "plural": "ARIA-attributtene er ikke tillatt: ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "ARIA-rollen er tillatt for det gitte element",
+      "fail": {
+        "singular": "ARIA-rollen ${data.values} er ikke tillatt for det gitte element",
+        "plural": "ARIA-rollene ${data.values} er ikke tillatt for det gitte element"
+      },
+      "incomplete": {
+        "singular": "ARIA-rollen ${data.values} skal være fjernet når elementet er synlig, da de ikke er tillatt for elementet",
+        "plural": "ARIA-rollene ${data.values} skal være fjernet når elementet er synlig, da det ikke er tillatt for elementet"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "Kunne ikke finne noen 'aria-hidden'-attributt i dokumentets <body> element",
+      "fail": "'aria-hidden=true' skal ikke brukes på dokumentets <body> element"
+    },
+    "aria-roledescription": {
+      "pass": "'aria-roledescription' brukes på en understøttet semantisk rolle",
+      "incomplete": "Sjekk at 'aria-roledescription' blir lest opp av understøttet skjermleser",
+      "fail": "Gi elementet en rolle som understøtter 'aria-roledescription'"
+    },
+    "aria-errormessage": {
+      "pass": "Bruker en understøttet 'aria-errormessage'-metode",
+      "fail": {
+        "singular": "'aria-errormessage'-verdi ${data.values}` skal bruke en metode for å annonsere beskeden (f.eks. 'aria-live', 'aria-describedby', 'role=alert', osv.)",
+        "plural": "'aria-errormessage'-verdier ${data.values}` skal bruke en metode for å annonsere beskeden (f.eks. 'aria-live', 'aria-describedby', 'role=alert', osv.)"
+      }
+    },
+    "has-widget-role": {
+      "pass": "Elementet har en 'widget'-rolle.",
+      "fail": "Elementet har ikke en 'widget'-rolle."
+    },
+    "invalidrole": {
+      "pass": "ARIA-rollen er korrekt",
+      "fail": "Rollen skal være en av de mulige ARIA-roller"
+    },
+    "no-implicit-explicit-label": {
+      "pass": "Det er uoverensstemmelse mellom <label> og det tilgjengelige navnet",
+      "incomplete": "Sjekk at <label> elementet ikke behøver å være en del av ${data}-feltets navn"
+    },
+    "aria-required-attr": {
+      "pass": "Alle påkrevde ARIA-attributter er tilstede",
+      "fail": {
+        "singular": "Påkrevd ARIA-attributt er ikke til stede: ${data.values}",
+        "plural": "Påkrevde ARIA-attributter er ikke til stede: ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Påkrevde ARIA-under-elementer er til stede"
+      },
+      "fail": {
+        "singular": "Påkrevd ARIA-under-element sin rolle er ikke til stede: ${data.values}",
+        "plural": "Påkrevde ARIA-under-elementer sine roller er ikke til stede: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Forventer at ARIA under-element sin rolle blir lagt til: ${data.values}",
+        "plural": "Forventer at ARIA under-elementer sine roller blir lagt til: ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "Påkrevde ARIA-over-elements rolle er til stede",
+      "fail": {
+        "singular": "Påkrevd ARIA-over-element sin rolle er ikke til stede: ${data.values}",
+        "plural": "Påkrevde ARIA-over-elementer sine roller er ikke til stede: ${data.values}"
+      }
+    },
+    "aria-unsupported-attr": {
+      "pass": "ARIA-attributt er understøttet",
+      "fail": "ARIA-attributt er ikke bredt understøttet i skjermlesere og tilgjengelighetsteknologier:  ${data.values}"
+    },
+    "unsupportedrole": {
+      "pass": "ARIA rollen er understøttet",
+      "fail": "Den brukte rolle er ikke bredt understøttet i skjermlesere og tilgjengelighetsteknologier:  ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "ARIA-attributverdien er gyldig",
+      "fail": {
+        "singular": "Ugyldig ARIA-attributtverdi: ${data.values}",
+        "plural": "Ugyldige ARIA-attributtverdier: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Kunne ikke finne ARIA-attributtet sitt element 'id' på siden: ${data.values}",
+        "plural": "Kunne ikke finne ARIA-attributtene sine element 'id' på siden: ${data.values}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "ARIA-attributnavnet er korrekt",
+        "plural": "ARIA-attributnavnene er korrekt"
+      },
+      "fail": {
+        "singular": "Ugyldig ARIA-attributtnavn: ${data.values}",
+        "plural": "Ugyldige ARIA-attributtnavn: ${data.values}"
+      }
+    },
+    "valid-scrollable-semantics": {
+      "pass": "Elementet har korrekt semantikk for et element i fokus-rekkefølgen.",
+      "fail": "Elementet har ikke korrekt semantikk for et element i fokus-rekkefølgen."
+    },
+    "color-contrast": {
+      "pass": "Elementet har tilstrekkelig fargekontrast. Den er ${data.contrastRatio}",
+      "fail": "Elementet har ikke god nok fargekontrast. Den er ${data.contrastRatio} (forgrunnsfarge: ${data.fgColor}, bakgrunnsfarge: ${data.bgColor}, tekststørrelse: ${data.fontSize}, teksttykkelse: ${data.fontWeight}). Forventet kontrastforhold er ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementets bakgrunnsfarge kunne ikke detekteres på grunn av et bakgrunnsbildet",
+        "bgGradient": "Elementets bakgrunnsfarge kunne ikke detekteres på grunn av en bakgrunnsgradient",
+        "imgNode": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi elementet inneholder et bildeelement",
+        "bgOverlap": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er overlappet av et annet element",
+        "fgAlpha": "Elementets forgrunnsfarge kunne ikke detekteres på grunn av dets gjennomsiktighet",
+        "elmPartiallyObscured": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er delvist dekket av et annet element",
+        "elmPartiallyObscuring": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det delvist dekker et annet element",
+        "outsideViewport": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er utenfor sidens 'viewport'",
+        "equalRatio": "Elementet har et 1:1-kontrastforhold med bakgrunnen",
+        "shortTextContent": "Elementets innhold er for kort til å kunne avgjøre om innholdet faktisk er tekst",
+        "default": "Kan ikke regne ut kontrastforhold"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "Elementet har tilstrekkelig fargekontrast, den er ${data.contrastRatio}",
+      "fail": "Elementet har ikke god nok fargekontrast, den er ${data.contrastRatio} (forgrunnsfarge: ${data.fgColor}, bakgrunnsfarge: ${data.bgColor}, tekststørrelse: ${data.fontSize}, teksttykkelse: ${data.fontWeight}). Forventet kontrastforhold er ${data.expectedContrastRatio}",
+      "incomplete": {
+        "bgImage": "Elementets bakgrunnsfarge kunne ikke detekteres på grunn av et bakgrunnsbilde",
+        "bgGradient": "Elementets bakgrunnsfarge kunne ikke detekteres på grunn av en bakgrunnsgradient",
+        "imgNode": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi elementet inneholder et bildeelement",
+        "bgOverlap": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er overlappet av et annet element",
+        "fgAlpha": "Elementets forgrunnsfarge kunne ikke detekteres på grunn av dets gjennomsiktighet",
+        "elmPartiallyObscured": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er delvist dekket av et annet element",
+        "elmPartiallyObscuring": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det delvist dekker et annet element",
+        "outsideViewport": "Elementets bakgrunnsfarge kunne ikke detekteres, fordi det er utenfor sidens 'viewport'",
+        "equalRatio": "Elementet har et 1:1-kontrastforhold med bakgrunnen",
+        "shortTextContent": "Elementets innhold er for kort til å kunne avgjøre om innholdet faktisk er tekst",
+        "default": "Kan ikke regne ut kontrastforhold"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Lenker kan adskilles fra den omkringliggende tekst på annen måte enn med farge",
+      "fail": "Lenker må skille seg ut fra den omkringliggende tekst på annen måte enn med farge",
+      "incomplete": {
+        "bgContrast": "Elementets kontrastforhold kunne ikke detekteres. Sjekk for spesifikk 'hover'/'focus' styling",
+        "bgImage": "Elementets kontrastforhold kunne ikke detekteres på grunn av et bakgrunnsbilde",
+        "bgGradient": "Elementets kontrastforhold kunne ikke detekteres på grunn av en bakgrunnsgradient",
+        "imgNode": "Elementets kontrastforhold kunne ikke detekteres, fordi elementet inneholder et bildeelement",
+        "bgOverlap": "Elementets kontrastforhold kunne ikke detekteres på grunn av overlappende elementer",
+        "default": "Kan ikke regne ut kontrastforhold"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "'autocomplete'-verdien er brukt på et passende element",
+      "fail": "'autocomplete'-verdien er ikke passende for denne type input"
+    },
+    "autocomplete-valid": {
+      "pass": "'autocomplete'-attributtet er korrekt formatert",
+      "fail": "'autocomplete'-attributtet er ikke formatert korrekt"
+    },
+    "accesskeys": {
+      "pass": "'Accesskey' attributtverdien er unik",
+      "fail": "Dokumentet har flere elementer med den samme 'accesskey'-attributtet"
+    },
+    "focusable-content": {
+      "pass": "Elementet inneholder fokuserbare elementer",
+      "fail": "Elementet skal ha fokuserbart innhold"
+    },
+    "focusable-disabled": {
+      "pass": "Ingen fokuserbare elementer inne i elementet",
+      "fail": "Fokuserbart innhold skal slås av eller fjernes fra sidens DOM"
+    },
+    "focusable-element": {
+      "pass": "Elementet er fokuserbart",
+      "fail": "Elementet skal være fokuserbart"
+    },
+    "focusable-no-name": {
+      "pass": "Elementet er ikke i sidens tabulerings-rekkefølge ('tab order') eller har tilgjengelig tekst",
+      "fail": "Elementet er i sidens tabulerings-rekkefølge ('tab order') og har ikke tilgjengelig tekst"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Ingen fokuserbare elementer inne i element",
+      "fail": "Fokuserbart innholdet skal ha tabindex='-1' eller fjernes fra sidens DOM"
+    },
+    "landmark-is-top-level": {
+      "pass": "${data.role} landemerke er på det øverste nivå.",
+      "fail": "${data.role} landemerke er innholdet i et annet landemerke."
+    },
+    "page-has-heading-one": {
+      "pass": "Siden har minst én overskrift på nivå 1",
+      "fail": "Siden skal ha minst én overskrift på nivå 1"
+    },
+    "page-has-main": {
+      "pass": "Dokumentet har minst ét 'main'-landemerke",
+      "fail": "Dokumentet har ikke et 'main'-landemerke"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "Dokumentet har ikke mer enn ett 'banner'-landemerke",
+      "fail": "Dokumentet har mer enn ett 'banner-'landemerke"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "Dokumentet har ikke mer enn ett 'contentinfo'-landemerke",
+      "fail": "Dokumentet har mer enn ett 'contentinfo'-landemerke"
+    },
+    "page-no-duplicate-main": {
+      "pass": "Dokumentet har ikke mer enn ett 'main'-landemerke",
+      "fail": "Dokumentet har mer enn ett 'main'-landemerke"
+    },
+    "tabindex": {
+      "pass": "Elementet har ikke en 'tabindex' som er større enn 0",
+      "fail": "Elementet har en 'tabindex' som er større enn 0"
+    },
+    "alt-space-value": {
+      "pass": "Elementet har en alt-attributt med gyldig verdi",
+      "fail": "Elementet har en alt-attributt som kun inneholder et mellomrom, som ikke ignoreres av alle skjermlesere"
+    },
+    "duplicate-img-label": {
+      "pass": "Elementet duplisere ikke den eksisterende tekst fra <img> elementets alt-tekst",
+      "fail": "Elementet inneholder et <img> element med alt-tekst, som duplisere den eksisterende tekst"
+    },
+    "explicit-label": {
+      "pass": "Form-elementet har en eksplisitt <label>",
+      "fail": "Form-elementet har ikke en eksplisitt <label>"
+    },
+    "help-same-as-label": {
+      "pass": "Hjelpeteksten ('title' eller 'aria-describedby') duplisere ikke label-teksten",
+      "fail": "Hjelpeteksten ('title' eller 'aria-describedby') er den samme som label-teksten"
+    },
+    "hidden-explicit-label": {
+      "pass": "Form-elementet har en synlig og eksplisitt <label>",
+      "fail": "Form-elementet har en eksplisitt <label>, som er skjult"
+    },
+    "implicit-label": {
+      "pass": "Form-elementet har en implisitt (inne i en) <label>",
+      "fail": "Form-elementet har ikke en implisitt (inne i en) <label>"
+    },
+    "label-content-name-mismatch": {
+      "pass": "Elementet inneholder synlig tekst som del av dets tilgjengelige navn",
+      "fail": "Tekst i elementet er ikke inkluderet i det tilgjengelige navn"
+    },
+    "multiple-label": {
+      "pass": "Form-feltet har ikke flere label-elementer",
+      "incomplete": "Flere label-elementer er ikke bredt understøttet i tilgjengelighetsteknologier. Sørg for at det første label-element inneholder all nødvendige informasjon."
+    },
+    "title-only": {
+      "pass": "Form-elementet bruker ikke utelukkende 'title'-attributtet som label",
+      "fail": "Kun 'title'-attributtet er brukt som label for form-elementet"
+    },
+    "landmark-is-unique": {
+      "pass": "Landemerker skal ha en unik rolle eller 'role'/'label'/'title'-attributtkombinasjon (som tilgjengelig navn)",
+      "fail": "Et landemerke skal ha en unik 'aria-label', 'aria-labelledby', eller 'title' for å gjøre landemerker atskillelige"
+    },
+    "has-lang": {
+      "pass": "<html> elementet har en 'lang'-attributt",
+      "fail": "<html> elementet har ikke en 'lang'-attributt"
+    },
+    "valid-lang": {
+      "pass": "'lang'-attributtet sin verdi er inkluderet i listen over godkjente språk",
+      "fail": "'lang'-attributtet sin verdi er ikke inkluderet i listen over gyldige språk"
+    },
+    "xml-lang-mismatch": {
+      "pass": "Attributtene 'lang' og 'xml:lang' har samme språk / dialekt",
+      "fail": "Attributtene 'lang' og 'xml:lang' har ikke samme språk / dialekt"
+    },
+    "dlitem": {
+      "pass": "Beskrivelsesliste-elementet har et <dl>-over-element",
+      "fail": "Beskrivelsesliste-elementet har ikke et <dl>-over-element"
+    },
+    "listitem": {
+      "pass": "Elementet i listen har et <ul>, <ol> eller 'role=\"list\"'-over-element",
+      "fail": "Elementet i listen har ikke et <ul>, <ol> eller 'role=\"list\"'-over-element"
+    },
+    "only-dlitems": {
+      "pass": "Elementet i listen har kun direkte under-elementer, som er tillatt i <dt> eller <dd> elementer",
+      "fail": "Elementet i listen har direkte under-elementer, som ikke er tillatt inde i <dt> eller <dd> elementer"
+    },
+    "only-listitems": {
+      "pass": "Elementet i listen har kun direkte under-elementer, som er tillatt i <li> elementer",
+      "fail": "Elementet i listen har direkte under-elementer, som ikke er tillatt inne i <li> elementer"
+    },
+    "structured-dlitems": {
+      "pass": "Det ikke-tomme elementet har både <dt> og <dd> elementer",
+      "fail": "Det ikke-tomme elementet mangler minst ett <dt> element etterfulgt av minst ett <dd> element"
+    },
+    "caption": {
+      "pass": "Multimedia-elementet har et track med undertekster",
+      "incomplete": "Sjekk at undertekster er tilgjengelige for elementet"
+    },
+    "frame-tested": {
+      "pass": "Denne <iframe> ble testet av axe-core",
+      "fail": "Denne <iframe> kunne ikke testes av axe-core",
+      "incomplete": "Denne <iframe> er enda ikke testet av axe-core"
+    },
+    "css-orientation-lock": {
+      "pass": "Skjermen kan styres, og sidens skjermretning er ikke låst med med 'css-orientation-lock'",
+      "fail": "Skjermretningen ('css-orientation-lock') er låst, hvilket gjør sidevisning vanskelig å styre på skjermen",
+      "incomplete": "Det kan ikke detekteres om skjermretning er låst (med 'css-orientation-lock')"
+    },
+    "meta-viewport-large": {
+      "pass": "<meta>-tagget begrenser ikke høy zoom på mobile enheter",
+      "fail": "<meta>-tagget begrenser zoom på mobile enheter"
+    },
+    "meta-viewport": {
+      "pass": "<meta>-tagget slår ikke zoom av på mobile enheter",
+      "fail": "${data} på <meta>-tagget slår zoom av på mobile enheter"
+    },
+    "header-present": {
+      "pass": "Siden har en overskrift (header)",
+      "fail": "Siden har ikke en overskrift (header)"
+    },
+    "heading-order": {
+      "pass": "Rekkefølgen av overskiftsnivåer er korrekt",
+      "fail": "Rekkefølgen av overskiftsnivåer er ikke korrekt"
+    },
+    "internal-link-present": {
+      "pass": "Passende 'skip link' funnet",
+      "fail": "Ingen passende 'skip link' funnet"
+    },
+    "landmark": {
+      "pass": "Siden har en 'landemerke' region",
+      "fail": "Siden har ikke en 'landemerke' region"
+    },
+    "meta-refresh": {
+      "pass": "<meta>-tagget oppdaterer ikke siden med det samme",
+      "fail": "<meta>-tagget oppdaterer siden med det samme"
+    },
+    "p-as-heading": {
+      "pass": "<p> elementer er ikke stylet som en overskrift",
+      "fail": "Overskrifts-elementer (<h1>, <h2>, osv.) skal brukes i stedet for stylet <p> elementer"
+    },
+    "region": {
+      "pass": "Alt innholdet på siden er lagt inn under landemerker",
+      "fail": "Deler av sidens innholdet er ikke lagt inn under et landemerke"
+    },
+    "skip-link": {
+      "pass": "Elementet som 'skip link' refererer til, eksisterer",
+      "incomplete": "Element som 'skip link' refererer til, skal bli synlig ved aktivering",
+      "fail": "Manglende 'skip link' 'target'-attributt"
+    },
+    "unique-frame-title": {
+      "pass": "Elementets 'title'-attributt er unik",
+      "fail": "Elementets 'title'-attributt er ikke unik"
+    },
+    "duplicate-id-active": {
+      "pass": "Dokumentet har ingen aktive elementer som deler den samme 'id'-attributt",
+      "fail": "Dokumentet har aktive elementer som deler den samme 'id'-attributten: ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "Dokumentet har ingen elementer referert med ARIA eller labels, som deler den samme 'id'-attributten",
+      "fail": "Dokumentet har flere elementer referert med ARIA med den samme 'id'-attributten: ${data}"
+    },
+    "duplicate-id": {
+      "pass": "Dokumentet har ingen statiske elementer som deler den samme 'id'-attributtet",
+      "fail": "Dokumentet har flere statiske elementer med den samme 'id'-attributtet"
+    },
+    "aria-label": {
+      "pass": "'aria-label'-attributt er til stede og er ikke tomt",
+      "fail": "'aria-label'-attributt eksisterer ikke eller er tomt"
+    },
+    "aria-labelledby": {
+      "pass": "'aria-labelledby'-attributt eksisterer og refererer elementer som er synlige for skjermlesere",
+      "fail": "'aria-labelledby'-attributt eksisterer ikke, eller refererer elementer, som ikke eksisterer - eller refererer til elementer, som er tomme"
+    },
+    "avoid-inline-spacing": {
+      "pass": "Ingen inline styling med '!important', som påvirker tekst-mellomrom-avstand er spesifisert",
+      "fail": {
+        "singular": "Fjern '!important' fra inline stylings ${data.values}, da overskrivning av dette ikke er understøttet i de fleste nettlesere",
+        "plural": "Fjern '!important' fra inline styling ${data.values}, da overskrivning av dette ikke er understøttet i de fleste nettlesere"
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "Elementet har indre tekst, som er synlig for skjermlesere",
+      "fail": "Elementet har ingen indre tekst, som er synlig for skjermlesere"
+    },
+    "doc-has-title": {
+      "pass": "Dokumentet har et <title> element som ikke er tomt",
+      "fail": "Dokumentet mangler et <title> element med innhold"
+    },
+    "exists": {
+      "pass": "Elementet eksisterer ikke",
+      "fail": "Elementet eksisterer"
+    },
+    "has-alt": {
+      "pass": "Elementet har en 'alt'-attributt",
+      "fail": "Elementet har ikke en 'alt'-attributt"
+    },
+    "has-visible-text": {
+      "pass": "Elementet har tekst som er synlig for skjermlesere",
+      "fail": "Elementet har ikke tekst som er synlig for skjermlesere"
+    },
+    "is-on-screen": {
+      "pass": "Elementet er ikke synlig",
+      "fail": "Elementet er synlig"
+    },
+    "non-empty-alt": {
+      "pass": "Elementet har 'alt'-attributt med innhold",
+      "fail": "Elementet har ingen 'alt'-attributt, eller 'alt'-attributtet er tomt"
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": "Elementet har ikke en 'value'-attributt",
+        "has-label": "Elementet har en 'verdi'-attributt med innhold"
+      },
+      "fail": "Elementet har en 'value'-attributt, og 'verdi'-attributtet er tomt"
+    },
+    "non-empty-title": {
+      "pass": "Elementet har en 'title'-attributt",
+      "fail": "Elementet har ingen 'title'-attributt, eller 'title'-attributtet er tomt"
+    },
+    "non-empty-value": {
+      "pass": "Elementet har 'value'-attributt med innholdet",
+      "fail": "Elementet har ingen 'value'-attributt, eller 'value'-attributtet er tomt"
+    },
+    "role-none": {
+      "pass": "Elementets standard semantikk ble overskrevet med attributtet 'role=\"none\"'",
+      "fail": "Elementets standard semantikk ble ikke overskrevet med attributtet 'role=\"none\"'"
+    },
+    "role-presentation": {
+      "pass": "Elementets standard semantikk ble overskrevet med attributtet 'role=\"presentation\"'",
+      "fail": "Elementets standard semantikk ble ikke overskrevet med attributtet 'role=\"presentation\"'"
+    },
+    "caption-faked": {
+      "pass": "Den første raden i tabellen er ikke brukt som en beskrivelse ('caption')",
+      "fail": "Det første elementet i tabellen skal være en beskrivelse (<caption>) i stedet for en celle"
+    },
+    "html5-scope": {
+      "pass": "'Scope'-attributtet skal kun brukes på tabellens header-elementer (<th>)",
+      "fail": "'Scope'-attributtet skal kun brukes på tabellens header-elementer (<th>)"
+    },
+    "same-caption-summary": {
+      "pass": "innholdet av 'summary'-attributtet og <caption> elementet er ikke identisk",
+      "fail": "innholdet av 'summary'-attributtet og <caption> elementet er identisk"
+    },
+    "scope-value": {
+      "pass": "'scope'-attributtet brukes korrekt",
+      "fail": "Verdien av 'scope'-attributtet skal kun være 'row' eller 'col'"
+    },
+    "td-has-header": {
+      "pass": "Alle data-celler med innhold har en tabell-header",
+      "fail": "Noen data-celler med innhold har ikke tabell-headers"
+    },
+    "td-headers-attr": {
+      "pass": "Header-attributtet brukes kun til å referere til andre celler i den samme tabel",
+      "fail": "Header-attributtet brukes ikke kun til å referere til andre celler i den samme tabel"
+    },
+    "th-has-data-cells": {
+      "pass": "Alle tabellens header-celler refererer til data-celler",
+      "fail": "Ikke alle tabellens header-celler refererer til data-celler",
+      "incomplete": "Noen av tabellens data-celler mangler eller er tomme"
+    },
+    "hidden-content": {
+      "pass": "Alt innholdet på siden er blitt analyseret.",
+      "fail": "Der var problemer med å analysere deler av innholdet på denne side.",
+      "incomplete": "Der er skjult innhold på siden som ikke ble analyseret. Du må gjøre dette innholdet synlig for å kunne analysere det."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Rett en av følgende: {{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Rett alle de følgende: {{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "axe kunne ikke finne årsaken. Tid for å finne frem utviklerverktøyet(element inspector)!"
+}

node_modules/axe-core/locales/pt_BR.json

@@ -0,0 +1,970 @@
+{
+  "lang": "pt_BR",
+  "rules": {
+    "accesskeys": {
+      "description": "Certifique-se de que cada valor do atributo 'acesskey' é único",
+      "help": "O valor do atributo 'accesskey' deve ser único"
+    },
+    "area-alt": {
+      "description": "Certifique-se de que elementos <area> de mapas de imagem tenham um texto alternativo",
+      "help": "Elementos <area> ativos devem ter um texto alternativo"
+    },
+    "aria-allowed-attr": {
+      "description": "Certifique-se de que os atributos ARIA são permitidos para a função de um elemento",
+      "help": "Os elementos devem usar apenas atributos ARIA permitidos"
+    },
+    "aria-allowed-role": {
+      "description": "Certifique-se de que o atributo 'role' tem um valor apropriado para o elemento",
+      "help": "A função ARIA deve ser apropriada para o elemento"
+    },
+    "aria-command-name": {
+      "description": "Certifique-se de que cada botão, link e item de menu ARIA tenha um nome acessível",
+      "help": "Comandos ARIA devem ter um nome acessível"
+    },
+    "aria-dialog-name": {
+      "description": "Certifique-se de que cada nó de diálogo e diálogo de alerta ARIA tenha um nome acessível",
+      "help": "Nós de diálogo e diálogo de alerta ARIA devem ter um nome acessível"
+    },
+    "aria-hidden-body": {
+      "description": "Certifique-se de que aria-hidden='true' não está presente no elemento <body>.",
+      "help": "aria-hidden='true' não deve estar presente no elemento <body>"
+    },
+    "aria-hidden-focus": {
+      "description": "Certifique-se de que elementos com aria-hidden não contenham elementos focalizáveis",
+      "help": "Elementos ocultados através de ARIA não devem conter elementos focalizáveis"
+    },
+    "aria-input-field-name": {
+      "description": "Certifique-se de que cada campo de entrada ARIA tenha um nome acessível",
+      "help": "Campos de entrada ARIA tenham um nome acessível"
+    },
+    "aria-meter-name": {
+      "description": "Certifique-se de que cada nó de medição ARIA tenha um nome acessível",
+      "help": "Nós de medição ARIA devem ter um nome acessível"
+    },
+    "aria-progressbar-name": {
+      "description": "Certifique-se de que cada nó de barra de progresso ARIA tenha um nome acessível",
+      "help": "Nós de barra de progresso ARIA devem ter um nome acessível"
+    },
+    "aria-required-attr": {
+      "description": "Certifique-se de que elementos com funções ARIA tenham todos os atributos ARIA necessários",
+      "help": "Os atributos ARIA necessários devem ser fornecidos"
+    },
+    "aria-required-children": {
+      "description": "Certifique-se de que elementos com uma função ARIA que requer funções filhas as contenham",
+      "help": "Certas funções ARIA devem conter filhos específicos"
+    },
+    "aria-required-parent": {
+      "description": "Certifique-se de que elementos com uma função ARIA que requer funções pais estejam contidas nestas",
+      "help": "Certas funções ARIA devem estar contidas em pais específicos"
+    },
+    "aria-roledescription": {
+      "description": "Certifique-se de que 'aria-roledescription' somente é utilizado em elementos com uma função implícita ou explícita",
+      "help": "Use 'aria-roledescription' em elementos com função semântica"
+    },
+    "aria-roles": {
+      "description": "Certifique-se de que todos os elementos com um atributo 'role' utilizem um valor válido",
+      "help": "Os ARIA 'roles' utilizados devem ter valores válidos"
+    },
+    "aria-text": {
+      "description": "Certifique-se de que \"role=text\" é usado em elementos sem descendentes focalizáveis",
+      "help": "\"role=text\" não deve ter descendentes focalizáveis"
+    },
+    "aria-toggle-field-name": {
+      "description": "Certifique-se de que cada botão de alternância ARIA tenha um nome acessível",
+      "help": "Botões de alternância ARIA tenham um nome acessível"
+    },
+    "aria-tooltip-name": {
+      "description": "Certifique-se de que cada nó de dica de tela ARIA tenha um nome acessível",
+      "help": "Nós de dica de tela ARIA devem ter um nome acessível"
+    },
+    "aria-treeitem-name": {
+      "description": "Certifique-se de que cada nó de 'treeitem' ARIA deve ter um nome acessível",
+      "help": "Nós de 'treeitem' ARIA devem ter um nome acessível"
+    },
+    "aria-valid-attr-value": {
+      "description": "Certifique-se de que cada atributo ARIA tenha um valor válido",
+      "help": "Atributos ARIA devem ter valores válidos"
+    },
+    "aria-valid-attr": {
+      "description": "Certifique-se de que atributos que se iniciem com aria- são atributos ARIA válidos",
+      "help": "Atributos ARIA devem ter nomes válidos"
+    },
+    "audio-caption": {
+      "description": "Certifique-se de que elementos <audio> tenham legendas",
+      "help": "Elementos <audio> devem ter uma trilha de legenda"
+    },
+    "autocomplete-valid": {
+      "description": "Certifique-se de que o atributo 'autocomplete' esteja correto e adequado para o campo de formulário",
+      "help": "Atributo 'autocomplete' deve ser usado corretamente"
+    },
+    "avoid-inline-spacing": {
+      "description": "Certifique-se de que o espaçamento de texto definido via atributos de estilo pode ser ajustado com folhas de estilo personalizadas",
+      "help": "O espaçamento de texto 'inline' deve ser ajustável com folhas de estilo personalizadas"
+    },
+    "blink": {
+      "description": "Certifique-se de que elementos <blink> não são utilizados",
+      "help": "Elementos <blink> foram descontinuados e não devem ser utilizados"
+    },
+    "button-name": {
+      "description": "Certifique-se de que botões tenham texto discernível",
+      "help": "Botões devem ter texto discernível"
+    },
+    "bypass": {
+      "description": "Certifique-se de que cada página tenha ao menos um mecanismo para o usuário ignorar a navegação e ir direto ao conteúdo",
+      "help": "A página deve ter meios para ignorar blocos repetidos"
+    },
+    "color-contrast": {
+      "description": "Certifique-se de que o contraste entre as cores de primeiro plano e de fundo atenda aos limites de relação de contraste WCAG 2 AA",
+      "help": "Os elementos devem ter contraste de cor suficiente"
+    },
+    "color-contrast-enhanced": {
+      "description": "Certifique-se de que o contraste entre as cores de primeiro plano e de fundo atenda aos limites de relação de contraste WCAG 2 AAA",
+      "help": "Os elementos devem ter contraste de cor suficiente"
+    },
+    "css-orientation-lock": {
+      "description": "Certifique-se de que o conteúdo não está bloqueado para nenhuma orientação de tela específica, e que o mesmo seja operável em todas as orientações de tela",
+      "help": "CSS Media queries não são usadas para bloquear a orientação de tela"
+    },
+    "definition-list": {
+      "description": "Certifique-se de que elementos <dl> estão estruturados corretamente",
+      "help": "Elementos <dl> devem conter diretamente apenas grupos <dt> e <dd> propriamente ordenados, ou elementos <script> ou <template>"
+    },
+    "dlitem": {
+      "description": "Certifique-se de que elementos <dt> e <dd> estão contidos em um elemento <dl>",
+      "help": "Elementos <dt> e <dd> devem estar contidos em um elemento <dl>"
+    },
+    "document-title": {
+      "description": "Certifique-se de que cada documento HTML contenha um elemento <title> não vazio",
+      "help": "Documentos devem ter um elemento <title> para ajudar na navegação"
+    },
+    "duplicate-id-active": {
+      "description": "Certifique-se de que cada valor do atributo 'id' de elementos ativos seja único",
+      "help": "IDs de elementos ativos devem ser únicos"
+    },
+    "duplicate-id-aria": {
+      "description": "Certifique-se de que cada valor do atributo 'id' usado no ARIA e em rótulos seja único",
+      "help": "IDs usados no ARIA e em 'labels' devem ser únicos"
+    },
+    "duplicate-id": {
+      "description": "Certifique-se de que cada valor do atributo 'id' seja único",
+      "help": "O valor do atributo 'id' deve ser único"
+    },
+    "empty-heading": {
+      "description": "Certifique-se de que os títulos tenham texto discernível",
+      "help": "Os títulos não devem ser vazios"
+    },
+    "empty-table-header": {
+      "description": "Certifique-se de que cabeçalhos de tabela tenham texto discernível",
+      "help": "O texto do cabeçalho de tabela não deve ser vazio"
+    },
+    "focus-order-semantics": {
+      "description": "Certifique-se de que os elementos na ordem de foco tenham uma função apropriada",
+      "help": "Elementos na ordem de foco necessitam de uma função apropriada para conteúdo interativo"
+    },
+    "form-field-multiple-labels": {
+      "description": "Certifique-se de que campos de formulários não tenham múltiplos elementos 'label'",
+      "help": "Campos de formulário não devem ter múltiplos elementos 'label'"
+    },
+    "frame-focusable-content": {
+      "description": "Certifique-se de que elementos <frame> e <iframe> com tabindex=-1 não tenham conteúdo focalizável",
+      "help": "Quadros com tabindex=-1 não devem ter conteúdo focalizável"
+    },
+    "frame-tested": {
+      "description": "Certifique-se de que elementos <iframe> e <frame> contenham o script axe-core",
+      "help": "Os 'frames' devem ser testados com o axe-core"
+    },
+    "frame-title-unique": {
+      "description": "Certifique-se de que os elementos <iframe> e <frame> contenham um atributo 'title' único",
+      "help": "Os 'frames' devem ter um atributo 'title' único"
+    },
+    "frame-title": {
+      "description": "Certifique-se de que os elementos <iframe> e <frame> contenham um atributo 'title' não vazio",
+      "help": "Os 'frames' devem ter um atributo 'title'"
+    },
+    "heading-order": {
+      "description": "Certifique-se de que a hierarquia dos níveis de títulos seja semanticamente correta",
+      "help": "Níveis dos títulos devem aumentar de um em um"
+    },
+    "hidden-content": {
+      "description": "Informar aos usuários sobre conteúdo oculto.",
+      "help": "O conteúdo oculto na página não pode ser analisado"
+    },
+    "html-has-lang": {
+      "description": "Certifique-se de que cada documento HTML tenha um atributo 'lang'",
+      "help": "O elemento <html> deve ter um atributo 'lang'"
+    },
+    "html-lang-valid": {
+      "description": "Certifique-se de que o atributo 'lang' do elemento <html> tenha um valor válido",
+      "help": "O elemento <html> deve ter um valor válido para o atributo 'lang'"
+    },
+    "html-xml-lang-mismatch": {
+      "description": "Certifique-se de que elementos HTML com ambos os atributos 'lang' e 'xml:lang' válidos concordem entre si sobre o idioma base da página",
+      "help": "Elementos HTML com 'lang' e 'xml:lang' devem ter o mesmo idioma base"
+    },
+    "identical-links-same-purpose": {
+      "description": "Certifique-se de que links com o mesmo nome acessível servem a um propósito similar",
+      "help": "Links com o mesmo nome devem ter um propósito similar"
+    },
+    "image-alt": {
+      "description": "Certifique-se de que elementos <img> tenham texto alternativo ou um 'role' igual a 'none' ou 'presentation'",
+      "help": "Imagens devem ter texto alternativo"
+    },
+    "image-redundant-alt": {
+      "description": "Certifique-se de que a alternativa de imagem não seja repetida como texto",
+      "help": "O texto alternativo de imagens não deve ser repetido como texto"
+    },
+    "input-button-name": {
+      "description": "Certifique-se de que botões tenham um texto discernível",
+      "help": "Botões de controle devem ter um texto discernível"
+    },
+    "input-image-alt": {
+      "description": "Certifique-se de que elementos <input type=\"image\"> tenham um texto alternativo",
+      "help": "Botões de imagem devem ter um texto alternativo"
+    },
+    "label-content-name-mismatch": {
+      "description": "Certifique-se de que elementos nomeados por meio de seu conteúdo tenham seu texto visível como parte de seu nome acessível",
+      "help": "Elementos devem ter seu texto visível como parte de seu nome acessível"
+    },
+    "label-title-only": {
+      "description": "Certifique-se de que cada elemento de formulário não seja rotulado apenas usando os atributos 'title' ou 'aria-describedby'",
+      "help": "Elementos de formulário devem ter um rótulo visível"
+    },
+    "label": {
+      "description": "Certifique-se de que cada elemento de formulário tenha um rótulo",
+      "help": "Elementos de formulário devem ter rótulos"
+    },
+    "landmark-banner-is-top-level": {
+      "description": "Certifique-se de que a região 'banner' esteja no nível principal",
+      "help": "A região 'banner' não deve estar contida em outra região"
+    },
+    "landmark-complementary-is-top-level": {
+      "description": "Certifique-se de que a região 'complementary' ou 'aside' estejam no nível principal",
+      "help": "'Aside' não deve estar contido em outra região"
+    },
+    "landmark-contentinfo-is-top-level": {
+      "description": "Certifique-se de que a região 'contentinfo' esteja no nível principal",
+      "help": "A região 'contentinfo' não deve estar contida em outra região"
+    },
+    "landmark-main-is-top-level": {
+      "description": "Certifique-se de que a região 'main' esteja no nível principal",
+      "help": "A região 'main' não deve estar contida em outra região"
+    },
+    "landmark-no-duplicate-banner": {
+      "description": "Certifique-se de que o documento tenha no máximo uma região 'banner'",
+      "help": "O documento não deve ter mais do que uma região 'banner'"
+    },
+    "landmark-no-duplicate-contentinfo": {
+      "description": "Certifique-se de que o documento tenha no máximo uma região 'contentinfo'",
+      "help": "O documento não deve ter mais do que uma região 'contentinfo'"
+    },
+    "landmark-no-duplicate-main": {
+      "description": "Certifique-se de que o documento tenha, no máximo, uma região 'main'",
+      "help": "O documento não deve ter mais de uma região 'main'"
+    },
+    "landmark-one-main": {
+      "description": "Certifique-se de que o documento tenha apenas uma região 'main' e que cada 'iframe' na página tenha no náximo uma região 'main'",
+      "help": "O documento deve ter uma região 'main'"
+    },
+    "landmark-unique": {
+      "help": "Certifique-se de que as regiões são únicas",
+      "description": "As regiões devem ter um 'role' ou combinação de 'role'/'label'/'title' (ou seja, um nome acessível) únicos"
+    },
+    "link-in-text-block": {
+      "description": "Links podem ser distinguidos sem depender da cor",
+      "help": "Links devem ser distinguidos do texto ao redor de uma maneira que não dependa da cor"
+    },
+    "link-name": {
+      "description": "Certifique-se de que links tenham um texto discernível",
+      "help": "Links devem ter um texto discernível"
+    },
+    "list": {
+      "description": "Certifique-se de que listas sejam estruturadas corretamente",
+      "help": "Elementos <ul> e <ol> devem conter diretamente apenas elementos <li>, <script> ou <template>"
+    },
+    "listitem": {
+      "description": "Certifique-se de que elementos <li> são usados semanticamente",
+      "help": "Elementos <li> devem estar contidos em um <ul> ou <ol>"
+    },
+    "marquee": {
+      "description": "Certifique-se de que elementos <marquee> não são utilizados",
+      "help": "Elementos <marquee> foram descontinuados e não devem ser utilizados"
+    },
+    "meta-refresh": {
+      "description": "Certifique-se de que <meta http-equiv=\"refresh\"> não é utilizado",
+      "help": "Atualização temporizada não deve existir"
+    },
+    "meta-viewport-large": {
+      "description": "Certifique-se de que <meta name=\"viewport\"> permite ampliar de maneira significativa",
+      "help": "Os usuários devem poder dar zoom e ampliar o texto em até 500%"
+    },
+    "meta-viewport": {
+      "description": "Certifique-se de que <meta name=\"viewport\"> não desabilite a ampliação de texto e o zoom",
+      "help": "O zoom e a ampliação de texto não devem ser desabilitados"
+    },
+    "nested-interactive": {
+      "description": "Controles interativos aninhados não são anunciados por leitores de tela",
+      "help": "Certifique-se de que controles interativos não estejam aninhados"
+    },
+    "no-autoplay-audio": {
+      "description": "Certifique-se de que elementos <video> ou <audio> não reproduzam áudio automaticamente por mais de 3 segundos sem um mecanismo de controle para parar ou silenciar o áudio",
+      "help": "Elementos <video> ou <audio> não reproduzam áudio automaticamente"
+    },
+    "object-alt": {
+      "description": "Certifique-se de que elementos <object> tenham um texto alternativo",
+      "help": "Elementos <object> devem ter um texto alternativo"
+    },
+    "p-as-heading": {
+      "description": "Certifique-se de que elementos <p> não sejam utilizados para estilizar títulos",
+      "help": "Negrito, itálico e 'font-size' não sejam utilizados para estilizar elementos <p> como um título"
+    },
+    "page-has-heading-one": {
+      "description": "Certifique-se de que a página, ou pelo menos um dos seus 'frames', contenha um título de primeiro nível",
+      "help": "A página deve conter um título de primeiro nível"
+    },
+    "presentation-role-conflict": {
+      "description": "Sinaliza elementos cuja função é 'none' ou 'presentation', e que causam o acionamento da resolução de conflito de funções.",
+      "help": "Elementos com função 'none' ou 'presentation' devem ser sinalizados"
+    },
+    "region": {
+      "description": "Certifique-se de todo o conteúdo da página esteja contido em regiões (landmarks)",
+      "help": "Todo o conteúdo da página deve estar contido em regiões (landmarks)"
+    },
+    "role-img-alt": {
+      "description": "Certifique-se de que elementos com [role='img'] tenham texto alternativo",
+      "help": "Elementos com [role='img'] tenham um texto alternativo"
+    },
+    "scope-attr-valid": {
+      "description": "Certifique-se de que o atributo 'scope' é utilizado corretamente em tabelas",
+      "help": "O atributo 'scope' deve ser utilizado corretamente"
+    },
+    "scrollable-region-focusable": {
+      "description": "Elementos que tenham conteúdo rolável devem ser acessíveis via teclado",
+      "help": "Certificar-se de que regiões roláveis tenham acesso via teclado"
+    },
+    "select-name": {
+      "description": "Certifique-se que o elemento 'select' tenha um nome acessível",
+      "help": "O elemento 'select' deve ter um nome acessível"
+    },
+    "server-side-image-map": {
+      "description": "Certifique-se de que mapas de imagem do lado do servidor não são utilizados",
+      "help": "Mapas de imagem do lado do servidor não devem ser utilizados"
+    },
+    "skip-link": {
+      "description": "Certifique-se de que todos os links de escape tenham um destino focalizável",
+      "help": "O destino de um link de escape deve existir e ser focalizável"
+    },
+    "svg-img-alt": {
+      "description": "Certifique-se de que elementos svg com um 'role' de 'img', 'graphics-document' ou 'graphics-symbol' tenham um texto acessível",
+      "help": "Elementos svg com um 'role' de 'img' tenham um texto alternativo"
+    },
+    "tabindex": {
+      "description": "Certifique-se de que os valores do atributo 'tabindex' não são maiores do que 0",
+      "help": "Elementos não devem ter um 'tabindex' maior do que zero"
+    },
+    "table-duplicate-name": {
+      "description": "Certifique-se de que tabelas não tenham 'summary' e <caption> iguais",
+      "help": "O elemento <caption> não deve conter o mesmo texto que o atributo 'summary'"
+    },
+    "table-fake-caption": {
+      "description": "Certifique-se de que tabelas com uma legenda usem o elemento <caption>.",
+      "help": "Células de dados ou cabeçalhos não devem ser usadas para exibir uma legenda para uma tabela de dados."
+    },
+    "td-has-header": {
+      "description": "Certifique-se de que cada célula de dados não vazia em uma tabela grande tenha um ou mais cabeçalhos",
+      "help": "Todos os elementos 'td' não vazios em uma tabela maior que 3 por 3 devem ter um cabeçalho associado"
+    },
+    "td-headers-attr": {
+      "description": "Certifique-se de que cada célula em uma tabela usando o atributo 'headers' se refira a outra célula nesta tabela",
+      "help": "Todas as células em uma tabela que utilizem o atributo 'headers' devem se referir apenas a outras células desta mesma tabela"
+    },
+    "th-has-data-cells": {
+      "description": "Certifique-se de cada cabeçalho em uma tabela de dados se refira a células de dados",
+      "help": "Todos os elementos 'th' e elementos com role=columnheader/rowheader devem ter células de dados que eles descrevem"
+    },
+    "valid-lang": {
+      "description": "Certifique-se de que os atributos 'lang' tenham valores válidos",
+      "help": "O atributo 'lang' deve ter um valor válido"
+    },
+    "video-caption": {
+      "description": "Certifique-se de que elementos <video> tenham legendas",
+      "help": "Elementos <video> devem ter legendas"
+    }
+  },
+  "checks": {
+    "abstractrole": {
+      "pass": "As funções abstratas não são utilizadas",
+      "fail": {
+        "singular": "A função abstrata não pode ser diretamente utilizada: ${data.values}",
+        "plural": "As funções abstratas não podem ser diretamente utilizadas: ${data.values}"
+      }
+    },
+    "aria-allowed-attr": {
+      "pass": "Atributos ARIA são usados corretamente para a função definida",
+      "fail": {
+        "singular": "O atributo ARIA não é permitido: ${data.values}",
+        "plural": "Os atributos ARIA não são permitidos: ${data.values}"
+      }
+    },
+    "aria-allowed-role": {
+      "pass": "O ARIA 'role' é permitido para o elemento dado",
+      "fail": {
+        "singular": "O ARIA 'role' ${data.values} não é permitido para o elemento dado",
+        "plural": "Os ARIA 'roles' ${data.values} não são permitidos para o elemento dado"
+      },
+      "incomplete": {
+        "singular": "O ARIA 'role' ${data.values} deve ser removido quando o elemento é tornado visível, uma vez que não é permitido para o elemento",
+        "plural": "Os ARIA 'roles' ${data.values} devem ser removidos quando o elemento é tornado visível, uma vez que não são permitidos para o elemento"
+      }
+    },
+    "aria-errormessage": {
+      "pass": "Usa uma técnica de 'aria-errormessage' suportada",
+      "fail": {
+        "singular": "O valor de 'aria-errormessage' `${data.values}` deve usar uma técnica para anunciar a mensagem (por exemplo, 'aria-live', 'aria-describedby', role=alert, etc.)",
+        "plural": "Os valores de 'aria-errormessage' `${data.values}` devem usar uma técnica para anunciar a mensagem (por exemplo, 'aria-live', 'aria-describedby', role=alert, etc.)"
+      },
+      "incomplete": {
+        "singular": "certifique-se de que o valor de 'aria-errormessage' `${data.values}` referencia um elemento existente",
+        "plural": "certifque-se de que os valores de 'aria-errormessage' `${data.values}` referenciem elementos existentes"
+      }
+    },
+    "aria-hidden-body": {
+      "pass": "Nenhum atributo 'aria-hidden' está presente no elemento <body>",
+      "fail": "'aria-hidden=true' não deve estar presente no elemento <body>"
+    },
+    "aria-prohibited-attr": {
+      "pass": "O atributo ARIA é permitido",
+      "fail": "O atributo ARIA não pode ser utilizado: ${data.values}",
+      "incomplete": "O atributo ARIA não é bem suportado no elemento e o conteúdo de texto será usado em seu lugar: ${data.values}"
+    },
+    "aria-required-attr": {
+      "pass": "Todos os atributos ARIA necessários estão presentes",
+      "fail": {
+        "singular": "Atributo ARIA necessário ausente: ${data.values}",
+        "plural": "Atributos ARIA necessários ausentes: ${data.values}"
+      }
+    },
+    "aria-required-children": {
+      "pass": {
+        "default": "Os ARIA filhos necessários estão presentes"
+      },
+      "fail": {
+        "singular": "Função ARIA filha necessária ausente: ${data.values}",
+        "plural": "Funções ARIA filhas necessárias ausentes: ${data.values}"
+      },
+      "incomplete": {
+        "singular": "Esperando função ARIA filha a ser adicionada: ${data.values}",
+        "plural": "Esperando funções ARIA filhas a serem adicionadas: ${data.values}"
+      }
+    },
+    "aria-required-parent": {
+      "pass": "A função ARIA pai necessária está presente",
+      "fail": {
+        "singular": "Função ARIA pai necessária ausente: ${data.values}",
+        "plural": "Funções ARIA pais necessárias ausentes: ${data.values}"
+      }
+    },
+    "aria-roledescription": {
+      "pass": "'aria-roledescription' usado em função semântica suportada",
+      "incomplete": "Garanta que o 'aria-roledescription' é anunciado pelos leitores de tela suportados",
+      "fail": "Dê ao elemento uma função que suporte 'aria-roledescription'"
+    },
+    "aria-unsupported-attr": {
+      "pass": "O atributo ARIA é suportado",
+      "fail": "O atributo ARIA não é amplamente suportado em leitores de tela e tecnologias assistivas:  ${data.values}"
+    },
+    "aria-valid-attr-value": {
+      "pass": "Os valores dos atributos ARIA são válidos",
+      "fail": {
+        "singular": "Valor de atributo ARIA inválido: ${data.values}",
+        "plural": "Valores de atributos ARIA inválidos: ${data.values}"
+      },
+      "incomplete": {
+        "noId": "O ID do atributo ARIA do elemento não existe na página: ${data.needsReview}",
+        "ariaCurrent": "O valor do atributo ARIA é inválido e será tratado como \"aria-current=true\": ${data.needsReview}"
+      }
+    },
+    "aria-valid-attr": {
+      "pass": {
+        "singular": "Os nomes dos atributos ARIA são válidos",
+        "plural": "O nome do atributo ARIA é valido"
+      },
+      "fail": {
+        "singular": "Nome de atributo ARIA inválido: ${data.values}",
+        "plural": "Nomes de atributos ARIA inválidos: ${data.values}"
+      }
+    },
+    "fallbackrole": {
+      "pass": "Apenas um valor de 'role' deve ser utilizado",
+      "fail": "Use apenas um valor de 'role', uma vez que funções 'fallback' não são suportadas em navegadores mais antigos"
+    },
+    "has-global-aria-attribute": {
+      "pass": {
+        "singular": "O elemento tem um atributo ARIA global: ${data.values}",
+        "plural": "O elemento tem atributos ARIA globais: ${data.values}"
+      },
+      "fail": "O elemento não tem atributo ARIA global"
+    },
+    "has-widget-role": {
+      "pass": "Elemento tem um 'role' de 'widget'.",
+      "fail": "Elemento não tem um 'role' de 'widget'."
+    },
+    "invalidrole": {
+      "pass": "O ARIA 'role' é válido",
+      "fail": {
+        "singular": "O 'role' deve ser um dos ARIA 'roles' válidos: ${data.values}",
+        "plural": "Os 'roles' devem ser um dos ARIA 'roles' válidos: ${data.values}"
+      }
+    },
+    "is-element-focusable": {
+      "pass": "O elemento é focalizável.",
+      "fail": "O elemento não é focalizável."
+    },
+    "no-implicit-explicit-label": {
+      "pass": "Não há nenhuma divergência entre <label> e o nome acessível",
+      "incomplete": "Verifique se o <label> não precisa fazer parte do nome do campo ARIA ${data}"
+    },
+    "unsupportedrole": {
+      "pass": "O ARIA 'role' é suportado",
+      "fail": "O 'role' usado não é amplamente suportado em leitores de tela e tecnologias assistivas: ${data.values}"
+    },
+    "valid-scrollable-semantics": {
+      "pass": "O elemento possui semântica válida para um elemento na ordem de foco.",
+      "fail": "O elemento possui semântica inválida para um elemento na ordem de foco."
+    },
+    "color-contrast": {
+      "pass": "O elemento tem contraste suficiente no valor de ${data.contrastRatio}",
+      "fail": "O elemento tem contraste insuficiente no valor de ${data.contrastRatio} (cor do primeiro plano: ${data.fgColor}, cor de fundo: ${data.bgColor}, tamanho da fonte: ${data.fontSize}, normal/negrito: ${data.fontWeight}). Contraste esperado no valor de ${data.expectedContrastRatio}",
+      "incomplete": {
+        "default": "Impossível determinar o contraste",
+        "bgImage": "A cor de fundo do elemento não pôde ser determinada devido a uma imagem de fundo",
+        "bgGradient": "A cor de fundo do elemento não pôde ser determinada devido a um gradiente de fundo",
+        "imgNode": "A cor de fundo do elemento não pôde ser determinada porque o elemento contém um nó de imagem",
+        "bgOverlap": "A cor de fundo do elemento não pôde ser determinada porque está sobreposta por outro elemento",
+        "fgAlpha": "A cor do primeiro plano do elemento não pôde ser determinada devido à transparência alfa",
+        "elmPartiallyObscured": "A cor de fundo do elemento não pôde ser determinada porque está parcialmente obscurecida por outro elemento",
+        "elmPartiallyObscuring": "A cor de fundo do elemento não pôde ser determinada porque está parcialmente sobreposta a outros elementos",
+        "outsideViewport": "A cor de fundo do elemento não pôde ser determinada porque está fora da 'viewport'",
+        "equalRatio": "O elemento tem um contraste de 1:1 com plano de fundo",
+        "shortTextContent": "O conteúdo do elemento é muito curto para determinar se é conteúdo de texto real",
+        "nonBmp": "O conteúdo do elemento contém apenas caracteres não textuais",
+        "pseudoContent": "A cor de fundo do elemento não pode ser determinada devido a um pseudo-elemento"
+      }
+    },
+    "color-contrast-enhanced": {
+      "pass": "O elemento tem contraste suficiente no valor de ${data.contrastRatio}",
+      "fail": "O elemento tem contraste insuficiente no valor de ${data.contrastRatio} (cor do primeiro plano: ${data.fgColor}, cor de fundo: ${data.bgColor}, tamanho da fonte: ${data.fontSize}, normal/negrito: ${data.fontWeight}). Contraste esperado no valor de ${data.expectedContrastRatio}",
+      "incomplete": {
+        "default": "Impossível determinar o contraste",
+        "bgImage": "A cor de fundo do elemento não pôde ser determinada devido a uma imagem de fundo",
+        "bgGradient": "A cor de fundo do elemento não pôde ser determinada devido a um gradiente de fundo",
+        "imgNode": "A cor de fundo do elemento não pôde ser determinada porque o elemento contém um nó de imagem",
+        "bgOverlap": "A cor de fundo do elemento não pôde ser determinada porque está sobreposta por outro elemento",
+        "fgAlpha": "A cor do primeiro plano do elemento não pôde ser determinada devido à transparência alfa",
+        "elmPartiallyObscured": "A cor de fundo do elemento não pôde ser determinada porque está parcialmente obscurecida por outro elemento",
+        "elmPartiallyObscuring": "A cor de fundo do elemento não pôde ser determinada porque está parcialmente sobreposta a outros elementos",
+        "outsideViewport": "A cor de fundo do elemento não pôde ser determinada porque está fora da 'viewport'",
+        "equalRatio": "O elemento tem um contraste de 1:1 com plano de fundo",
+        "shortTextContent": "O conteúdo do elemento é muito curto para determinar se é conteúdo de texto real",
+        "nonBmp": "O conteúdo do elemento contém apenas caracteres não textuais",
+        "pseudoContent": "A cor de fundo do elemento não pode ser determinada devido a um pseudo-elemento"
+      }
+    },
+    "link-in-text-block": {
+      "pass": "Links pode ser distinguidos do texto ao redor de outra maneira além da cor",
+      "fail": "Links precisam ser distinguidos do texto ao redor de outra maneira além da cor",
+      "incomplete": {
+        "default": "Impossível determinar o contraste",
+        "bgContrast": "O contraste do elemento não pôde ser determinado. Verifique se há um estilo distinto para 'hover'/'focus'.",
+        "bgImage": "O contraste do elemento não pôde ser determinado devido a uma imagem de fundo",
+        "bgGradient": "O contraste do elemento não pôde ser determinado devido a um gradiente de fundo",
+        "imgNode": "O contraste do elemento não pôde ser determinado porque o elemento contém um nó de imagem",
+        "bgOverlap": "O contraste do elemento não pôde ser determinado devido a uma sobreposição do elemento"
+      }
+    },
+    "autocomplete-appropriate": {
+      "pass": "o valor 'autocomplete' está em um elemento apropriado",
+      "fail": "o valor 'autocomplete' está em um elemento inapropriado para este tipo de entrada"
+    },
+    "autocomplete-valid": {
+      "pass": "o atributo 'autocomplete' está corretamente formatado",
+      "fail": "o atributo 'autocomplete' está incorretamente formatado"
+    },
+    "accesskeys": {
+      "pass": "O valor do atributo 'accesskey' é único",
+      "fail": "O documento tem múltiplos elementos com a mesma 'accesskey'"
+    },
+    "focusable-content": {
+      "pass": "O elemento contém elementos focalizáveis",
+      "fail": "O elemento deveria ter conteúdo focalizável"
+    },
+    "focusable-disabled": {
+      "pass": "Nenhum elemento focalizável contido no elemento",
+      "fail": "Conteúdo focalizável deve ser desabilitado ou removido do DOM"
+    },
+    "focusable-element": {
+      "pass": "O elemento é focalizável",
+      "fail": "O elemento deveria ser focalizável"
+    },
+    "focusable-modal-open": {
+      "pass": "Nenhum elemento focalizável enquanto um modal está aberto",
+      "incomplete": "Garanta que os elementos focalizáveis não estejam na ordem de tabulação no estado atual"
+    },
+    "focusable-no-name": {
+      "pass": "O elemento não está na ordem de tabulação ou tem texto acessível",
+      "fail": "O elemento está na ordem de tabulação e não tem nome acessível",
+      "incomplete": "Não foi possível determinar se o elemento tem um nome acessível"
+    },
+    "focusable-not-tabbable": {
+      "pass": "Nenhum elemento focalizável contido no elemento",
+      "fail": "Conteúdo focalizável deve ter tabindex='-1' ou ser removido do DOM"
+    },
+    "frame-focusable-content": {
+      "pass": "O elemento não tem descendentes focalizáveis",
+      "fail": "O elemento tem descendentes focalizáveis",
+      "incomplete": "Não foi possível determinar se o elemento tem descendentes"
+    },
+    "landmark-is-top-level": {
+      "pass": "A região ${data.role} está no nível principal.",
+      "fail": "A região ${data.role} está contida em outra região."
+    },
+    "no-focusable-content": {
+      "pass": "O elemento não tem descendentes focalizáveis",
+      "fail": "O elemento tem descendentes focalizáveis",
+      "incomplete": "Não foi possível determinar se o elemento tem descendentes"
+    },
+    "page-has-heading-one": {
+      "pass": "A página tem pelo menos um título de primeiro nível",
+      "fail": "A página deve ter pelo menos um título de primeiro nível"
+    },
+    "page-has-main": {
+      "pass": "O documento tem pelo menos uma região 'main'",
+      "fail": "O documento não tem uma região 'main'"
+    },
+    "page-no-duplicate-banner": {
+      "pass": "O documento não tem mais de uma região 'banner'",
+      "fail": "O documento tem mais de uma região 'banner'"
+    },
+    "page-no-duplicate-contentinfo": {
+      "pass": "O documento não tem mais de uma região 'contentinfo'",
+      "fail": "O documento tem mais de uma região 'contenteinfo'"
+    },
+    "page-no-duplicate-main": {
+      "pass": "O documento não tem mais de uma região 'main'",
+      "fail": "O documento tem mais de uma região 'main'"
+    },
+    "tabindex": {
+      "pass": "O elemento não tem um 'tabindex' maior do que 0",
+      "fail": "O elemento tem um 'tabindex' maior do que 0"
+    },
+    "alt-space-value": {
+      "pass": "O elemento tem um valor válido para o atributo 'alt'",
+      "fail": "O elemento tem um atributo 'alt' contendo apenas um caracter de espaço, o que não é ignorado por todos os leitores de tela"
+    },
+    "duplicate-img-label": {
+      "pass": "O elemento não duplica um texto existente no atributo 'alt' do elemento <img>",
+      "fail": "O elemento contém o elemento <img> com texto alternativo duplicando um texto existente"
+    },
+    "explicit-label": {
+      "pass": "O elemento de formulário tem um <label> explícito",
+      "fail": "O elemento de formulário não tem um <label> explícito",
+      "incomplete": "Não foi possível determinar se o elemento de formulário tem um <label> explícito"
+    },
+    "help-same-as-label": {
+      "pass": "O texto de ajuda ('title' ou 'aria-describedby') não duplica o texto do rótulo",
+      "fail": "O texto de ajuda ('title' ou 'aria-describedby') é o igual ao texto do rótulo"
+    },
+    "hidden-explicit-label": {
+      "pass": "O elemento de formulário tem um <label> explícito visível",
+      "fail": "O elemento de formulário tem um <label> explícito que está oculto",
+      "incomplete": "Não foi possível determinar se o elemento de formulário tem um <label> explícito que está oculto"
+    },
+    "implicit-label": {
+      "pass": "O elemento de formulário tem um <label> implícito (envolvido)",
+      "fail": "O elemento de formulário não tem <label> implícito (envolvido)",
+      "incomplete": "Não foi possível determinar se o elemento de formulário tem um <label> implícito (envolvido)"
+    },
+    "label-content-name-mismatch": {
+      "pass": "O elemento contém o texto visível como parte do seu nome acessível",
+      "fail": "O texto dentro do elemento não está incluído no nome acessível"
+    },
+    "multiple-label": {
+      "pass": "O campo de formulário não tem múltiplos elementos <label>",
+      "incomplete": "O uso de múltiplos elementos <label> não é amplamente suportado pelas tecnologias assistivas. Certifique-se de que o primeiro <label> contém toda a informação necessária."
+    },
+    "title-only": {
+      "pass": "Elementos de formulário não usam somente o atributo 'title' como seu rótulo",
+      "fail": "Apenas 'title' usado para gerar o rótulo do elemento de formulário"
+    },
+    "landmark-is-unique": {
+      "pass": "As regiões devem ter um 'role' ou combinação de 'role'/'label'/'title' (ou seja, nome acessível) únicos",
+      "fail": "A região deve ter um 'aria-label', 'aria-labelledby', ou 'title' único para tornar as regiões distinguíveis"
+    },
+    "has-lang": {
+      "pass": "O elemento <html> tem um atributo 'lang'",
+      "fail": {
+        "noXHTML": "O atributo 'xml:lang' não é válido em páginas HTML, use o atributo 'lang'.",
+        "noLang": "O elemento <html> não possui um atributo 'lang'"
+      }
+    },
+    "valid-lang": {
+      "pass": "O valor do atributo 'lang' está incluso na lista de idiomas válidos",
+      "fail": "O valor do atributo 'lang' não está incluso na lista de idiomas válidos"
+    },
+    "xml-lang-mismatch": {
+      "pass": "Os atributos 'lang' e 'xml:lang' têm o mesmo idioma base",
+      "fail": "Os atributos 'lang' e 'xml:lang' não têm o mesmo idioma base"
+    },
+    "dlitem": {
+      "pass": "O item da lista de descrição tem um elemento pai <dl>",
+      "fail": "O item da lista de descrição não tem um elemente pai <dl>"
+    },
+    "listitem": {
+      "pass": "O item de lista tem um elemento pai <ul>, <ol> ou role=\"list\"",
+      "fail": {
+        "default": "O item de lista não tem um elemento pai <ul> ou <ol>",
+        "roleNotValid": "O item de lista não tem um elemento pai <ul> ou <ol> sem um 'role', ou um role=\"list\""
+      }
+    },
+    "only-dlitems": {
+      "pass": "O elemento de lista tem somente filhos diretos que são permitidos dentro de elementos <dt> ou <dd>",
+      "fail": "O elemento de lista tem filhos diretos que não são permitidos dentro de elementos <dt> ou <dd>"
+    },
+    "only-listitems": {
+      "pass": "O elemento de lista tem somente filhos diretos que são permitidos dentro de elementos <li>",
+      "fail": {
+        "default": "O elemento de lista tem filhos diretos que não são permitidos dentro de elementos <li>",
+        "roleNotValid": "O elemento de lista tem filhos diretos com um 'role' que não é permitido: ${data.roles}"
+      }
+    },
+    "structured-dlitems": {
+      "pass": "Quando não vazio, o elemento tem ambos elementos <dt> e <dd>",
+      "fail": "Quando não vazio, o elemento não tem nem ao menos um elemento <dt> seguindo de pelo menos um elemento <dd>"
+    },
+    "caption": {
+      "pass": "O elemento multimídia tem uma trilha de legendas",
+      "incomplete": "Verifique se legendas estão disponíveis para o elemento"
+    },
+    "frame-tested": {
+      "pass": "O 'iframe' foi testado com o 'axe-core'",
+      "fail": "O 'iframe' não pôde ser testado com o 'axe-core'",
+      "incomplete": "O 'iframe' ainda tem que ser testado com o 'axe-core'"
+    },
+    "no-autoplay-audio": {
+      "pass": "Elementos <video> ou <audio> não reproduzem áudio por mais do que a duração permitida ou possuem mecanismos de controle",
+      "fail": "Elementos <video> ou <audio> reproduzem áudio por uma duração maior que a permitida ou não possuem mecanismos de controle",
+      "incomplete": "Garanta que elementos <video> ou <audio> não reproduzam áudio por mais do que a duração permitida ou disponibilize mecanismos de controle"
+    },
+    "css-orientation-lock": {
+      "pass": "A tela é operável, e o bloqueio da orientação não existe",
+      "fail": "Bloqueio de orientação CSS aplicado, o que torna a tela inoperável",
+      "incomplete": "Bloqueio de orientação CSS não pode ser determinado"
+    },
+    "meta-viewport-large": {
+      "pass": "A tag <meta> não impede o zoom significativo em dispositivos móveis",
+      "fail": "A tag <meta> limita o zoom em dispositivos móveis"
+    },
+    "meta-viewport": {
+      "pass": "A tag <meta> não desabilita o zoom em dispositivos móveis",
+      "fail": "${data} na tag <meta> desabilita o zoom em dispositivos móveis"
+    },
+    "header-present": {
+      "pass": "A página tem um cabeçalho (header)",
+      "fail": "A página não tem um cabeçalho (header)"
+    },
+    "heading-order": {
+      "pass": "Hierarquia de títulos válida",
+      "fail": "Hierarquia de títulos inválida"
+    },
+    "identical-links-same-purpose": {
+      "pass": "Não há outros links com o mesmo nome, que direcionem para uma URL diferente",
+      "incomplete": "Verifique se os links têm o mesmo propósito ou são intencionalmente ambíguos."
+    },
+    "internal-link-present": {
+      "pass": "Link de escape válido encontrado",
+      "fail": "Nenhum link de escape válido encontrado"
+    },
+    "landmark": {
+      "pass": "A página tem uma região (landmark)",
+      "fail": "A página não tem nenhuma região (landmark)"
+    },
+    "meta-refresh": {
+      "pass": "A tag <meta> não atualiza a página imediatamente",
+      "fail": "A tag <meta> força atualizações temporizadas da página"
+    },
+    "p-as-heading": {
+      "pass": "Elementos <p> não são estilizados como títulos",
+      "fail": "Elementos de título devem ser utilizados no lugar de elementos <p> estilizados"
+    },
+    "region": {
+      "pass": "Todo o conteúdo da página está contido em regiões (landmarks)",
+      "fail": "Algum conteúdo da página não está contido em regiões (landmarks)"
+    },
+    "skip-link": {
+      "pass": "Destino do link de escape existe",
+      "incomplete": "Destino do link de escape deve se tornar visível na ativação",
+      "fail": "Nenhum destino para o link de escape"
+    },
+    "unique-frame-title": {
+      "pass": "O atributo 'title' do elemento é único",
+      "fail": "O atributo 'title' do elemento não é único"
+    },
+    "duplicate-id-active": {
+      "pass": "O documento não tem elementos ativos que compartilham o mesmo atributo 'id'",
+      "fail": "O documento tem elementos ativos com o mesmo atributo 'id': ${data}"
+    },
+    "duplicate-id-aria": {
+      "pass": "O documento não tem elementos referenciados com ARIA ou rótulos que compartilham o mesmo atributo 'id'",
+      "fail": "O documento tem múltiplos elementos referenciados com ARIA com o mesmo atributo 'id': ${data}"
+    },
+    "duplicate-id": {
+      "pass": "O documento não tem elementos estáticos que compartilham o mesmo atributo 'id'",
+      "fail": "O documento tem múltiplos elementos estáticos com o mesmo atributo 'id'"
+    },
+    "aria-label": {
+      "pass": "O atributo 'aria-label' existe e não está vazio",
+      "fail": "O atributo 'aria-label' não existe ou está vazio"
+    },
+    "aria-labelledby": {
+      "pass": "O atributo 'aria-labelledby' existe e referencia elementos que são visíveis aos leitores de tela",
+      "fail": "O atributo 'aria-labelledby' não existe, referencia elementos que não existem ou são vazios",
+      "incomplete": "certifique-se de que 'aria-labelledby' referencie um elemento existente"
+    },
+    "avoid-inline-spacing": {
+      "pass": "Nenhum estilo 'inline' com '!important' que afete o espaçamento do texto foi especificado",
+      "fail": {
+        "singular": "Remova '!important' do estilo 'inline' ${data.values}, uma vez que sobrepor isto não é suportado pela maioria dos navegadores",
+        "plural": "Remova '!important' dos estilos 'inline' ${data.values}, uma vez que sobrepor isto não é suportado pela maioria dos navegadores"
+      }
+    },
+    "button-has-visible-text": {
+      "pass": "O elemento tem texto interno que é visível aos leitores de tela",
+      "fail": "O elemento não tem texto interno que seja visível aos leitores de tela",
+      "incomplete": "Não foi possível determinar se o elemento tem filhos"
+    },
+    "doc-has-title": {
+      "pass": "O documento tem um elemento <title> não vazio",
+      "fail": "O documento não tem um elemento <title> não vazio"
+    },
+    "exists": {
+      "pass": "O elemento não existe",
+      "incomplete": "O elemento existe"
+    },
+    "has-alt": {
+      "pass": "O elemento tem um atributo 'alt'",
+      "fail": "O elemento não tem um atributo 'alt'"
+    },
+    "has-visible-text": {
+      "pass": "O elemento tem texto que é visível aos leitores de tela",
+      "fail": "O elemento não tem texto que seja visível aos leitores de tela",
+      "incomplete": "Não foi possível determinar se o elemento tem filhos"
+    },
+    "is-on-screen": {
+      "pass": "O elemento não é visível",
+      "fail": "O elemento é visível"
+    },
+    "non-empty-alt": {
+      "pass": "O elemento tem um atributo 'alt' não vazio",
+      "fail": {
+        "noAttr": "O elemento não tem um atributo 'alt'",
+        "emptyAttr": "O elemento tem um atributo 'alt' vazio"
+      }
+    },
+    "non-empty-if-present": {
+      "pass": {
+        "default": "O elemento tem um atributo 'value",
+        "has-label": "O elemento tem um atributo 'value' não vazio"
+      },
+      "fail": "O elemento tem um atributo 'value' e ele está vazio"
+    },
+    "non-empty-placeholder": {
+      "pass": "O elemento tem um atributo 'placeholder'",
+      "fail": {
+        "noAttr": "O elemento não tem um atributo 'placeholder'",
+        "emptyAttr": "O elemento tem um atributo 'placeholder' vazio"
+      }
+    },
+    "non-empty-title": {
+      "pass": "O elemento tem um atributo 'title'",
+      "fail": {
+        "noAttr": "O elemento não tem um atributo 'title'",
+        "emptyAttr": "O elemento tem um atributo 'title' vazio"
+      }
+    },
+    "non-empty-value": {
+      "pass": "O elemento tem um atributo 'value' não vazio",
+      "fail": {
+        "noAttr": "O elemento não tem um atributo 'value'",
+        "emptyAttr": "O elemento tem um atributo 'value' vazio"
+      }
+    },
+    "presentational-role": {
+      "pass": "A semântica padrão do elemento foi sobrescrita com role=\"${data.role}\"",
+      "fail": {
+        "default": "A semântica padrão do elemento não foi sobrescrita com role=\"none\" or role=\"presentation\"",
+        "globalAria": "A função do elemento não é de apresentação pois ele tem um atributo ARIA global",
+        "focusable": "A função do elemento não é de apresentação pois ele é focalizável",
+        "both": "A função do elemento não é de apresentação pois ele tem um atributo ARIA global e é focalizável"
+      }
+    },
+    "role-none": {
+      "pass": "A semântica padrão do elemento foi sobrescrita com role=\"none\"",
+      "fail": "A semântica padrão do elemento não foi sobrescrita com role=\"none\""
+    },
+    "role-presentation": {
+      "pass": "A semântica padrão do elemento foi sobrescrita com role=\"presentation\"",
+      "fail": "A semântica padrão do elemento não foi sobrescrita com role=\"presentation\""
+    },
+    "svg-non-empty-title": {
+      "pass": "O elemento tem um filho <title>",
+      "fail": {
+        "noTitle": "O elemento não tem um filho que seja 'title'",
+        "emptyTitle": "O 'title' filho do elemento está vazio"
+      },
+      "incomplete": "Não foi possível determinar se o elemento tem um filho que seja um 'title'"
+    },
+    "caption-faked": {
+      "pass": "A primeira linha de uma tabela não é usada como legenda",
+      "fail": "O primeiro elemento da tabela deve ser um <caption> em vez de uma célula da tabela"
+    },
+    "html5-scope": {
+      "pass": "O atributo 'scope' só é utilizado em elementos de cabeçalho de tabela (<th>)",
+      "fail": "No HTML 5, os atributos 'scope' só devem ser utilizados em elementos de cabeçalho de tabela (<th>)"
+    },
+    "same-caption-summary": {
+      "pass": "O conteúdo do atributo 'summary' e <caption> não estão duplicados",
+      "fail": "O conteúdo do atributo 'summary' e <caption> são idênticos"
+    },
+    "scope-value": {
+      "pass": "O atributo 'scope' é usado corretamente",
+      "fail": "O valor do atributo 'scope' pode ser apenas 'row' ou 'col'"
+    },
+    "td-has-header": {
+      "pass": "Todos as células de dados não vazias possuem cabeçalhos",
+      "fail": "Algumas células de dados não vazias não possuem cabeçalho"
+    },
+    "td-headers-attr": {
+      "pass": "O atributo 'headers' é usado exclusivamente para referenciar outras células da tabela",
+      "incomplete": "O atributo 'headers' está vazio",
+      "fail": "O atributo 'headers' não é usado exclusivamente para referenciar outras células da tabela"
+    },
+    "th-has-data-cells": {
+      "pass": "Todas as células de cabeçalho da tabela se referem a células de dados",
+      "fail": "Nem todas as células de cabeçalho da tabela se referem a células de dados",
+      "incomplete": "Células de dados da tabela estão ausentes ou vazias"
+    },
+    "hidden-content": {
+      "pass": "Todo o conteúdo da página foi analisado.",
+      "fail": "Houve problemas ao analisar o conteúdo desta página.",
+      "incomplete": "Existe conteúdo oculto na página que não foi analisado. Será preciso provocar a exibição deste conteúdo para poder analisá-lo."
+    }
+  },
+  "failureSummaries": {
+    "any": {
+      "failureMessage": "Corrija qualquer um dos itens a seguir:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    },
+    "none": {
+      "failureMessage": "Corrija todos os itens a seguir:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+    }
+  },
+  "incompleteFallbackMessage": "Corrija todos os itens a seguir:{{~it:value}}\n  {{=value.split('\\n').join('\\n  ')}}{{~}}"
+}

node_modules/axe-core/package.json

@@ -0,0 +1,200 @@
+{
+  "name": "axe-core",
+  "description": "Accessibility engine for automated Web UI testing",
+  "version": "4.10.0",
+  "license": "MPL-2.0",
+  "engines": {
+    "node": ">=4"
+  },
+  "contributors": [
+    {
+      "name": "David Sturley",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    },
+    {
+      "name": "Dylan Barrell",
+      "email": "dylan@barrell.com",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    },
+    {
+      "name": "Wilco Fiers",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    },
+    {
+      "name": "Dian Fay",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    },
+    {
+      "name": "Marcy Sutton",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    },
+    {
+      "name": "Ava Gaiety Wroten",
+      "organization": "Deque Systems, Inc.",
+      "url": "http://deque.com/"
+    }
+  ],
+  "homepage": "https://www.deque.com/axe/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dequelabs/axe-core.git"
+  },
+  "keywords": [
+    "Accessibility",
+    "a11y",
+    "testing",
+    "unit",
+    "tdd",
+    "bdd",
+    "axe"
+  ],
+  "main": "axe.js",
+  "typings": "axe.d.ts",
+  "files": [
+    "axe.js",
+    "axe.min.js",
+    "axe.d.ts",
+    "sri-history.json",
+    "locales/",
+    "LICENSE-3RD-PARTY.txt"
+  ],
+  "standard-version": {
+    "scripts": {
+      "postbump": "npm ci && npm run sri-update && git add doc/rule-descriptions.md"
+    },
+    "skip": {
+      "tag": true
+    }
+  },
+  "scripts": {
+    "start": "http-server -a \"\" -p 9876 --silent",
+    "develop": "grunt dev --force",
+    "api-docs": "jsdoc --configure .jsdoc.json",
+    "build": "grunt",
+    "patch": "npx patch-package",
+    "unpatch": "npx patch-package --reverse",
+    "eslint": "eslint --color --format stylish '{lib,test,build,doc}/**/*.js' 'Gruntfile.js'",
+    "test": "npm run test:tsc && run-s \"test:unit:* -- {@}\" --",
+    "test:tsc": "tsc",
+    "test:unit": "karma start test/karma.conf.js",
+    "test:debug": "npm run test:unit -- --no-single-run --browsers=ChromeDebugging",
+    "test:unit:core": "npm run test:unit -- testDirs=core",
+    "test:unit:commons": "npm run test:unit -- testDirs=commons",
+    "test:unit:rule-matches": "npm run test:unit -- testDirs=rule-matches",
+    "test:unit:checks": "npm run test:unit -- testDirs=checks",
+    "test:unit:api": "npm run test:unit -- testDirs=api",
+    "test:unit:integration": "npm run test:unit -- testDirs=integration",
+    "test:unit:virtual-rules": "npm run test:unit -- testDirs=virtual-rules",
+    "integration": "node test/integration/full/test-webdriver.js",
+    "integration:apg": "mocha --fail-zero test/aria-practices/*.spec.js",
+    "integration:chrome": "npm run integration -- browser=Chrome",
+    "integration:firefox": "npm run integration -- browser=Firefox",
+    "test:integration": "npm run test:integration:chrome",
+    "test:integration:chrome": "start-server-and-test 9876 integration:chrome",
+    "test:integration:firefox": "start-server-and-test 9876 integration:firefox",
+    "test:examples": "node ./doc/examples/test-examples",
+    "test:act": "mocha --fail-zero test/act-rules/*.spec.js",
+    "test:apg": "start-server-and-test 9876 integration:apg",
+    "test:locales": "mocha test/test-locales.js",
+    "test:virtual-rules": "mocha test/test-virtual-rules.js",
+    "test:rule-help-version": "mocha test/test-rule-help-version.js",
+    "test:node": "node test/node/node.js",
+    "test:jsdom": "mocha test/node/jsdom.js",
+    "version": "echo \"use 'npm run release' to bump axe-core version\" && exit 1",
+    "release": "git fetch origin --tags --force && standard-version -a",
+    "rule-gen": "node build/rule-generator",
+    "next-release": "standard-version --scripts.prebump=./build/next-version.js --skip.commit=true --skip.tag=true",
+    "sri-update": "grunt build && node build/sri-update && git add sri-history.json",
+    "sri-validate": "node build/sri-update --validate",
+    "fmt": "prettier --write .",
+    "prepare": "husky && npm run patch",
+    "prebuild": "node ./build/check-node-version.js",
+    "pretest": "node ./build/check-node-version.js",
+    "postbuild": "prettier --write ./locales/_template.json ./doc/rule-descriptions.md"
+  },
+  "devDependencies": {
+    "@axe-core/webdriverjs": "^4.9.0",
+    "@babel/core": "^7.20.12",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/runtime-corejs3": "^7.20.7",
+    "@deque/dot": "^1.1.5",
+    "aria-practices": "github:w3c/aria-practices#ce0336bd82d7d3651abcbde86af644197ddbc629",
+    "aria-query": "^5.1.3",
+    "browser-driver-manager": "1.0.4",
+    "chai": "^4.3.7",
+    "chalk": "^4.x",
+    "chromedriver": "latest",
+    "clean-jsdoc-theme": "^4.2.17",
+    "clone": "^2.1.2",
+    "colorjs.io": "0.4.3",
+    "conventional-commits-parser": "^5.0.0",
+    "core-js": "^3.27.1",
+    "css-selector-parser": "^1.4.1",
+    "emoji-regex": "^10.2.1",
+    "es6-promise": "^4.2.8",
+    "esbuild": "^0.10.x",
+    "eslint": "^9.2.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-mocha-no-only": "^1.2.0",
+    "execa": "5.x",
+    "glob": "^10.3.10",
+    "globals": "^15.2.0",
+    "grunt": "^1.5.3",
+    "grunt-babel": "^8.0.0",
+    "grunt-bytesize": "^0.2.0",
+    "grunt-contrib-clean": "^2.0.1",
+    "grunt-contrib-concat": "^2.1.0",
+    "grunt-contrib-uglify": "^5.2.2",
+    "grunt-contrib-watch": "^1.1.0",
+    "html-entities": "^2.4.0",
+    "http-server": "^14.1.1",
+    "husky": "^9.0.7",
+    "inquirer": "^8.2.5",
+    "jquery": "^3.6.3",
+    "jsdoc": "^4.0.2",
+    "jsdom": "^24.0.0",
+    "karma": "^6.4.1",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-mocha": "^2.0.1",
+    "karma-sinon": "^1.0.5",
+    "karma-spec-reporter": "^0.0.36",
+    "lint-staged": "^15.0.2",
+    "memoizee": "^0.4.15",
+    "mocha": "^10.2.0",
+    "node-notifier": "^10.0.1",
+    "npm-run-all": "^4.1.5",
+    "outdent": "^0.8.0",
+    "patch-package": "^8.0.0",
+    "prettier": "^3.0.3",
+    "revalidator": "^0.3.1",
+    "selenium-webdriver": "^4.7.1",
+    "serve-handler": "^6.1.5",
+    "sinon": "^18.0.0",
+    "sri-toolbox": "^0.2.0",
+    "standard-version": "^9.5.0",
+    "start-server-and-test": "^2.0.1",
+    "typedarray": "^0.0.7",
+    "typescript": "^5.2.2",
+    "uglify-js": "^3.17.4",
+    "wcag-act-rules": "github:w3c/wcag-act-rules#dc90495a5533d326b300ee5a9487afdfc6d493c0",
+    "weakmap-polyfill": "^2.0.4"
+  },
+  "lint-staged": {
+    "*.{md,json,ts,html}": [
+      "prettier --write"
+    ],
+    "*.js": [
+      "prettier --write",
+      "eslint --fix"
+    ]
+  }
+}

node_modules/axe-core/sri-history.json

@@ -0,0 +1,386 @@
+{
+  "1.0.1": {
+    "axe.js": "sha256-F14wfpbaL6+ZafS2ufmz74/R6CD1L777gCOJVuLn5Ao=",
+    "axe.min.js": "sha256-GfbQgd6aKJKQT21HaQfVUuGEbMUfSKhi7RsWrrih7SM="
+  },
+  "1.1.0": {
+    "axe.js": "sha256-nG9+LLksY/HS6yG4x0iS08U7RAmTucy50uXQS5ndQnM=",
+    "axe.min.js": "sha256-5Lfk3/s+ieHttrDTOCVuepGjDgH2D1neTDDtXnJdIT0="
+  },
+  "1.1.1": {
+    "axe.js": "sha256-K0MLUClls79s14CT01F82LPc+ZubTBwt6fZDdN5iyFw=",
+    "axe.min.js": "sha256-UWXq259l36QypXwd2e4K2V1Lli2qHeSPmKfDXy+7uIM="
+  },
+  "2.0.5": {
+    "axe.js": "sha256-KVA5sj4tNmFLneuHPPbg4iEp3MBzsHvn3+s9CxfMrmc=",
+    "axe.min.js": "sha256-lt5eNq/L7IBUaoSUSAbQ7MEO02DThMGdVm/oxeA88gk="
+  },
+  "2.0.6": {
+    "axe.js": "sha256-cLV1ABoE5NjfwLaRAJYIstAJCmciDXZ55/TrQS5rR/M=",
+    "axe.min.js": "sha256-fnbwW70tA7/ya+5q5Oimc8wCRsdiv3WrU0MElp/euvY="
+  },
+  "2.0.7": {
+    "axe.js": "sha256-HjHe1xKQqP6i3eGpDlARb5HkFsZxvAslvr1JJhUlp60=",
+    "axe.min.js": "sha256-vo7Qs4YxFxzFEW5DG9u05JdAUCsFxx7dBIoBP5rzmKA="
+  },
+  "2.1.7": {
+    "axe.js": "sha256-kXUowSb3HQy6AChF4LYR4cvNxKEHCWqCcuiSxvY6E1s=",
+    "axe.min.js": "sha256-xJPQwkKDFmgwYDLqrt/esIHlc2HLUB2ogf9c1uS1BXA="
+  },
+  "2.2.0": {
+    "axe.js": "sha256-0iX4Q9QT3uHAo+oxS5NWsrU4DNZKB30JRf7m+jjZcX0=",
+    "axe.min.js": "sha256-3UsQJdfWbhtVd0QzcYi2VAJEfs8DMzxrRvr3h9WbMiE="
+  },
+  "2.2.1": {
+    "axe.js": "sha256-1kuZOWtoYszbvrtG7TYfl/FuO48uwZeFpN4aNnebABk=",
+    "axe.min.js": "sha256-WSHVQ1/IJaG9ZOydoFg+QXHLjOq8x/mhYkRAyN1yAdI="
+  },
+  "2.2.2": {
+    "axe.js": "sha256-jTirRblNTKinTlmCK3FqDG6POtZVbP/bJNdrXZhCuqk=",
+    "axe.min.js": "sha256-zpmYSLTgHx09UyYIvYrS5K6uj4VuBbspk54kHk5hPqo="
+  },
+  "2.2.3": {
+    "axe.js": "sha256-dV8RkE0hyyzj7qgValVkoP7Rtu8789BmbyeHZmidvqA=",
+    "axe.min.js": "sha256-BrNWjOcDL265Me8eKQosGWerJ6ju2g+G9+RvMWiBGOA="
+  },
+  "2.3.0": {
+    "axe.js": "sha256-rkyHB2lHjs+tissQLBUxuxIvWlzRbS4f4cdaH+TjQvo=",
+    "axe.min.js": "sha256-MGWkallV18uw6bSq6w8cjbGsf9v4rJtXP+NDtMEbO14="
+  },
+  "2.3.1": {
+    "axe.js": "sha256-63oq1xHBiOhX9jlvn5sJmoL8TwJ8JaLYIB91gyb74RI=",
+    "axe.min.js": "sha256-BGAllCBTUJjJXw3yOPMVai2Bj+1PVaEhK2na699nI/o="
+  },
+  "2.4.1": {
+    "axe.js": "sha256-nR7Ix22wBzWJJw7bNukb3n8Bw16bvHdpGKW86+G8dU4=",
+    "axe.min.js": "sha256-xVpSddrzxbQVFp90jaOUOQGp3fwCwK4sYxYmkIU3N2c="
+  },
+  "2.4.2": {
+    "axe.js": "sha256-x1Yy3nmIKx4qWNKjPy+jtpXSozwbuFsLez1iHliFgEQ=",
+    "axe.min.js": "sha256-v8V4N5vGmwEq7XbSIyUkGN9TrjhGBHjM1ZuAAIhgp6o="
+  },
+  "2.5.0": {
+    "axe.js": "sha256-NYUXSdma9KjPfzmpt7jw/hlbmeAha8K3zEA2UOW+eWw=",
+    "axe.min.js": "sha256-7MV3BvKtgHeecwFjYOBYJbmOhvh2wdTGU7odxgpcrG0="
+  },
+  "2.6.0": {
+    "axe.js": "sha256-zK6kpREBDqi1wucJ1GoH9UafxT0E0+XUnrSzg03wdmw=",
+    "axe.min.js": "sha256-vqKSLjjqbp9J3seCuphn1h/3OC6o5jntS8LtlIftvdY="
+  },
+  "2.6.1": {
+    "axe.js": "sha256-fFHgLOnvH7mY6LNF58cvts9CXZCsyUgd++hhHeZpowo=",
+    "axe.min.js": "sha256-arpGpcEwKuAfd4XQmHqNdmXP/nUvm4eMonLh+L0s6cc="
+  },
+  "3.0.0-alpha.7": {
+    "axe.js": "sha256-10kIurI2DW5bjegHOgc/MMSHiiXK2CAVWCQfoN6h0fs=",
+    "axe.min.js": "sha256-cDpGlEEbGsAh0MI82ZFwvX+oOpD5j+uo+kjKH/gJ5t4="
+  },
+  "3.0.0-alpha.8": {
+    "axe.js": "sha256-1ZYjd7ajlao8zM/E8GJLh7u0H/uoMgO5K1fayVUOW5Q=",
+    "axe.min.js": "sha256-hqbtoVFN2hNjaNhgH2anN1itc31jUDUnOX2cj/6SR2M="
+  },
+  "3.0.0-alpha.9": {
+    "axe.js": "sha256-9eUbLQe6YDrwxRsdNnAeTGoBV3lTIrzokBmP2gaStBI=",
+    "axe.min.js": "sha256-2nIufAEb6J4t/f/mnSa3D16vrdcBd0fPjEFy81F+N7k="
+  },
+  "3.0.0-beta.1": {
+    "axe.js": "sha256-F9UktrEmuvDZZ3uYq5WVR9pyfgS+IP+RmRMq8WY6NzU=",
+    "axe.min.js": "sha256-K0dHFoOFTxCCdRuVrey4KVRGQx6Oj5afJyp3YVpZNz0="
+  },
+  "3.0.0-beta.2": {
+    "axe.js": "sha256-cMk6LIQ0mYRm54wqfZ6O2U/6BT6XpHPjqIPVyhMMHYU=",
+    "axe.min.js": "sha256-66fXkU5+wmx5X9sURMglHTsWKO8R+LoOIcBwB8N9dPI="
+  },
+  "3.0.0-beta.3": {
+    "axe.js": "sha256-9le58CGdN3pVlavrlAiyCmo276kXpnTKIIgFRlUhauI=",
+    "axe.min.js": "sha256-yzD9M6lgRosBZtC6x3acx5XaiLgR2jAWe1dDMqutmbs="
+  },
+  "3.0.0": {
+    "axe.js": "sha256-1wR8RsA0/NYF2caKkmvgOqcCoyZXOZK2q7/EfZ4Y8Fo=",
+    "axe.min.js": "sha256-6SQ3NZobDnpEoUWc8h2u+4G3H2/yzt53VX3nv9PZ8g8="
+  },
+  "3.0.1": {
+    "axe.js": "sha256-Vf/arxSrHppK2X5x6VgBZLJnCy8yK6P6uH99WwzQ30s=",
+    "axe.min.js": "sha256-vMPyo7vifw5RTaVEAlnfwGFa9VyHymsNqanCsHh3Q8c="
+  },
+  "3.0.2": {
+    "axe.js": "sha256-D24i3Yy35gMxOZNTNZyQLAyL3W3wVvW1wUYakK5v1VI=",
+    "axe.min.js": "sha256-Hsc1oDUNhkVBP4gVUaC9jNm9t0qmLpTJzXW4uzx10bo="
+  },
+  "3.0.3": {
+    "axe.js": "sha256-QhYA1btt0EGa6HUDloEPZ5p6ZArWsL8J9C7PDoqi320=",
+    "axe.min.js": "sha256-Xlzi+kk/RJRo2x/+w04BppEgcrO/Cy9xTSbuIp6m/CU="
+  },
+  "3.0.4": {
+    "axe.js": "sha256-l8dI6H61gah8+nZRMFdcZkCU08rxvMgpUaRx0Hs/lL8=",
+    "axe.min.js": "sha256-cqgH55deHQaFac6ItvRSV9eRcUbf4dlqjc3Nwp1jUUI="
+  },
+  "3.1.0": {
+    "axe.js": "sha256-qUMvWIpNXGal2tqBIDJsrXde0clrbTcATxlteQSyA4M=",
+    "axe.min.js": "sha256-q1K/bHXBTINVndnMyDdntNSJHTAei0YhN/kNqeaGD5A="
+  },
+  "3.1.1": {
+    "axe.js": "sha256-54k0QW1jMWPC2Lq/pTSX2xu8ky7QSd39uEqcy3Yk35o=",
+    "axe.min.js": "sha256-Zs6maznrnIa0ko83hAWIKlhPPeBLmKmRmfphyuqBJbA="
+  },
+  "3.1.2": {
+    "axe.js": "sha256-goUY5vBRPoITOCdg7HK/vfHRs50+RdQRQQkNCU3lnMs=",
+    "axe.min.js": "sha256-wIvlzfT77n6fOnSL6/oLbzB873rY7QHTW/e0Z0mOoYs="
+  },
+  "3.1.3": {
+    "axe.js": "sha256-X/FaOBNaYhVis9NrSYGNPLyjzkmTD1OqSc8o7A9y2RA=",
+    "axe.min.js": "sha256-KpiyZmcHc5wnCsMY7WLhvQEuB3wz1mjV7UA//ifbCK4="
+  },
+  "3.2.0": {
+    "axe.js": "sha256-wdCvSfDepBhwcvTqB0gm586ywpla6Yi81qLCHjegILM=",
+    "axe.min.js": "sha256-Tvf4toyAt1NFmmkuLsgStXW+4pcG5GG9ugopPoOvOwg="
+  },
+  "3.2.1": {
+    "axe.js": "sha256-VPX1ngRx0XWqC5BP9XdHoDd8YlbgXGK39cz14GBL9bg=",
+    "axe.min.js": "sha256-ynN9JxvxoI9VpL7IbdTVCUCLhy3N7Ygrnit2r7a2vK8="
+  },
+  "3.2.2": {
+    "axe.js": "sha256-ekZaZcmreeOq0/Hm0MYYpjK2k/HfLIBchbdzynX2s1A=",
+    "axe.min.js": "sha256-WUsm7HQhfTPm48UUbRuQCZ6mXZXpO+trPivOXYelKM0="
+  },
+  "3.2.3": {
+    "axe.js": "sha256-l36pxPggxG0w7W9WFK21lyw9uaObTj3M5gS1Fl7ZABo=",
+    "axe.min.js": "sha256-c+LGvM2VcJVUXwaqzmDeKLDBMJSZgKUhnW9GK3JkZ5o="
+  },
+  "3.2.4": {
+    "axe.js": "sha256-EBY9p4epOAuqOfHhHDmA03TuKUqarplY3FA97bGDwyY=",
+    "axe.min.js": "sha256-heYXBvx3dOPu5dGnEKhOr2FyynWFxWht0bslELqiUAo="
+  },
+  "3.3.0": {
+    "axe.js": "sha256-9qKFcrJohPVSRdWg+nYMf1cnxUz00rojnrcDbRpofP4=",
+    "axe.min.js": "sha256-t2QDE4+vMfgX52JfOztdvXHLxDJLc9Gc1O583kc4l/s="
+  },
+  "3.3.1": {
+    "axe.js": "sha256-MdbXT1qQi6W6AGWVUzUROzk8KhsTy6ePEpa3pBhO1S4=",
+    "axe.min.js": "sha256-x2j+s50F+GHZZWsTK2GWiJtcHo4MDvc5zpuIFTwXioY="
+  },
+  "3.3.2": {
+    "axe.js": "sha256-0gx9+aOF0I9F91zdACXlV8C0eZRP0bjKORUPDFuGOkw=",
+    "axe.min.js": "sha256-eMkj7GARritK91GFkbOxZind0uesDKEOXS/AggeFJ4E="
+  },
+  "3.3.3": {
+    "axe.js": "sha256-cWikFVL1B7T3kafsX1ESurvIh/+2bFrhX8CKJJUNnQ0=",
+    "axe.min.js": "sha256-L/faUr+k2zA3fuo4l2T7mIpMxL8vPB3CWsSujoLyKLk="
+  },
+  "3.3.4": {
+    "axe.js": "sha256-hcKoJVuQBu5iOURV1//SJrAFn4Gx8rooN/SmKOr5o9g=",
+    "axe.min.js": "sha256-P/yLNTZPLmpl/OLh4pfocIWG8J6HDuv9oXNhFIRvIOc="
+  },
+  "3.4.0": {
+    "axe.js": "sha256-J7v+KmmfiDeImDENld25aBnvcJyhg2Z/PayxJyJmL3A=",
+    "axe.min.js": "sha256-3uvAwJcMTsYRtepeqr32rrpy5zZ/fMYjiKEKPZM6Rtc="
+  },
+  "3.4.1": {
+    "axe.js": "sha256-2mBsmz6UhYUk3gYnRiMkzuJTiHd86XCEA/Rxf3tN7l8=",
+    "axe.min.js": "sha256-z1eK+dbxVx44jv/XqW4xYJlyA9T9zXuxMlJbNJfTvOg="
+  },
+  "3.4.2": {
+    "axe.js": "sha256-1O2tV4TBC/8pYjxbIwj192fUX1SJvsjn8KQH3PdJUuU=",
+    "axe.min.js": "sha256-XXgQWSZNsMKcqEQnEU2BDkIfCzV6gCjOjrwnrzioYm4="
+  },
+  "3.4.3": {
+    "axe.js": "sha256-SaFKkccPxaPG6ZNeF2DOwDpKSQlZ/AIrfLJq3R7IDQ4=",
+    "axe.min.js": "sha256-riQur+AZD7BQyyNzplymxhdhwsEBQHiaJwM5ozy3ISw="
+  },
+  "3.5.0": {
+    "axe.js": "sha256-w/zYk9v7UUawn15gNmZHGrh8WdzCI1bSxmRM2N7Uk4o=",
+    "axe.min.js": "sha256-p3SZwFLtGBl/V92T6V9wJvUEkr5GvLswqkPy8rt49S0="
+  },
+  "3.5.1": {
+    "axe.js": "sha256-J5+J6tFJyKx7Jyn9xK3rJhAyJCGAPR6kOwzXjpdFbEM=",
+    "axe.min.js": "sha256-wo0QYtgoayRMifoYIHc8Spw5NmeFN4ojGLSqmrUuhX8="
+  },
+  "3.5.2": {
+    "axe.js": "sha256-wf7AYQ0YxwohIAqhYIfQ6y1VDQmP2zbgGhL6mb8a+Eg=",
+    "axe.min.js": "sha256-suutTbfowm19n2znRYpsLOcHOkwv9g+ximjS8TLJ6/8="
+  },
+  "3.5.3": {
+    "axe.js": "sha256-lO/Zp+gRgYruJbjyvHOfqWqqroJ2ogTLJ64DwunyUz4=",
+    "axe.min.js": "sha256-Oh5/ClgfAAKQWyCvlU3F+Ud6QDsS0myLJr866QFt67w="
+  },
+  "3.5.4": {
+    "axe.js": "sha256-4f1ZZbAr3xgoAputB3oZK5ASoazrNIw6SU2M1Nnb4bg=",
+    "axe.min.js": "sha256-XDhCakYtcQtOpujvhE876/a4fUyZjiKtNn8xniP03Ek="
+  },
+  "3.5.5": {
+    "axe.js": "sha256-u+Xkb1EmxyRof8YJD9nPMbq9e3VXBj5cO99aEtr2uEs=",
+    "axe.min.js": "sha256-ODhTB+pG6Fxp1+zEO2uNekC30gj1q8gQ4iCZZpMQhuE="
+  },
+  "3.5.6": {
+    "axe.js": "sha256-kEgieHQSxGEe1pEXRrbCXuzUtQe3riQHWP3b9GCB2vc=",
+    "axe.min.js": "sha256-0fQXgcsl+WahejLCUoWzSNSPChr65aPlw5P7jsCpoVc="
+  },
+  "4.0.0": {
+    "axe.js": "sha256-F408iSv2h/vUtSWZ0hzzKvfoV6TVr25kzqD4CZE3gnk=",
+    "axe.min.js": "sha256-TtQRMYXl4FFwO5r1PgEpv9qfeYUQTUKv4w6M0Mu3wnE="
+  },
+  "4.0.1": {
+    "axe.js": "sha256-qt/1RCmnUExiG4pAxxvS14Rv5WG2mUl3D/9ZG5hIOoo=",
+    "axe.min.js": "sha256-UX2nqe7C94kL3oes720eLjMxFcJgNYjwEYgAeIVpdMM="
+  },
+  "4.0.2": {
+    "axe.js": "sha256-J5lSA5Tjmd8TJgXJw1nplpRsm+0oZdxZhzh3svJCRTA=",
+    "axe.min.js": "sha256-Lalcd7gfejE06N+Tl7ZMgGdmyHp77fT8Jlu4mQLH7Nc="
+  },
+  "4.0.3": {
+    "axe.js": "sha256-VQi0wRLTfYCI6xi/IuxJw54g36VbqYkmR61gKkop0f8=",
+    "axe.min.js": "sha256-lQoBfvmYSxUMKoH5XANiG3ubapXmQ7v+iYjlJ9UngWA="
+  },
+  "4.1.0": {
+    "axe.js": "sha256-CpsJouSBpr1ARLhTtIKjZlS1eMWKAdb6k2USgtNGHQI=",
+    "axe.min.js": "sha256-Slv1vTH024BG87L3ztHvVdlKpeQXG+wN5BcNMcHp1qk="
+  },
+  "4.1.1": {
+    "axe.js": "sha256-Tz6yShAcKxP8ce//YhbRkOLinUj+htEK2MjIi5yjY58=",
+    "axe.min.js": "sha256-43geecotYZGPnRt6o9Uu7Pjl3GthxnDacXrzCGv11go="
+  },
+  "4.1.2": {
+    "axe.js": "sha256-wnrhK+P+FXp6U/oYQrYVu6/6PrpO0chRAkik/2ENuS0=",
+    "axe.min.js": "sha256-TzERMakAkktf5sw0quZYuHVmniguowRhWRIVYpjbLbA="
+  },
+  "4.1.3": {
+    "axe.js": "sha256-T1FukaTlhjibBqAm8SBwYmo8GLAHdn45r52XRllMdv8=",
+    "axe.min.js": "sha256-2Z3/OrInIQjAzZ5kMvTBZ2CDUiAgUG/2J5ca1XpNfYw="
+  },
+  "4.1.4": {
+    "axe.js": "sha256-MURsYMNnII8EGBcbmd0FGY36x9dICBq6IDOz+hnaJns=",
+    "axe.min.js": "sha256-dYHtyLO/5lpm5JgQFWzcf3DFg4BvMTf9MDfZG7nxMEM="
+  },
+  "4.2.0": {
+    "axe.js": "sha256-RWY2EhLV83s/DmYMCNZM1ZNSVeVWyYMIXosbCvbSvUs=",
+    "axe.min.js": "sha256-DGi+8Cpa4CzwJcmtJI/xUnpEDLfhn6mgyescUhP8W8g="
+  },
+  "4.2.1": {
+    "axe.js": "sha256-DK0go8gPzyLAfXpA0r1wKNnpIYqSAtKJx2XkUxw3cp8=",
+    "axe.min.js": "sha256-GY7NT5JqpkYWliaJ+xXDHf0t5o30jVvEHb5KRVXykXA="
+  },
+  "4.2.2": {
+    "axe.js": "sha256-K3oF47ZvKGUvc3E1qiF7l3pyLK9WoxuUobm1EuWJFiQ=",
+    "axe.min.js": "sha256-uUSPcE2E0gEuXZYQaEoMQAn1Q34H7JSfjUzDwvVaB8A="
+  },
+  "4.2.3": {
+    "axe.js": "sha256-YpHE4EYgzaX6R5zc08TtcjCwyDoQf2Dczv+W2vhkdEg=",
+    "axe.min.js": "sha256-7kmyHEX64EqrQmlKiBetbDbidBg++T1OK7pJ0Ch0tVE="
+  },
+  "4.2.4": {
+    "axe.js": "sha256-5COa2/D9CE8AshTHVGhvT0A1FZXaTZy+Kh0x177VAww=",
+    "axe.min.js": "sha256-rsECe0URvW9YH4nley2GHQLI7bC9Ucan8zY9AaZdyrY="
+  },
+  "4.3.0": {
+    "axe.js": "sha256-V36WfTm/iDPLDQHIKkUfj1lPRPloIKZxS+7syZp7gzw=",
+    "axe.min.js": "sha256-zG5ql3CjWawSvMuVGJI9C8OvXR5MZAXK1IhBt83psrA="
+  },
+  "4.3.1": {
+    "axe.js": "sha256-59tFDkuadP3UQaLuRg51nCnT6M22O3+I1lBIuiTer8U=",
+    "axe.min.js": "sha256-QJtI5W/X35A3qw39uNE/Ho4iei3arUL4zrWillwv2oA="
+  },
+  "4.3.2": {
+    "axe.js": "sha256-q0wpLH5m3+m2qIpuhiAfNx2BMxC6E8O5BLBQ52P6AvM=",
+    "axe.min.js": "sha256-eGWJWadXBOoWLwGBXmtbrpqclaIxMoIRVIN9mJ5/idw="
+  },
+  "4.3.3": {
+    "axe.js": "sha256-Zvxy3UIxivqa1hGYQez9LNFxm6JBX826VrkGlH4x6hk=",
+    "axe.min.js": "sha256-KqKNp9dAHi8QV4BZv/lB28ZJt3ROsN8Y7vVRbxewSJ8="
+  },
+  "4.3.4": {
+    "axe.js": "sha256-C62RaRaF4cx65nFcFNMq5qhRPs0K3syB/x32hxSnDFM=",
+    "axe.min.js": "sha256-Qw1EkY/ShOt08vZ7tZXSskZI3bQ6HGw9t9F6Rq05MAo="
+  },
+  "4.3.5": {
+    "axe.js": "sha256-pBzsgJIL4mZHcw50O3sj5f1ZYkMYLG659lHq6Qrkuzc=",
+    "axe.min.js": "sha256-PVZfyAKgcOWwy7tmB01H7BVjKLjtFW5QO94AIXxWkcw="
+  },
+  "4.4.0": {
+    "axe.js": "sha256-gXqUZOaNO3O6o8WlFgwgeyPBiVS+CKGohTW7gC1vreE=",
+    "axe.min.js": "sha256-0+zQT47ZDlw7BjxlDClFCx2/NA0XcRmpXSn33IL/ua4="
+  },
+  "4.4.1": {
+    "axe.js": "sha256-3JaN+ADNfrGA15wszgRmfF5HiotL+1zjZznNmgzCYj4=",
+    "axe.min.js": "sha256-hGavf/+WwgIndgE1q4LjwtSlyHJjEdkQq1iilUUafC8="
+  },
+  "4.4.2": {
+    "axe.js": "sha256-s3Ip/Rm7jkD6tDMBfUvDdj1Okyjm+wMBKf60/39jaug=",
+    "axe.min.js": "sha256-LPnPAiGlol21Bn7pq9yM1TkCvztX37pp59UhYeSwShM="
+  },
+  "4.4.3": {
+    "axe.js": "sha256-R+pmfA40BsLNJsCD6FrO4KRXoV2mV3NKNUZuxFSJk6g=",
+    "axe.min.js": "sha256-aX6mx+3/D+KJt7vs8f97kBUkm8g0tAmjSM0GDfgK66A="
+  },
+  "4.5.0": {
+    "axe.js": "sha256-AYLBIQscniY92RkIlsESUAIu3cOplhUmJ3Y4/DKR4SE=",
+    "axe.min.js": "sha256-cdG6H1F9kSiSIpyWgjGYXkbV3mcfc6/SvE7Zbq2km/A="
+  },
+  "4.5.1": {
+    "axe.js": "sha256-IkK+029qUdULyO88zkDU2TeO5kQB8AjncJvjmFKqBHQ=",
+    "axe.min.js": "sha256-Ost3Bp9ymk0FCZFL9pOU2g/ph8u06GuVCm8go6W+THw="
+  },
+  "4.5.2": {
+    "axe.js": "sha256-GY6QNA/wTZYR80KdSFkH5BevH8QfsZGGbJ9qFzCkneY=",
+    "axe.min.js": "sha256-4Jw5rCVL57KrRYPfrx9AC87f3txwWIpgTM5n/LbSPTQ="
+  },
+  "4.6.0": {
+    "axe.js": "sha256-THkPfmokl4bJu3OupcpOt0ndrVCtSuKHPAbmah9KOfI=",
+    "axe.min.js": "sha256-14jwyUq9PSLhUTnee2RUaKm1i5z93fVEhUTgPCLzGO0="
+  },
+  "4.6.1": {
+    "axe.js": "sha256-5YoRtLPmXJjZaeVXOVTTPf6DtevHdYBfD4oxaCBDCXw=",
+    "axe.min.js": "sha256-8CV1yJR7ZBS/j8HkUf1OwOEib+WUH+QovSg8xOh9MVI="
+  },
+  "4.6.2": {
+    "axe.js": "sha256-6BCLF6TcLdHG7Ok3yyV7HOKF/Se1yJQgzgAiz3AnzX0=",
+    "axe.min.js": "sha256-US+MWxPC7r+aFzKfSCl+effrzN0Qoz4tS2wxlIpmsCM="
+  },
+  "4.6.3": {
+    "axe.js": "sha256-N8N7PwDRFNyzsL80UoXAE5ibkfu/KJ71Ixw0zWYX+yM=",
+    "axe.min.js": "sha256-vOhlk9sgryrpUZOv6801a9uYhuG6Z/NBJmOJb0aAQQQ="
+  },
+  "4.7.0": {
+    "axe.js": "sha256-JxLtVRh3EvdwPhr6ipXNnoN2ugUYvpwIAx4usr5jKcU=",
+    "axe.min.js": "sha256-q5YvHv5paIlrWyys5xKDb79XtmXYpiAHFVZcg61Qick="
+  },
+  "4.7.1": {
+    "axe.js": "sha256-1ruJfhOP+fO+uuQiIs1U9P4ILYOxnFc5MCH7LzaH+Lc=",
+    "axe.min.js": "sha256-ReDVBpTYnDCOjYC3eTfhCwsWtAcleTtuoekVW8eoU38="
+  },
+  "4.7.2": {
+    "axe.js": "sha256-EE+7F84cDAG4yvmWb/Cbb3WmQaNAGj4FwU4cKxJZqjg=",
+    "axe.min.js": "sha256-VTWaX4yE65/ofnyeohwMLLKvU1GEYDoWOCbKlcqFMs8="
+  },
+  "4.8.0": {
+    "axe.js": "sha256-Rd1U88z7mahhAvxYhchoCfwWxV8R/H+BcSoX6XTQ0gY=",
+    "axe.min.js": "sha256-1oZiCfWnUt2rwqLWzpkoxlcEaOH53/QFYke0jo+KecA="
+  },
+  "4.8.1": {
+    "axe.js": "sha256-xAiDRfIT8BFIcORsehvJYCROe4K+U0Ak5MVJMaCvn9k=",
+    "axe.min.js": "sha256-EkEySwRAuCQljOYWJ29XQp4s80KPPlsmKwFtKFn6Vr0="
+  },
+  "4.8.2": {
+    "axe.js": "sha256-VZuuruUDDRwfzCo4ZDDzXiVefuy4pSW6BlGx+D/ucC0=",
+    "axe.min.js": "sha256-O9U055OcfxyKV61g3Qn7N9mvpJNht0RCPcFw+QjWTG4="
+  },
+  "4.8.3": {
+    "axe.js": "sha256-YWpAAdIo7fwKmLq8nJx1f6pwt7HAXwWm15RSGJKbxhw=",
+    "axe.min.js": "sha256-/mct+I/4SJnZ30Ce+j9T7ll9zPwzbJVrjdKpbKIP+NA="
+  },
+  "4.8.4": {
+    "axe.js": "sha256-RRn+EjX3fX893zHeLzMQebvK4/HR3yZpVFNxsV3Pbm0=",
+    "axe.min.js": "sha256-HXl1GEx0+LwVB27fLmwgdXCmeTM2beVwwFosWvFzLmo="
+  },
+  "4.9.0": {
+    "axe.js": "sha256-76H9rp5bFFzCQrHiNlIEZniM30DftZzZ5pUJd/ZG4Qg=",
+    "axe.min.js": "sha256-leYBst5Y3dlncZ2YVBpe5s//BhrMC7XbK9yhUCAyPNA="
+  },
+  "4.9.1": {
+    "axe.js": "sha256-t7u8FiO2U54AN0dyGu2hAMcYdgpuXEkM6n+Eup6lMyQ=",
+    "axe.min.js": "sha256-GCpA3F2CB+YmwJhhrWUCfUXoXjpW0BBF0Gji6I7kMuo="
+  },
+  "4.10.0": {
+    "axe.js": "sha256-n/KN+TQhojZXnh49uUEY3/Df5WszWcCEothu0P58qDY=",
+    "axe.min.js": "sha256-SDpP7Usv5Wz9lKWFZQIMhjmD+EFeKCfzSB3ONecO/7U="
+  }
+}