axe-core 4.1.2-canary.ec00dc7 → 4.1.2

package/lib/commons/index.js

@@ -17,15 +17,15 @@ import * as text from './text';
 import * as utils from '../core/utils';
 
 var commons = {
-  aria,
-  color,
-  dom,
-  forms,
-  matches,
-  standards,
-  table,
-  text,
-  utils
+	aria,
+	color,
+	dom,
+	forms,
+	matches,
+	standards,
+	table,
+	text,
+	utils
 };
 
 export { aria, color, dom, forms, matches, standards, table, text, utils };

package/lib/commons/matches/attributes.js

@@ -23,10 +23,10 @@ import { getNodeFromTree } from '../../core/utils';
  * @returns {Boolean}
  */
 function attributes(vNode, matcher) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
-  return fromFunction(attrName => vNode.attr(attrName), matcher);
+	if (!(vNode instanceof AbstractVirtualNode)) {
+		vNode = getNodeFromTree(vNode);
+	}
+	return fromFunction(attrName => vNode.attr(attrName), matcher);
 }
 
 export default attributes;

package/lib/commons/matches/condition.js

@@ -14,7 +14,7 @@
  * @returns {Boolean}
  */
 function condition(arg, condition) {
-  return !!condition(arg);
+	return !!condition(arg);
 }
 
 export default condition;

package/lib/commons/matches/explicit-role.js

@@ -18,7 +18,7 @@ import getExplicitRole from '../aria/get-explicit-role';
  * @returns {Boolean}
  */
 function explicitRole(vNode, matcher) {
-  return fromPrimative(getExplicitRole(vNode), matcher);
+	return fromPrimative(getExplicitRole(vNode), matcher);
 }
 
 export default explicitRole;

package/lib/commons/matches/from-definition.js

@@ -9,13 +9,13 @@ import AbstractVirtualNode from '../../core/base/virtual-node/abstract-virtual-n
 import { getNodeFromTree, matches } from '../../core/utils';
 
 const matchers = {
-  attributes,
-  condition,
-  explicitRole,
-  implicitRole,
-  nodeName,
-  properties,
-  semanticRole
+	attributes,
+	condition,
+	explicitRole,
+	implicitRole,
+	nodeName,
+	properties,
+	semanticRole
 };
 
 /**
@@ -42,32 +42,32 @@ const matchers = {
  * @returns {Boolean}
  */
 function fromDefinition(vNode, definition) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
+	if (!(vNode instanceof AbstractVirtualNode)) {
+		vNode = getNodeFromTree(vNode);
+	}
 
-  if (Array.isArray(definition)) {
-    return definition.some(definitionItem =>
-      fromDefinition(vNode, definitionItem)
-    );
-  }
-  if (typeof definition === 'string') {
-    return matches(vNode, definition);
-  }
+	if (Array.isArray(definition)) {
+		return definition.some(definitionItem =>
+			fromDefinition(vNode, definitionItem)
+		);
+	}
+	if (typeof definition === 'string') {
+		return matches(vNode, definition);
+	}
 
-  return Object.keys(definition).every(matcherName => {
-    if (!matchers[matcherName]) {
-      throw new Error(`Unknown matcher type "${matcherName}"`);
-    }
-    // Find the specific matches method to.
-    // matches.attributes, matches.nodeName, matches.properties, etc.
-    const matchMethod = matchers[matcherName];
+	return Object.keys(definition).every(matcherName => {
+		if (!matchers[matcherName]) {
+			throw new Error(`Unknown matcher type "${matcherName}"`);
+		}
+		// Find the specific matches method to.
+		// matches.attributes, matches.nodeName, matches.properties, etc.
+		const matchMethod = matchers[matcherName];
 
-    // Find the matcher that goes into the matches method.
-    // 'div', /^div$/, (str) => str === 'div', etc.
-    const matcher = definition[matcherName];
-    return matchMethod(vNode, matcher);
-  });
+		// Find the matcher that goes into the matches method.
+		// 'div', /^div$/, (str) => str === 'div', etc.
+		const matcher = definition[matcherName];
+		return matchMethod(vNode, matcher);
+	});
 }
 
 export default fromDefinition;

package/lib/commons/matches/from-function.js

@@ -22,19 +22,19 @@ import fromPrimative from './from-primative';
  * @returns {Boolean}
  */
 function fromFunction(getValue, matcher) {
-  const matcherType = typeof matcher;
-  if (
-    matcherType !== 'object' ||
-    Array.isArray(matcher) ||
-    matcher instanceof RegExp
-  ) {
-    throw new Error('Expect matcher to be an object');
-  }
+	const matcherType = typeof matcher;
+	if (
+		matcherType !== 'object' ||
+		Array.isArray(matcher) ||
+		matcher instanceof RegExp
+	) {
+		throw new Error('Expect matcher to be an object');
+	}
 
-  // Check that the property has all the expected values
-  return Object.keys(matcher).every(propName => {
-    return fromPrimative(getValue(propName), matcher[propName]);
-  });
+	// Check that the property has all the expected values
+	return Object.keys(matcher).every(propName => {
+		return fromPrimative(getValue(propName), matcher[propName]);
+	});
 }
 
 export default fromFunction;

package/lib/commons/matches/from-primative.js

@@ -15,30 +15,30 @@
  * @returns {Boolean}
  */
 function fromPrimative(someString, matcher) {
-  const matcherType = typeof matcher;
-  if (Array.isArray(matcher) && typeof someString !== 'undefined') {
-    return matcher.includes(someString);
-  }
+	const matcherType = typeof matcher;
+	if (Array.isArray(matcher) && typeof someString !== 'undefined') {
+		return matcher.includes(someString);
+	}
 
-  if (matcherType === 'function') {
-    return !!matcher(someString);
-  }
+	if (matcherType === 'function') {
+		return !!matcher(someString);
+	}
 
-  // RegExp.test(str) typecasts the str to a String value so doing
-  // `/.*/.test(null)` returns true as null is cast to "null"
-  if (someString !== null && someString !== undefined) {
-    if (matcher instanceof RegExp) {
-      return matcher.test(someString);
-    }
+	// RegExp.test(str) typecasts the str to a String value so doing
+	// `/.*/.test(null)` returns true as null is cast to "null"
+	if (someString !== null && someString !== undefined) {
+		if (matcher instanceof RegExp) {
+			return matcher.test(someString);
+		}
 
-    // matcher starts and ends with "/"
-    if (/^\/.*\/$/.test(matcher)) {
-      const pattern = matcher.substring(1, matcher.length - 1);
-      return new RegExp(pattern).test(someString);
-    }
-  }
+		// matcher starts and ends with "/"
+		if (/^\/.*\/$/.test(matcher)) {
+			const pattern = matcher.substring(1, matcher.length - 1);
+			return new RegExp(pattern).test(someString);
+		}
+	}
 
-  return matcher === someString;
+	return matcher === someString;
 }
 
 export default fromPrimative;

package/lib/commons/matches/implicit-role.js

@@ -18,7 +18,7 @@ import getImplicitRole from '../aria/implicit-role';
  * @returns {Boolean}
  */
 function implicitRole(vNode, matcher) {
-  return fromPrimative(getImplicitRole(vNode), matcher);
+	return fromPrimative(getImplicitRole(vNode), matcher);
 }
 
 export default implicitRole;

package/lib/commons/matches/matches.js

@@ -33,7 +33,7 @@ import fromDefinition from './from-definition';
  * @return {Boolean} true/ false based on if vNode passes the constraints expected
  */
 function matches(vNode, definition) {
-  return fromDefinition(vNode, definition);
+	return fromDefinition(vNode, definition);
 }
 
 export default matches;

package/lib/commons/matches/node-name.js

@@ -20,10 +20,10 @@ import { getNodeFromTree } from '../../core/utils';
  * @returns {Boolean}
  */
 function nodeName(vNode, matcher) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
-  return fromPrimative(vNode.props.nodeName, matcher);
+	if (!(vNode instanceof AbstractVirtualNode)) {
+		vNode = getNodeFromTree(vNode);
+	}
+	return fromPrimative(vNode.props.nodeName, matcher);
 }
 
 export default nodeName;

package/lib/commons/matches/properties.js

@@ -23,10 +23,10 @@ import { getNodeFromTree } from '../../core/utils';
  * @returns {Boolean}
  */
 function properties(vNode, matcher) {
-  if (!(vNode instanceof AbstractVirtualNode)) {
-    vNode = getNodeFromTree(vNode);
-  }
-  return fromFunction(propName => vNode.props[propName], matcher);
+	if (!(vNode instanceof AbstractVirtualNode)) {
+		vNode = getNodeFromTree(vNode);
+	}
+	return fromFunction(propName => vNode.props[propName], matcher);
 }
 
 export default properties;

package/lib/commons/matches/semantic-role.js

@@ -18,7 +18,7 @@ import getRole from '../aria/get-role';
  * @returns {Boolean}
  */
 function semanticRole(vNode, matcher) {
-  return fromPrimative(getRole(vNode), matcher);
+	return fromPrimative(getRole(vNode), matcher);
 }
 
 export default semanticRole;

package/lib/commons/standards/get-aria-roles-by-type.js

@@ -6,9 +6,9 @@ import standards from '../../standards';
  * @return {String[]} List of all roles matching the type
  */
 function getAriaRolesByType(type) {
-  return Object.keys(standards.ariaRoles).filter(roleName => {
-    return standards.ariaRoles[roleName].type === type;
-  });
+	return Object.keys(standards.ariaRoles).filter(roleName => {
+		return standards.ariaRoles[roleName].type === type;
+	});
 }
 
 export default getAriaRolesByType;

package/lib/commons/standards/get-aria-roles-supporting-name-from-content.js

@@ -6,17 +6,17 @@ import standards from '../../standards';
  * @return {String[]} List of all roles with name from content
  */
 function getAriaRolesSupportingNameFromContent() {
-  if (cache.get('ariaRolesNameFromContent')) {
-    return cache.get('ariaRolesNameFromContent');
-  }
+	if (cache.get('ariaRolesNameFromContent')) {
+		return cache.get('ariaRolesNameFromContent');
+	}
 
-  const contentRoles = Object.keys(standards.ariaRoles).filter(roleName => {
-    return standards.ariaRoles[roleName].nameFromContent;
-  });
+	const contentRoles = Object.keys(standards.ariaRoles).filter(roleName => {
+		return standards.ariaRoles[roleName].nameFromContent;
+	});
 
-  cache.set('ariaRolesNameFromContent', contentRoles);
+	cache.set('ariaRolesNameFromContent', contentRoles);
 
-  return contentRoles;
+	return contentRoles;
 }
 
 export default getAriaRolesSupportingNameFromContent;

package/lib/commons/standards/get-element-spec.js

@@ -7,48 +7,48 @@ import matchesFn from '../../commons/matches';
  * @return {Object} The standard spec object
  */
 function getElementSpec(vNode) {
-  const standard = standards.htmlElms[vNode.props.nodeName];
-
-  // invalid element name (could be an svg or custom element name)
-  if (!standard) {
-    return {};
-  }
-
-  if (!standard.variant) {
-    return standard;
-  }
-
-  // start with the information at the top level
-  const { variant, ...spec } = standard;
-
-  // loop through all variants (excluding default) finding anything
-  // that matches
-  for (const variantName in variant) {
-    if (!variant.hasOwnProperty(variantName) || variantName === 'default') {
-      continue;
-    }
-
-    const { matches, ...props } = variant[variantName];
-    if (matchesFn(vNode, matches)) {
-      for (const propName in props) {
-        if (props.hasOwnProperty(propName)) {
-          spec[propName] = props[propName];
-        }
-      }
-    }
-  }
-
-  // apply defaults if properties were not found
-  for (const propName in variant.default) {
-    if (
-      variant.default.hasOwnProperty(propName) &&
-      typeof spec[propName] === 'undefined'
-    ) {
-      spec[propName] = variant.default[propName];
-    }
-  }
-
-  return spec;
+	const standard = standards.htmlElms[vNode.props.nodeName];
+
+	// invalid element name (could be an svg or custom element name)
+	if (!standard) {
+		return {};
+	}
+
+	if (!standard.variant) {
+		return standard;
+	}
+
+	// start with the information at the top level
+	const { variant, ...spec } = standard;
+
+	// loop through all variants (excluding default) finding anything
+	// that matches
+	for (const variantName in variant) {
+		if (!variant.hasOwnProperty(variantName) || variantName === 'default') {
+			continue;
+		}
+
+		const { matches, ...props } = variant[variantName];
+		if (matchesFn(vNode, matches)) {
+			for (const propName in props) {
+				if (props.hasOwnProperty(propName)) {
+					spec[propName] = props[propName];
+				}
+			}
+		}
+	}
+
+	// apply defaults if properties were not found
+	for (const propName in variant.default) {
+		if (
+			variant.default.hasOwnProperty(propName) &&
+			typeof spec[propName] === 'undefined'
+		) {
+			spec[propName] = variant.default[propName];
+		}
+	}
+
+	return spec;
 }
 
 export default getElementSpec;

package/lib/commons/standards/get-elements-by-content-type.js

@@ -6,25 +6,25 @@ import standards from '../../standards';
  * @return {String[]} List of all elements matching the type
  */
 function getElementsByContentType(type) {
-  return Object.keys(standards.htmlElms).filter(nodeName => {
-    const elm = standards.htmlElms[nodeName];
+	return Object.keys(standards.htmlElms).filter(nodeName => {
+		const elm = standards.htmlElms[nodeName];
 
-    if (elm.contentTypes) {
-      return elm.contentTypes.includes(type);
-    }
+		if (elm.contentTypes) {
+			return elm.contentTypes.includes(type);
+		}
 
-    // some elements do not have content types
-    if (!elm.variant) {
-      return false;
-    }
+		// some elements do not have content types
+		if (!elm.variant) {
+			return false;
+		}
 
-    if (elm.variant.default && elm.variant.default.contentTypes) {
-      return elm.variant.default.contentTypes.includes(type);
-    }
+		if (elm.variant.default && elm.variant.default.contentTypes) {
+			return elm.variant.default.contentTypes.includes(type);
+		}
 
-    // content type depends on a virtual node
-    return false;
-  });
+		// content type depends on a virtual node
+		return false;
+	});
 }
 
 export default getElementsByContentType;

package/lib/commons/standards/get-global-aria-attrs.js

@@ -6,17 +6,17 @@ import standards from '../../standards';
  * @return {String[]} List of all global aria attributes
  */
 function getGlobalAriaAttrs() {
-  if (cache.get('globalAriaAttrs')) {
-    return cache.get('globalAriaAttrs');
-  }
+	if (cache.get('globalAriaAttrs')) {
+		return cache.get('globalAriaAttrs');
+	}
 
-  const globalAttrs = Object.keys(standards.ariaAttrs).filter(attrName => {
-    return standards.ariaAttrs[attrName].global;
-  });
+	const globalAttrs = Object.keys(standards.ariaAttrs).filter(attrName => {
+		return standards.ariaAttrs[attrName].global;
+	});
 
-  cache.set('globalAriaAttrs', globalAttrs);
+	cache.set('globalAriaAttrs', globalAttrs);
 
-  return globalAttrs;
+	return globalAttrs;
 }
 
 export default getGlobalAriaAttrs;