init source

node_modules/eslint-plugin-jsx-a11y/lib/util/attributes/ISO.json

@@ -0,0 +1,390 @@
+{
+  "countries": [
+    "AF",
+    "AL",
+    "DZ",
+    "AS",
+    "AD",
+    "AO",
+    "AI",
+    "AQ",
+    "AG",
+    "AR",
+    "AM",
+    "AW",
+    "AU",
+    "AT",
+    "AZ",
+    "BS",
+    "BH",
+    "BD",
+    "BB",
+    "BY",
+    "BE",
+    "BZ",
+    "BJ",
+    "BM",
+    "BT",
+    "BO",
+    "BA",
+    "BW",
+    "BR",
+    "IO",
+    "VG",
+    "BN",
+    "BG",
+    "BF",
+    "MM",
+    "BI",
+    "KH",
+    "CM",
+    "CA",
+    "CV",
+    "KY",
+    "CF",
+    "TD",
+    "CL",
+    "CN",
+    "CX",
+    "CC",
+    "CO",
+    "KM",
+    "CK",
+    "CR",
+    "HR",
+    "CU",
+    "CY",
+    "CZ",
+    "CD",
+    "DK",
+    "DJ",
+    "DM",
+    "DO",
+    "EC",
+    "EG",
+    "SV",
+    "GQ",
+    "ER",
+    "EE",
+    "ET",
+    "FK",
+    "FO",
+    "FJ",
+    "FI",
+    "FR",
+    "PF",
+    "GA",
+    "GM",
+    "GE",
+    "DE",
+    "GH",
+    "GI",
+    "GR",
+    "GL",
+    "GD",
+    "GU",
+    "GT",
+    "GN",
+    "GW",
+    "GY",
+    "HT",
+    "VA",
+    "HN",
+    "HK",
+    "HU",
+    "IS",
+    "IN",
+    "ID",
+    "IR",
+    "IQ",
+    "IE",
+    "IM",
+    "IL",
+    "IT",
+    "CI",
+    "JM",
+    "JP",
+    "JE",
+    "JO",
+    "KZ",
+    "KE",
+    "KI",
+    "KW",
+    "KG",
+    "LA",
+    "LV",
+    "LB",
+    "LS",
+    "LR",
+    "LY",
+    "LI",
+    "LT",
+    "LU",
+    "MO",
+    "MK",
+    "MG",
+    "MW",
+    "MY",
+    "MV",
+    "ML",
+    "MT",
+    "MH",
+    "MR",
+    "MU",
+    "YT",
+    "MX",
+    "FM",
+    "MD",
+    "MC",
+    "MN",
+    "ME",
+    "MS",
+    "MA",
+    "MZ",
+    "NA",
+    "NR",
+    "NP",
+    "NL",
+    "AN",
+    "NC",
+    "NZ",
+    "NI",
+    "NE",
+    "NG",
+    "NU",
+    "KP",
+    "MP",
+    "NO",
+    "OM",
+    "PK",
+    "PW",
+    "PA",
+    "PG",
+    "PY",
+    "PE",
+    "PH",
+    "PN",
+    "PL",
+    "PT",
+    "PR",
+    "QA",
+    "CG",
+    "RO",
+    "RU",
+    "RW",
+    "BL",
+    "SH",
+    "KN",
+    "LC",
+    "MF",
+    "PM",
+    "VC",
+    "WS",
+    "SM",
+    "ST",
+    "SA",
+    "SN",
+    "RS",
+    "SC",
+    "SL",
+    "SG",
+    "SK",
+    "SI",
+    "SB",
+    "SO",
+    "ZA",
+    "KR",
+    "ES",
+    "LK",
+    "SD",
+    "SR",
+    "SJ",
+    "SZ",
+    "SE",
+    "CH",
+    "SY",
+    "TW",
+    "TJ",
+    "TZ",
+    "TH",
+    "TL",
+    "TG",
+    "TK",
+    "TO",
+    "TT",
+    "TN",
+    "TR",
+    "TM",
+    "TC",
+    "TV",
+    "UG",
+    "UA",
+    "AE",
+    "GB",
+    "US",
+    "UY",
+    "VI",
+    "UZ",
+    "VU",
+    "VE",
+    "VN",
+    "WF",
+    "EH",
+    "YE",
+    "ZM",
+    "ZW"
+  ],
+
+  "languages": [
+    "ab",
+    "aa",
+    "af",
+    "sq",
+    "am",
+    "ar",
+    "an",
+    "hy",
+    "as",
+    "ay",
+    "az",
+    "ba",
+    "eu",
+    "bn",
+    "dz",
+    "bh",
+    "bi",
+    "br",
+    "bg",
+    "my",
+    "be",
+    "km",
+    "ca",
+    "zh",
+    "zh-Hans",
+    "zh-Hant",
+    "co",
+    "hr",
+    "cs",
+    "da",
+    "nl",
+    "en",
+    "eo",
+    "et",
+    "fo",
+    "fa",
+    "fj",
+    "fi",
+    "fr",
+    "fy",
+    "gl",
+    "gd",
+    "gv",
+    "ka",
+    "de",
+    "el",
+    "kl",
+    "gn",
+    "gu",
+    "ht",
+    "ha",
+    "he",
+    "iw",
+    "hi",
+    "hu",
+    "is",
+    "io",
+    "id",
+    "in",
+    "ia",
+    "ie",
+    "iu",
+    "ik",
+    "ga",
+    "it",
+    "ja",
+    "jv",
+    "kn",
+    "ks",
+    "kk",
+    "rw",
+    "ky",
+    "rn",
+    "ko",
+    "ku",
+    "lo",
+    "la",
+    "lv",
+    "li",
+    "ln",
+    "lt",
+    "mk",
+    "mg",
+    "ms",
+    "ml",
+    "mt",
+    "mi",
+    "mr",
+    "mo",
+    "mn",
+    "na",
+    "ne",
+    "no",
+    "oc",
+    "or",
+    "om",
+    "ps",
+    "pl",
+    "pt",
+    "pa",
+    "qu",
+    "rm",
+    "ro",
+    "ru",
+    "sm",
+    "sg",
+    "sa",
+    "sr",
+    "sh",
+    "st",
+    "tn",
+    "sn",
+    "ii",
+    "sd",
+    "si",
+    "ss",
+    "sk",
+    "sl",
+    "so",
+    "es",
+    "su",
+    "sw",
+    "sv",
+    "tl",
+    "tg",
+    "ta",
+    "tt",
+    "te",
+    "th",
+    "bo",
+    "ti",
+    "to",
+    "ts",
+    "tr",
+    "tk",
+    "tw",
+    "ug",
+    "uk",
+    "ur",
+    "uz",
+    "vi",
+    "vo",
+    "wa",
+    "cy",
+    "wo",
+    "xh",
+    "yi",
+    "ji",
+    "yo",
+    "zu"
+  ]
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/attributesComparator.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns true if all items in baseAttributes are found in attributes. Always
+ * returns true if baseAttributes is empty.
+ */
+function attributesComparator() {
+  var baseAttributes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return baseAttributes.every(function (baseAttr) {
+    return attributes.some(function (attribute) {
+      // Guard against non-JSXAttribute nodes like JSXSpreadAttribute
+      if (attribute.type !== 'JSXAttribute') {
+        return false;
+      } // Attribute matches.
+
+
+      if (baseAttr.name !== (0, _jsxAstUtils.propName)(attribute)) {
+        return false;
+      } // Value exists and does not match.
+
+
+      if (baseAttr.value && baseAttr.value !== (0, _jsxAstUtils.getLiteralPropValue)(attribute)) {
+        return false;
+      }
+
+      return true;
+    });
+  });
+}
+
+var _default = attributesComparator;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/getComputedRole.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getComputedRole;
+
+var _getExplicitRole = _interopRequireDefault(require("./getExplicitRole"));
+
+var _getImplicitRole = _interopRequireDefault(require("./getImplicitRole"));
+
+/**
+ * Returns an element's computed role, which is
+ *
+ *  1. The valid value of its explicit role attribute; or
+ *  2. The implicit value of its tag.
+ */
+function getComputedRole(tag, attributes) {
+  return (0, _getExplicitRole["default"])(tag, attributes) || (0, _getImplicitRole["default"])(tag, attributes);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/getExplicitRole.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getExplicitRole;
+
+var _ariaQuery = require("aria-query");
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns an element's computed role, which is
+ *
+ *  1. The valid value of its explicit role attribute; or
+ *  2. The implicit value of its tag.
+ */
+function getExplicitRole(tag, attributes) {
+  var explicitRole = function toLowerCase(role) {
+    if (typeof role === 'string') {
+      return role.toLowerCase();
+    }
+
+    return null;
+  }((0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role')));
+
+  if (_ariaQuery.roles.has(explicitRole)) {
+    return explicitRole;
+  }
+
+  return null;
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/getImplicitRole.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRole;
+
+var _ariaQuery = require("aria-query");
+
+var _implicitRoles = _interopRequireDefault(require("./implicitRoles"));
+
+/**
+ * Returns an element's implicit role given its attributes and type.
+ * Some elements only have an implicit role when certain props are defined.
+ */
+function getImplicitRole(type, attributes) {
+  var implicitRole;
+
+  if (_implicitRoles["default"][type]) {
+    implicitRole = _implicitRoles["default"][type](attributes);
+  }
+
+  if (_ariaQuery.roles.has(implicitRole)) {
+    return implicitRole;
+  }
+
+  return null;
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/getSuggestion.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getSuggestion;
+
+var _damerauLevenshtein = _interopRequireDefault(require("damerau-levenshtein"));
+
+// Minimum edit distance to be considered a good suggestion.
+var THRESHOLD = 2;
+/**
+ * Returns an array of suggestions given a word and a dictionary and limit of suggestions
+ * to return.
+ */
+
+function getSuggestion(word) {
+  var dictionary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+  var distances = dictionary.reduce(function (suggestions, dictionaryWord) {
+    var distance = (0, _damerauLevenshtein["default"])(word.toUpperCase(), dictionaryWord.toUpperCase());
+    var steps = distance.steps;
+    suggestions[dictionaryWord] = steps; // eslint-disable-line
+
+    return suggestions;
+  }, {});
+  return Object.keys(distances).filter(function (suggestion) {
+    return distances[suggestion] <= THRESHOLD;
+  }).sort(function (a, b) {
+    return distances[a] - distances[b];
+  }) // Sort by distance
+  .slice(0, limit);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/getTabIndex.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getTabIndex;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the tabIndex value.
+ */
+function getTabIndex(tabIndex) {
+  var literalValue = (0, _jsxAstUtils.getLiteralPropValue)(tabIndex); // String and number values.
+
+  if (['string', 'number'].indexOf(typeof literalValue) > -1) {
+    // Empty string will convert to zero, so check for it explicity.
+    if (typeof literalValue === 'string' && literalValue.length === 0) {
+      return undefined;
+    }
+
+    var value = Number(literalValue);
+
+    if (Number.isNaN(value)) {
+      return undefined;
+    }
+
+    return Number.isInteger(value) ? value : undefined;
+  } // Booleans are not valid values, return undefined.
+
+
+  if (literalValue === true || literalValue === false) {
+    return undefined;
+  }
+
+  return (0, _jsxAstUtils.getPropValue)(tabIndex);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/hasAccessibleChild.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = hasAccessibleChild;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var _isHiddenFromScreenReader = _interopRequireDefault(require("./isHiddenFromScreenReader"));
+
+function hasAccessibleChild(node) {
+  return node.children.some(function (child) {
+    switch (child.type) {
+      case 'Literal':
+      case 'JSXText':
+        return Boolean(child.value);
+
+      case 'JSXElement':
+        return !(0, _isHiddenFromScreenReader["default"])((0, _jsxAstUtils.elementType)(child.openingElement), child.openingElement.attributes);
+
+      case 'JSXExpressionContainer':
+        if (child.expression.type === 'Identifier') {
+          return child.expression.name !== 'undefined';
+        }
+
+        return true;
+
+      default:
+        return false;
+    }
+  }) || (0, _jsxAstUtils.hasAnyProp)(node.openingElement.attributes, ['dangerouslySetInnerHTML', 'children']);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/a.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForAnchor;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for an anchor tag.
+ */
+function getImplicitRoleForAnchor(attributes) {
+  if ((0, _jsxAstUtils.getProp)(attributes, 'href')) {
+    return 'link';
+  }
+
+  return '';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/area.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForArea;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for an area tag.
+ */
+function getImplicitRoleForArea(attributes) {
+  if ((0, _jsxAstUtils.getProp)(attributes, 'href')) {
+    return 'link';
+  }
+
+  return '';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/article.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForArticle;
+
+/**
+ * Returns the implicit role for an article tag.
+ */
+function getImplicitRoleForArticle() {
+  return 'article';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/aside.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForAside;
+
+/**
+ * Returns the implicit role for an aside tag.
+ */
+function getImplicitRoleForAside() {
+  return 'complementary';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/body.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForBody;
+
+/**
+ * Returns the implicit role for a body tag.
+ */
+function getImplicitRoleForBody() {
+  return 'document';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/button.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForButton;
+
+/**
+ * Returns the implicit role for a button tag.
+ */
+function getImplicitRoleForButton() {
+  return 'button';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/datalist.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForDatalist;
+
+/**
+ * Returns the implicit role for a datalist tag.
+ */
+function getImplicitRoleForDatalist() {
+  return 'listbox';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/details.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForDetails;
+
+/**
+ * Returns the implicit role for a details tag.
+ */
+function getImplicitRoleForDetails() {
+  return 'group';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/dialog.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForDialog;
+
+/**
+ * Returns the implicit role for a dialog tag.
+ */
+function getImplicitRoleForDialog() {
+  return 'dialog';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/dl.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForDl;
+
+/**
+ * Returns the implicit role for a dl tag.
+ */
+function getImplicitRoleForDl() {
+  return 'list';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/form.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForForm;
+
+/**
+ * Returns the implicit role for a form tag.
+ */
+function getImplicitRoleForForm() {
+  return 'form';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h1.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH1;
+
+/**
+ * Returns the implicit role for an h1 tag.
+ */
+function getImplicitRoleForH1() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h2.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH2;
+
+/**
+ * Returns the implicit role for an h2 tag.
+ */
+function getImplicitRoleForH2() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h3.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH3;
+
+/**
+ * Returns the implicit role for an h3 tag.
+ */
+function getImplicitRoleForH3() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h4.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH4;
+
+/**
+ * Returns the implicit role for an h4 tag.
+ */
+function getImplicitRoleForH4() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h5.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH5;
+
+/**
+ * Returns the implicit role for an h5 tag.
+ */
+function getImplicitRoleForH5() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/h6.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForH6;
+
+/**
+ * Returns the implicit role for an h6tag.
+ */
+function getImplicitRoleForH6() {
+  return 'heading';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/hr.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForHr;
+
+/**
+ * Returns the implicit role for an hr tag.
+ */
+function getImplicitRoleForHr() {
+  return 'separator';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/img.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForImg;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for an img tag.
+ */
+function getImplicitRoleForImg(attributes) {
+  var alt = (0, _jsxAstUtils.getProp)(attributes, 'alt');
+
+  if (alt && (0, _jsxAstUtils.getLiteralPropValue)(alt) === '') {
+    return '';
+  }
+
+  return 'img';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/index.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _a = _interopRequireDefault(require("./a"));
+
+var _area = _interopRequireDefault(require("./area"));
+
+var _article = _interopRequireDefault(require("./article"));
+
+var _aside = _interopRequireDefault(require("./aside"));
+
+var _body = _interopRequireDefault(require("./body"));
+
+var _button = _interopRequireDefault(require("./button"));
+
+var _datalist = _interopRequireDefault(require("./datalist"));
+
+var _details = _interopRequireDefault(require("./details"));
+
+var _dialog = _interopRequireDefault(require("./dialog"));
+
+var _dl = _interopRequireDefault(require("./dl"));
+
+var _form = _interopRequireDefault(require("./form"));
+
+var _h = _interopRequireDefault(require("./h1"));
+
+var _h2 = _interopRequireDefault(require("./h2"));
+
+var _h3 = _interopRequireDefault(require("./h3"));
+
+var _h4 = _interopRequireDefault(require("./h4"));
+
+var _h5 = _interopRequireDefault(require("./h5"));
+
+var _h6 = _interopRequireDefault(require("./h6"));
+
+var _hr = _interopRequireDefault(require("./hr"));
+
+var _img = _interopRequireDefault(require("./img"));
+
+var _input = _interopRequireDefault(require("./input"));
+
+var _li = _interopRequireDefault(require("./li"));
+
+var _link = _interopRequireDefault(require("./link"));
+
+var _menu = _interopRequireDefault(require("./menu"));
+
+var _menuitem = _interopRequireDefault(require("./menuitem"));
+
+var _meter = _interopRequireDefault(require("./meter"));
+
+var _nav = _interopRequireDefault(require("./nav"));
+
+var _ol = _interopRequireDefault(require("./ol"));
+
+var _option = _interopRequireDefault(require("./option"));
+
+var _output = _interopRequireDefault(require("./output"));
+
+var _progress = _interopRequireDefault(require("./progress"));
+
+var _section = _interopRequireDefault(require("./section"));
+
+var _select = _interopRequireDefault(require("./select"));
+
+var _tbody = _interopRequireDefault(require("./tbody"));
+
+var _textarea = _interopRequireDefault(require("./textarea"));
+
+var _tfoot = _interopRequireDefault(require("./tfoot"));
+
+var _thead = _interopRequireDefault(require("./thead"));
+
+var _ul = _interopRequireDefault(require("./ul"));
+
+var _default = {
+  a: _a["default"],
+  area: _area["default"],
+  article: _article["default"],
+  aside: _aside["default"],
+  body: _body["default"],
+  button: _button["default"],
+  datalist: _datalist["default"],
+  details: _details["default"],
+  dialog: _dialog["default"],
+  dl: _dl["default"],
+  form: _form["default"],
+  h1: _h["default"],
+  h2: _h2["default"],
+  h3: _h3["default"],
+  h4: _h4["default"],
+  h5: _h5["default"],
+  h6: _h6["default"],
+  hr: _hr["default"],
+  img: _img["default"],
+  input: _input["default"],
+  li: _li["default"],
+  link: _link["default"],
+  menu: _menu["default"],
+  menuitem: _menuitem["default"],
+  meter: _meter["default"],
+  nav: _nav["default"],
+  ol: _ol["default"],
+  option: _option["default"],
+  output: _output["default"],
+  progress: _progress["default"],
+  section: _section["default"],
+  select: _select["default"],
+  tbody: _tbody["default"],
+  textarea: _textarea["default"],
+  tfoot: _tfoot["default"],
+  thead: _thead["default"],
+  ul: _ul["default"]
+};
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/input.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForInput;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for an input tag.
+ */
+function getImplicitRoleForInput(attributes) {
+  var type = (0, _jsxAstUtils.getProp)(attributes, 'type');
+
+  if (type) {
+    var value = (0, _jsxAstUtils.getLiteralPropValue)(type) || '';
+
+    switch (typeof value === 'string' && value.toUpperCase()) {
+      case 'BUTTON':
+      case 'IMAGE':
+      case 'RESET':
+      case 'SUBMIT':
+        return 'button';
+
+      case 'CHECKBOX':
+        return 'checkbox';
+
+      case 'RADIO':
+        return 'radio';
+
+      case 'RANGE':
+        return 'slider';
+
+      case 'EMAIL':
+      case 'PASSWORD':
+      case 'SEARCH': // with [list] selector it's combobox
+
+      case 'TEL': // with [list] selector it's combobox
+
+      case 'URL': // with [list] selector it's combobox
+
+      default:
+        return 'textbox';
+    }
+  }
+
+  return 'textbox';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/li.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForLi;
+
+/**
+ * Returns the implicit role for an li tag.
+ */
+function getImplicitRoleForLi() {
+  return 'listitem';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/link.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForLink;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for a link tag.
+ */
+function getImplicitRoleForLink(attributes) {
+  if ((0, _jsxAstUtils.getProp)(attributes, 'href')) {
+    return 'link';
+  }
+
+  return '';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/menu.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForMenu;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for a menu tag.
+ */
+function getImplicitRoleForMenu(attributes) {
+  var type = (0, _jsxAstUtils.getProp)(attributes, 'type');
+
+  if (type) {
+    var value = (0, _jsxAstUtils.getLiteralPropValue)(type);
+    return value && value.toUpperCase() === 'TOOLBAR' ? 'toolbar' : '';
+  }
+
+  return '';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/menuitem.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForMenuitem;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns the implicit role for a menuitem tag.
+ */
+function getImplicitRoleForMenuitem(attributes) {
+  var type = (0, _jsxAstUtils.getProp)(attributes, 'type');
+
+  if (type) {
+    var value = (0, _jsxAstUtils.getLiteralPropValue)(type) || '';
+
+    switch (typeof value === 'string' && value.toUpperCase()) {
+      case 'COMMAND':
+        return 'menuitem';
+
+      case 'CHECKBOX':
+        return 'menuitemcheckbox';
+
+      case 'RADIO':
+        return 'menuitemradio';
+
+      default:
+        return '';
+    }
+  }
+
+  return '';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/meter.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForMeter;
+
+/**
+ * Returns the implicit role for a meter tag.
+ */
+function getImplicitRoleForMeter() {
+  return 'progressbar';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/nav.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForNav;
+
+/**
+ * Returns the implicit role for a nav tag.
+ */
+function getImplicitRoleForNav() {
+  return 'navigation';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/ol.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForOl;
+
+/**
+ * Returns the implicit role for an ol tag.
+ */
+function getImplicitRoleForOl() {
+  return 'list';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/option.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForOption;
+
+/**
+ * Returns the implicit role for an option tag.
+ */
+function getImplicitRoleForOption() {
+  return 'option';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/output.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForOutput;
+
+/**
+ * Returns the implicit role for an output tag.
+ */
+function getImplicitRoleForOutput() {
+  return 'status';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/progress.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForProgress;
+
+/**
+ * Returns the implicit role for a progress tag.
+ */
+function getImplicitRoleForProgress() {
+  return 'progressbar';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/section.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForSection;
+
+/**
+ * Returns the implicit role for a section tag.
+ */
+function getImplicitRoleForSection() {
+  return 'region';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/select.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForSelect;
+
+/**
+ * Returns the implicit role for a select tag.
+ */
+function getImplicitRoleForSelect() {
+  return 'listbox';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/tbody.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForTbody;
+
+/**
+ * Returns the implicit role for a tbody tag.
+ */
+function getImplicitRoleForTbody() {
+  return 'rowgroup';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/textarea.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForTextarea;
+
+/**
+ * Returns the implicit role for a textarea tag.
+ */
+function getImplicitRoleForTextarea() {
+  return 'textbox';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/tfoot.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForTfoot;
+
+/**
+ * Returns the implicit role for a tfoot tag.
+ */
+function getImplicitRoleForTfoot() {
+  return 'rowgroup';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/thead.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForThead;
+
+/**
+ * Returns the implicit role for a thead tag.
+ */
+function getImplicitRoleForThead() {
+  return 'rowgroup';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/implicitRoles/ul.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getImplicitRoleForUl;
+
+/**
+ * Returns the implicit role for a ul tag.
+ */
+function getImplicitRoleForUl() {
+  return 'list';
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/isAbstractRole.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var abstractRoles = new Set((0, _toConsumableArray2["default"])(_ariaQuery.roles.keys()).filter(function (role) {
+  return _ariaQuery.roles.get(role)["abstract"];
+}));
+var DOMElements = (0, _toConsumableArray2["default"])(_ariaQuery.dom.keys());
+
+var isAbstractRole = function isAbstractRole(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (DOMElements.indexOf(tagName) === -1) {
+    return false;
+  }
+
+  var role = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role'));
+  return abstractRoles.has(role);
+};
+
+var _default = isAbstractRole;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isDOMElement.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var domElements = (0, _toConsumableArray2["default"])(_ariaQuery.dom.keys());
+/**
+ * Returns boolean indicating whether the given element is a DOM element.
+ */
+
+var isDOMElement = function isDOMElement(tagName) {
+  return (0, _arrayIncludes["default"])(domElements, tagName);
+};
+
+var _default = isDOMElement;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isDisabledElement.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var isDisabledElement = function isDisabledElement(attributes) {
+  var disabledAttr = (0, _jsxAstUtils.getProp)(attributes, 'disabled');
+  var disabledAttrValue = (0, _jsxAstUtils.getPropValue)(disabledAttr);
+  var isHTML5Disabled = disabledAttr && disabledAttrValue !== undefined;
+
+  if (isHTML5Disabled) {
+    return true;
+  }
+
+  var ariaDisabledAttr = (0, _jsxAstUtils.getProp)(attributes, 'aria-disabled');
+  var ariaDisabledAttrValue = (0, _jsxAstUtils.getLiteralPropValue)(ariaDisabledAttr);
+
+  if (ariaDisabledAttr && ariaDisabledAttrValue !== undefined && ariaDisabledAttrValue === true) {
+    return true;
+  }
+
+  return false;
+};
+
+var _default = isDisabledElement;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isHiddenFromScreenReader.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns boolean indicating that the aria-hidden prop
+ * is present or the value is true. Will also return true if
+ * there is an input with type='hidden'.
+ *
+ * <div aria-hidden /> is equivalent to the DOM as <div aria-hidden=true />.
+ */
+var isHiddenFromScreenReader = function isHiddenFromScreenReader(type, attributes) {
+  if (type.toUpperCase() === 'INPUT') {
+    var hidden = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'type'));
+
+    if (hidden && hidden.toUpperCase() === 'HIDDEN') {
+      return true;
+    }
+  }
+
+  var ariaHidden = (0, _jsxAstUtils.getPropValue)((0, _jsxAstUtils.getProp)(attributes, 'aria-hidden'));
+  return ariaHidden === true;
+};
+
+var _default = isHiddenFromScreenReader;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isInteractiveElement.js

@@ -0,0 +1,133 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _axobjectQuery = require("axobject-query");
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var _attributesComparator = _interopRequireDefault(require("./attributesComparator"));
+
+var domKeys = (0, _toConsumableArray2["default"])(_ariaQuery.dom.keys());
+var roleKeys = (0, _toConsumableArray2["default"])(_ariaQuery.roles.keys());
+var elementRoleEntries = (0, _toConsumableArray2["default"])(_ariaQuery.elementRoles);
+var nonInteractiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+
+  return !role["abstract"] && !role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}));
+var interactiveRoles = new Set([].concat(roleKeys, // 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+'toolbar').filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+
+  return !role["abstract"] && role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}));
+var nonInteractiveElementRoleSchemas = elementRoleEntries.reduce(function (accumulator, _ref) {
+  var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      elementSchema = _ref2[0],
+      roleSet = _ref2[1];
+
+  if ((0, _toConsumableArray2["default"])(roleSet).every(function (role) {
+    return nonInteractiveRoles.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+var interactiveElementRoleSchemas = elementRoleEntries.reduce(function (accumulator, _ref3) {
+  var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+      elementSchema = _ref4[0],
+      roleSet = _ref4[1];
+
+  if ((0, _toConsumableArray2["default"])(roleSet).some(function (role) {
+    return interactiveRoles.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+var interactiveAXObjects = new Set((0, _toConsumableArray2["default"])(_axobjectQuery.AXObjects.keys()).filter(function (name) {
+  return _axobjectQuery.AXObjects.get(name).type === 'widget';
+}));
+var interactiveElementAXObjectSchemas = (0, _toConsumableArray2["default"])(_axobjectQuery.elementAXObjects).reduce(function (accumulator, _ref5) {
+  var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
+      elementSchema = _ref6[0],
+      AXObjectSet = _ref6[1];
+
+  if ((0, _toConsumableArray2["default"])(AXObjectSet).every(function (role) {
+    return interactiveAXObjects.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+
+function checkIsInteractiveElement(tagName, attributes) {
+  function elementSchemaMatcher(elementSchema) {
+    return tagName === elementSchema.name && (0, _attributesComparator["default"])(elementSchema.attributes, attributes);
+  } // Check in elementRoles for inherent interactive role associations for
+  // this element.
+
+
+  var isInherentInteractiveElement = interactiveElementRoleSchemas.some(elementSchemaMatcher);
+
+  if (isInherentInteractiveElement) {
+    return true;
+  } // Check in elementRoles for inherent non-interactive role associations for
+  // this element.
+
+
+  var isInherentNonInteractiveElement = nonInteractiveElementRoleSchemas.some(elementSchemaMatcher);
+
+  if (isInherentNonInteractiveElement) {
+    return false;
+  } // Check in elementAXObjects for AX Tree associations for this element.
+
+
+  var isInteractiveAXElement = interactiveElementAXObjectSchemas.some(elementSchemaMatcher);
+
+  if (isInteractiveAXElement) {
+    return true;
+  }
+
+  return false;
+}
+/**
+ * Returns boolean indicating whether the given element is
+ * interactive on the DOM or not. Usually used when an element
+ * has a dynamic handler on it and we need to discern whether or not
+ * it's intention is to be interacted with on the DOM.
+ */
+
+
+var isInteractiveElement = function isInteractiveElement(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!(0, _arrayIncludes["default"])(domKeys, tagName)) {
+    return false;
+  }
+
+  return checkIsInteractiveElement(tagName, attributes);
+};
+
+var _default = isInteractiveElement;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isInteractiveRole.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var roles = (0, _toConsumableArray2["default"])(_ariaQuery.roles.keys());
+var interactiveRoles = roles.filter(function (name) {
+  return !_ariaQuery.roles.get(name)["abstract"];
+}).filter(function (name) {
+  return _ariaQuery.roles.get(name).superClass.some(function (klasses) {
+    return (0, _arrayIncludes["default"])(klasses, 'widget');
+  });
+}); // 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+
+interactiveRoles.push('toolbar');
+/**
+ * Returns boolean indicating whether the given element has a role
+ * that is associated with an interactive component. Used when an element
+ * has a dynamic handler on it and we need to discern whether or not
+ * its intention is to be interacted with in the DOM.
+ *
+ * isInteractiveRole is a Logical Disjunction:
+ * https://en.wikipedia.org/wiki/Logical_disjunction
+ * The JSX element does not have a tagName or it has a tagName and a role
+ * attribute with a value in the set of non-interactive roles.
+ */
+
+var isInteractiveRole = function isInteractiveRole(tagName, attributes) {
+  var value = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role')); // If value is undefined, then the role attribute will be dropped in the DOM.
+  // If value is null, then getLiteralAttributeValue is telling us that the
+  // value isn't in the form of a literal
+
+  if (value === undefined || value === null) {
+    return false;
+  }
+
+  var isInteractive = false;
+  var normalizedValues = String(value).toLowerCase().split(' ');
+  var validRoles = normalizedValues.reduce(function (accumulator, name) {
+    if ((0, _arrayIncludes["default"])(roles, name)) {
+      accumulator.push(name);
+    }
+
+    return accumulator;
+  }, []);
+
+  if (validRoles.length > 0) {
+    // The first role value is a series takes precedence.
+    isInteractive = (0, _arrayIncludes["default"])(interactiveRoles, validRoles[0]);
+  }
+
+  return isInteractive;
+};
+
+var _default = isInteractiveRole;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isNonInteractiveElement.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _axobjectQuery = require("axobject-query");
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var _attributesComparator = _interopRequireDefault(require("./attributesComparator"));
+
+var roleKeys = (0, _toConsumableArray2["default"])(_ariaQuery.roles.keys());
+var elementRoleEntries = (0, _toConsumableArray2["default"])(_ariaQuery.elementRoles);
+var nonInteractiveRoles = new Set(roleKeys.filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+
+  return !role["abstract"] && !role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}));
+var interactiveRoles = new Set([].concat(roleKeys, // 'toolbar' does not descend from widget, but it does support
+// aria-activedescendant, thus in practice we treat it as a widget.
+'toolbar').filter(function (name) {
+  var role = _ariaQuery.roles.get(name);
+
+  return !role["abstract"] && role.superClass.some(function (classes) {
+    return (0, _arrayIncludes["default"])(classes, 'widget');
+  });
+}));
+var nonInteractiveElementRoleSchemas = elementRoleEntries.reduce(function (accumulator, _ref) {
+  var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      elementSchema = _ref2[0],
+      roleSet = _ref2[1];
+
+  if ((0, _toConsumableArray2["default"])(roleSet).every(function (role) {
+    return nonInteractiveRoles.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+var interactiveElementRoleSchemas = elementRoleEntries.reduce(function (accumulator, _ref3) {
+  var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
+      elementSchema = _ref4[0],
+      roleSet = _ref4[1];
+
+  if ((0, _toConsumableArray2["default"])(roleSet).some(function (role) {
+    return interactiveRoles.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+var nonInteractiveAXObjects = new Set((0, _toConsumableArray2["default"])(_axobjectQuery.AXObjects.keys()).filter(function (name) {
+  return (0, _arrayIncludes["default"])(['window', 'structure'], _axobjectQuery.AXObjects.get(name).type);
+}));
+var nonInteractiveElementAXObjectSchemas = (0, _toConsumableArray2["default"])(_axobjectQuery.elementAXObjects).reduce(function (accumulator, _ref5) {
+  var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
+      elementSchema = _ref6[0],
+      AXObjectSet = _ref6[1];
+
+  if ((0, _toConsumableArray2["default"])(AXObjectSet).every(function (role) {
+    return nonInteractiveAXObjects.has(role);
+  })) {
+    accumulator.push(elementSchema);
+  }
+
+  return accumulator;
+}, []);
+
+function checkIsNonInteractiveElement(tagName, attributes) {
+  function elementSchemaMatcher(elementSchema) {
+    return tagName === elementSchema.name && (0, _attributesComparator["default"])(elementSchema.attributes, attributes);
+  } // Check in elementRoles for inherent non-interactive role associations for
+  // this element.
+
+
+  var isInherentNonInteractiveElement = nonInteractiveElementRoleSchemas.some(elementSchemaMatcher);
+
+  if (isInherentNonInteractiveElement) {
+    return true;
+  } // Check in elementRoles for inherent interactive role associations for
+  // this element.
+
+
+  var isInherentInteractiveElement = interactiveElementRoleSchemas.some(elementSchemaMatcher);
+
+  if (isInherentInteractiveElement) {
+    return false;
+  } // Check in elementAXObjects for AX Tree associations for this element.
+
+
+  var isNonInteractiveAXElement = nonInteractiveElementAXObjectSchemas.some(elementSchemaMatcher);
+
+  if (isNonInteractiveAXElement) {
+    return true;
+  }
+
+  return false;
+}
+/**
+ * Returns boolean indicating whether the given element is a non-interactive
+ * element. If the element has either a non-interactive role assigned or it
+ * is an element with an inherently non-interactive role, then this utility
+ * returns true. Elements that lack either an explicitly assigned role or
+ * an inherent role are not considered. For those, this utility returns false
+ * because a positive determination of interactiveness cannot be determined.
+ */
+
+
+var isNonInteractiveElement = function isNonInteractiveElement(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!_ariaQuery.dom.has(tagName)) {
+    return false;
+  }
+
+  return checkIsNonInteractiveElement(tagName, attributes);
+};
+
+var _default = isNonInteractiveElement;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isNonInteractiveRole.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _ariaQuery = require("aria-query");
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var roles = (0, _toConsumableArray2["default"])(_ariaQuery.roles.keys());
+var nonInteractiveRoles = roles.filter(function (name) {
+  return !_ariaQuery.roles.get(name)["abstract"];
+}).filter(function (name) {
+  return !_ariaQuery.roles.get(name).superClass.some(function (klasses) {
+    return (0, _arrayIncludes["default"])(klasses, 'widget');
+  });
+});
+/**
+ * Returns boolean indicating whether the given element has a role
+ * that is associated with a non-interactive component. Non-interactive roles
+ * include `listitem`, `article`, or `dialog`. These are roles that indicate
+ * for the most part containers.
+ *
+ * Elements with these roles should not respond or handle user interactions.
+ * For example, an `onClick` handler should not be assigned to an element with
+ * the role `listitem`. An element inside the `listitem`, like a button or a
+ * link, should handle the click.
+ *
+ * This utility returns true for elements that are assigned a non-interactive
+ * role. It will return false for elements that do not have a role. So whereas
+ * a `div` might be considered non-interactive, for the purpose of this utility,
+ * it is considered neither interactive nor non-interactive -- a determination
+ * cannot be made in this case and false is returned.
+ */
+
+var isNonInteractiveRole = function isNonInteractiveRole(tagName, attributes) {
+  // Do not test higher level JSX components, as we do not know what
+  // low-level DOM element this maps to.
+  if (!_ariaQuery.dom.has(tagName)) {
+    return false;
+  }
+
+  var role = (0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role'));
+  var isNonInteractive = false;
+  var normalizedValues = String(role).toLowerCase().split(' ');
+  var validRoles = normalizedValues.reduce(function (accumulator, name) {
+    if ((0, _arrayIncludes["default"])(roles, name)) {
+      accumulator.push(name);
+    }
+
+    return accumulator;
+  }, []);
+
+  if (validRoles.length > 0) {
+    // The first role value is a series takes precedence.
+    isNonInteractive = (0, _arrayIncludes["default"])(nonInteractiveRoles, validRoles[0]);
+  }
+
+  return isNonInteractive;
+};
+
+var _default = isNonInteractiveRole;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isNonLiteralProperty.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns boolean indicating whether the given element has been specified with
+ * an AST node with a non-literal type.
+ *
+ * Returns true if the elements has a role and its value is not of a type Literal.
+ * Otherwise returns false.
+ */
+var isNonLiteralProperty = function isNonLiteralProperty(attributes, propName) {
+  var prop = (0, _jsxAstUtils.getProp)(attributes, propName);
+  if (!prop) return false;
+  var propValue = prop.value;
+  if (!propValue) return false;
+  if (propValue.type === 'Literal') return false;
+
+  if (propValue.type === 'JSXExpressionContainer') {
+    var expression = propValue.expression;
+    if (expression.type === 'Identifier' && expression.name === 'undefined') return false;
+    if (expression.type === 'JSXText') return false;
+  }
+
+  return true;
+};
+
+var _default = isNonLiteralProperty;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isPresentationRole.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var presentationRoles = new Set(['presentation', 'none']);
+
+var isPresentationRole = function isPresentationRole(tagName, attributes) {
+  return presentationRoles.has((0, _jsxAstUtils.getLiteralPropValue)((0, _jsxAstUtils.getProp)(attributes, 'role')));
+};
+
+var _default = isPresentationRole;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/isSemanticRoleElement.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _axobjectQuery = require("axobject-query");
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+var isSemanticRoleElement = function isSemanticRoleElement(elementType, attributes) {
+  var roleAttr = (0, _jsxAstUtils.getProp)(attributes, 'role');
+  var res = false;
+  var roleAttrValue = (0, _jsxAstUtils.getLiteralPropValue)(roleAttr);
+
+  _axobjectQuery.elementAXObjects.forEach(function (axObjects, concept) {
+    if (res) {
+      return;
+    }
+
+    if (concept.name === elementType && (concept.attributes || []).every(function (cAttr) {
+      return attributes.some(function (attr) {
+        if (!attr.type || attr.type !== 'JSXAttribute') {
+          return false;
+        }
+
+        var namesMatch = cAttr.name === (0, _jsxAstUtils.propName)(attr);
+        var valuesMatch;
+
+        if (cAttr.value !== undefined) {
+          valuesMatch = cAttr.value === (0, _jsxAstUtils.getLiteralPropValue)(attr);
+        }
+
+        if (!namesMatch) {
+          return false;
+        }
+
+        return namesMatch && valuesMatch !== undefined ? valuesMatch : true;
+      });
+    })) {
+      axObjects.forEach(function (name) {
+        if (res) {
+          return;
+        }
+
+        var roles = _axobjectQuery.AXObjectRoles.get(name);
+
+        if (roles) {
+          roles.forEach(function (role) {
+            if (res === true) {
+              return;
+            }
+
+            if (role.name === roleAttrValue) {
+              res = true;
+            }
+          });
+        }
+      });
+    }
+  });
+
+  return res;
+};
+
+var _default = isSemanticRoleElement;
+exports["default"] = _default;

node_modules/eslint-plugin-jsx-a11y/lib/util/mayContainChildComponent.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = mayContainChildComponent;
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns true if it can positively determine that the element lacks an
+ * accessible label. If no determination is possible, it returns false. Treat
+ * false as an unknown value. The element might still have an accessible label,
+ * but this module cannot determine it positively.
+ *
+ * 
+ */
+function mayContainChildComponent(root, componentName) {
+  var maxDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+
+  function traverseChildren(node, depth) {
+    // Bail when maxDepth is exceeded.
+    if (depth > maxDepth) {
+      return false;
+    }
+
+    if (node.children) {
+      /* $FlowFixMe */
+      for (var i = 0; i < node.children.length; i += 1) {
+        /* $FlowFixMe */
+        var childNode = node.children[i]; // Assume an expression container renders a label. It is the best we can
+        // do in this case.
+
+        if (childNode.type === 'JSXExpressionContainer') {
+          return true;
+        } // Check for comonents with the provided name.
+
+
+        if (childNode.type === 'JSXElement' && childNode.openingElement && (0, _jsxAstUtils.elementType)(childNode.openingElement) === componentName) {
+          return true;
+        }
+
+        if (traverseChildren(childNode, depth + 1)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return traverseChildren(root, 1);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/mayHaveAccessibleLabel.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = mayHaveAccessibleLabel;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _arrayIncludes = _interopRequireDefault(require("array-includes"));
+
+var _jsxAstUtils = require("jsx-ast-utils");
+
+/**
+ * Returns true if a labelling element is found or if it cannot determine if
+ * a label is present because of expression containers or spread attributes.
+ * A false return value means that the node definitely does not have a label,
+ * but a true return return value means that the node may or may not have a
+ * label.
+ *
+ * 
+ */
+function hasLabellingProp(openingElement) {
+  var additionalLabellingProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var labellingProps = ['alt', // Assume alt is used correctly on an image
+  'aria-label', 'aria-labelledby'].concat((0, _toConsumableArray2["default"])(additionalLabellingProps));
+  return openingElement.attributes.some(function (attribute) {
+    // We must assume that a spread value contains a labelling prop.
+    if (attribute.type !== 'JSXAttribute') {
+      return true;
+    } // Attribute matches.
+
+
+    if ((0, _arrayIncludes["default"])(labellingProps, (0, _jsxAstUtils.propName)(attribute)) && !!(0, _jsxAstUtils.getPropValue)(attribute)) {
+      return true;
+    }
+
+    return false;
+  });
+}
+
+function mayHaveAccessibleLabel(root) {
+  var maxDepth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var additionalLabellingProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  function checkElement(node, depth) {
+    // Bail when maxDepth is exceeded.
+    if (depth > maxDepth) {
+      return false;
+    } // Check for literal text.
+
+
+    if (node.type === 'Literal' && !!node.value) {
+      return true;
+    } // Assume an expression container renders a label. It is the best we can
+    // do in this case.
+
+
+    if (node.type === 'JSXExpressionContainer') {
+      return true;
+    } // Check for JSXText.
+    // $FlowFixMe Remove after updating ast-types-flow
+
+
+    if (node.type === 'JSXText' && !!node.value) {
+      return true;
+    } // Check for labelling props.
+
+
+    if (node.openingElement
+    /* $FlowFixMe */
+    && hasLabellingProp(node.openingElement, additionalLabellingProps)) {
+      return true;
+    } // Recurse into the child element nodes.
+
+
+    if (node.children) {
+      /* $FlowFixMe */
+      for (var i = 0; i < node.children.length; i += 1) {
+        /* $FlowFixMe */
+        if (checkElement(node.children[i], depth + 1)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return checkElement(root, 0);
+}

node_modules/eslint-plugin-jsx-a11y/lib/util/schemas.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateObjSchema = exports.enumArraySchema = exports.arraySchema = void 0;
+
+/**
+ * JSON schema to accept an array of unique strings
+ */
+var arraySchema = {
+  type: 'array',
+  items: {
+    type: 'string'
+  },
+  uniqueItems: true,
+  additionalItems: false
+};
+/**
+ * JSON schema to accept an array of unique strings from an enumerated list.
+ */
+
+exports.arraySchema = arraySchema;
+
+var enumArraySchema = function enumArraySchema() {
+  var enumeratedList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var minItems = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return Object.assign({}, arraySchema, {
+    items: {
+      type: 'string',
+      "enum": enumeratedList
+    },
+    minItems
+  });
+};
+/**
+ * Factory function to generate an object schema
+ * with specified properties object
+ */
+
+
+exports.enumArraySchema = enumArraySchema;
+
+var generateObjSchema = function generateObjSchema() {
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var required = arguments.length > 1 ? arguments[1] : undefined;
+  return {
+    type: 'object',
+    properties,
+    required
+  };
+};
+
+exports.generateObjSchema = generateObjSchema;