axe-core 4.1.2-canary.ec00dc7 → 4.1.2

package/lib/core/constants.js

@@ -1,62 +1,62 @@
 const definitions = [
-  {
-    name: 'NA',
-    value: 'inapplicable',
-    priority: 0,
-    group: 'inapplicable'
-  },
-  {
-    name: 'PASS',
-    value: 'passed',
-    priority: 1,
-    group: 'passes'
-  },
-  {
-    name: 'CANTTELL',
-    value: 'cantTell',
-    priority: 2,
-    group: 'incomplete'
-  },
-  {
-    name: 'FAIL',
-    value: 'failed',
-    priority: 3,
-    group: 'violations'
-  }
+	{
+		name: 'NA',
+		value: 'inapplicable',
+		priority: 0,
+		group: 'inapplicable'
+	},
+	{
+		name: 'PASS',
+		value: 'passed',
+		priority: 1,
+		group: 'passes'
+	},
+	{
+		name: 'CANTTELL',
+		value: 'cantTell',
+		priority: 2,
+		group: 'incomplete'
+	},
+	{
+		name: 'FAIL',
+		value: 'failed',
+		priority: 3,
+		group: 'violations'
+	}
 ];
 
 const constants = {
-  helpUrlBase: 'https://dequeuniversity.com/rules/',
-  results: [],
-  resultGroups: [],
-  resultGroupMap: {},
-  impact: Object.freeze(['minor', 'moderate', 'serious', 'critical']),
-  preload: Object.freeze({
-    /**
-     * array of supported & preload(able) asset types.
-     */
-    assets: ['cssom', 'media'],
-    /**
-     * timeout value when resolving preload(able) assets
-     */
-    timeout: 10000
-  })
+	helpUrlBase: 'https://dequeuniversity.com/rules/',
+	results: [],
+	resultGroups: [],
+	resultGroupMap: {},
+	impact: Object.freeze(['minor', 'moderate', 'serious', 'critical']),
+	preload: Object.freeze({
+		/**
+		 * array of supported & preload(able) asset types.
+		 */
+		assets: ['cssom', 'media'],
+		/**
+		 * timeout value when resolving preload(able) assets
+		 */
+		timeout: 10000
+	})
 };
 
-definitions.forEach(definition => {
-  const name = definition.name;
-  const value = definition.value;
-  const priority = definition.priority;
-  const group = definition.group;
+definitions.forEach(function(definition) {
+	const name = definition.name;
+	const value = definition.value;
+	const priority = definition.priority;
+	const group = definition.group;
 
-  constants[name] = value;
-  constants[name + '_PRIO'] = priority;
-  constants[name + '_GROUP'] = group;
+	constants[name] = value;
+	constants[name + '_PRIO'] = priority;
+	constants[name + '_GROUP'] = group;
 
-  constants.results[priority] = value;
-  constants.resultGroups[priority] = group;
+	constants.results[priority] = value;
+	constants.resultGroups[priority] = group;
 
-  constants.resultGroupMap[value] = group;
+	constants.resultGroupMap[value] = group;
 });
 
 // Freeze everything

package/lib/core/core.js

@@ -26,8 +26,6 @@ import reset from './public/reset';
 import runRules from './public/run-rules';
 import runVirtualRule from './public/run-virtual-rule';
 import run from './public/run';
-import setup from './public/setup';
-import teardown from './public/teardown';
 
 import naReporter from './reporters/na';
 import noPassesReporter from './reporters/no-passes';
@@ -51,13 +49,13 @@ axe._cache = cache;
 // TODO: remove `_thisWillBeDeletedDoNotUse`
 axe._thisWillBeDeletedDoNotUse = axe._thisWillBeDeletedDoNotUse || {};
 axe._thisWillBeDeletedDoNotUse.base = {
-  Audit,
-  CheckResult,
-  Check,
-  Context,
-  RuleResult,
-  Rule,
-  metadataFunctionMap
+	Audit,
+	CheckResult,
+	Check,
+	Context,
+	RuleResult,
+	Rule,
+	metadataFunctionMap
 };
 
 axe.imports = imports;
@@ -75,8 +73,6 @@ axe.reset = reset;
 axe._runRules = runRules;
 axe.runVirtualRule = runVirtualRule;
 axe.run = run;
-axe.setup = setup;
-axe.teardown = teardown;
 
 axe.commons = commons;
 axe.utils = utils;

package/lib/core/imports/index.js

@@ -8,26 +8,26 @@ import { Uint32Array } from 'typedarray';
 import 'weakmap-polyfill';
 
 if (!('Promise' in window)) {
-  es6promise.polyfill();
+	es6promise.polyfill();
 }
 
 if (!('Uint32Array' in window)) {
-  window.Uint32Array = Uint32Array;
+	window.Uint32Array = Uint32Array;
 }
 if (window.Uint32Array) {
-  // @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
-  if (!('some' in window.Uint32Array.prototype)) {
-    Object.defineProperty(window.Uint32Array.prototype, 'some', {
-      value: Array.prototype.some
-    });
-  }
+	// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+	if (!('some' in window.Uint32Array.prototype)) {
+		Object.defineProperty(window.Uint32Array.prototype, 'some', {
+			value: Array.prototype.some
+		});
+	}
 
-  if (!('reduce' in window.Uint32Array.prototype)) {
-    // @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
-    Object.defineProperty(window.Uint32Array.prototype, 'reduce', {
-      value: Array.prototype.reduce
-    });
-  }
+	if (!('reduce' in window.Uint32Array.prototype)) {
+		// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+		Object.defineProperty(window.Uint32Array.prototype, 'reduce', {
+			value: Array.prototype.reduce
+		});
+	}
 }
 
 /**

package/lib/core/index.js

@@ -6,35 +6,37 @@ var axe = axe || {};
 axe.version = '<%= pkg.version %>';
 
 if (typeof define === 'function' && define.amd) {
-  // Explicitly naming the module to avoid mismatched anonymous define() modules when injected in a page
-  define('axe-core', [], () => axe);
+	// Explicitly naming the module to avoid mismatched anonymous define() modules when injected in a page
+	define('axe-core', [], function() {
+		return axe;
+	});
 }
 if (
-  typeof module === 'object' &&
-  module.exports &&
-  typeof axeFunction.toString === 'function'
+	typeof module === 'object' &&
+	module.exports &&
+	typeof axeFunction.toString === 'function'
 ) {
-  axe.source =
-    '(' +
-    axeFunction.toString() +
-    ')(typeof window === "object" ? window : this);';
-  module.exports = axe;
+	axe.source =
+		'(' +
+		axeFunction.toString() +
+		')(typeof window === "object" ? window : this);';
+	module.exports = axe;
 }
 if (typeof window.getComputedStyle === 'function') {
-  window.axe = axe;
+	window.axe = axe;
 }
 // local namespace for common functions
 var commons;
 
 function SupportError(error) {
-  this.name = 'SupportError';
-  this.cause = error.cause;
-  this.message = `\`${error.cause}\` - feature unsupported in your environment.`;
-  if (error.ruleId) {
-    this.ruleId = error.ruleId;
-    this.message += ` Skipping ${this.ruleId} rule.`;
-  }
-  this.stack = new Error().stack;
+	this.name = 'SupportError';
+	this.cause = error.cause;
+	this.message = `\`${error.cause}\` - feature unsupported in your environment.`;
+	if (error.ruleId) {
+		this.ruleId = error.ruleId;
+		this.message += ` Skipping ${this.ruleId} rule.`;
+	}
+	this.stack = new Error().stack;
 }
 SupportError.prototype = Object.create(Error.prototype);
 SupportError.prototype.constructor = SupportError;

package/lib/core/log.js

@@ -4,10 +4,10 @@
  * Logs a message to the developer console (if it exists and is active).
  */
 function log() {
-  if (typeof console === 'object' && console.log) {
-    // IE does not support console.log.apply
-    Function.prototype.apply.call(console.log, console, arguments);
-  }
+	if (typeof console === 'object' && console.log) {
+		// IE does not support console.log.apply
+		Function.prototype.apply.call(console.log, console, arguments);
+	}
 }
 
 export default log;

package/lib/core/public/cleanup.js

@@ -1,51 +1,53 @@
 function cleanup(resolve, reject) {
-  resolve = resolve || function res() {};
-  reject = reject || axe.log;
+	resolve = resolve || function() {};
+	reject = reject || axe.log;
 
-  if (!axe._audit) {
-    throw new Error('No audit configured');
-  }
+	if (!axe._audit) {
+		throw new Error('No audit configured');
+	}
 
-  var q = axe.utils.queue();
-  // If a plugin fails it's cleanup, we still want the others to run
-  var cleanupErrors = [];
+	var q = axe.utils.queue();
+	// If a plugin fails it's cleanup, we still want the others to run
+	var cleanupErrors = [];
 
-  Object.keys(axe.plugins).forEach(key => {
-    q.defer(res => {
-      var rej = function rej(err) {
-        cleanupErrors.push(err);
-        res();
-      };
-      try {
-        axe.plugins[key].cleanup(res, rej);
-      } catch (err) {
-        rej(err);
-      }
-    });
-  });
+	Object.keys(axe.plugins).forEach(function(key) {
+		q.defer(function(res) {
+			var rej = function(err) {
+				cleanupErrors.push(err);
+				res();
+			};
+			try {
+				axe.plugins[key].cleanup(res, rej);
+			} catch (err) {
+				rej(err);
+			}
+		});
+	});
 
-  var flattenedTree = axe.utils.getFlattenedTree(document.body);
+	var flattenedTree = axe.utils.getFlattenedTree(document.body);
 
-  axe.utils.querySelectorAll(flattenedTree, 'iframe, frame').forEach(node => {
-    q.defer((res, rej) => {
-      return axe.utils.sendCommandToFrame(
-        node.actualNode,
-        {
-          command: 'cleanup-plugin'
-        },
-        res,
-        rej
-      );
-    });
-  });
+	axe.utils
+		.querySelectorAll(flattenedTree, 'iframe, frame')
+		.forEach(function(node) {
+			q.defer(function(res, rej) {
+				return axe.utils.sendCommandToFrame(
+					node.actualNode,
+					{
+						command: 'cleanup-plugin'
+					},
+					res,
+					rej
+				);
+			});
+		});
 
-  q.then(results => {
-    if (cleanupErrors.length === 0) {
-      resolve(results);
-    } else {
-      reject(cleanupErrors);
-    }
-  }).catch(reject);
+	q.then(function(results) {
+		if (cleanupErrors.length === 0) {
+			resolve(results);
+		} else {
+			reject(cleanupErrors);
+		}
+	}).catch(reject);
 }
 
 export default cleanup;

package/lib/core/public/configure.js

@@ -2,118 +2,118 @@ import { hasReporter } from './reporter';
 import { configureStandards } from '../../standards';
 
 function configure(spec) {
-  var audit;
-
-  audit = axe._audit;
-  if (!audit) {
-    throw new Error('No audit configured');
-  }
-
-  if (spec.axeVersion || spec.ver) {
-    const specVersion = spec.axeVersion || spec.ver;
-    if (!/^\d+\.\d+\.\d+(-canary)?/.test(specVersion)) {
-      throw new Error(`Invalid configured version ${specVersion}`);
-    }
-
-    const [version, canary] = specVersion.split('-');
-    const [major, minor, patch] = version.split('.').map(Number);
-
-    const [axeVersion, axeCanary] = axe.version.split('-');
-    const [axeMajor, axeMinor, axePatch] = axeVersion.split('.').map(Number);
-
-    if (
-      major !== axeMajor ||
-      axeMinor < minor ||
-      (axeMinor === minor && axePatch < patch) ||
-      (major === axeMajor &&
-        minor === axeMinor &&
-        patch === axePatch &&
-        canary &&
-        canary !== axeCanary)
-    ) {
-      throw new Error(
-        `Configured version ${specVersion} is not compatible with current axe version ${axe.version}`
-      );
-    }
-  }
-
-  if (
-    spec.reporter &&
-    (typeof spec.reporter === 'function' || hasReporter(spec.reporter))
-  ) {
-    audit.reporter = spec.reporter;
-  }
-
-  if (spec.checks) {
-    if (!Array.isArray(spec.checks)) {
-      throw new TypeError('Checks property must be an array');
-    }
-
-    spec.checks.forEach(check => {
-      if (!check.id) {
-        throw new TypeError(
-          // eslint-disable-next-line max-len
-          `Configured check ${JSON.stringify(
-            check
-          )} is invalid. Checks must be an object with at least an id property`
-        );
-      }
-
-      audit.addCheck(check);
-    });
-  }
-
-  const modifiedRules = [];
-  if (spec.rules) {
-    if (!Array.isArray(spec.rules)) {
-      throw new TypeError('Rules property must be an array');
-    }
-
-    spec.rules.forEach(rule => {
-      if (!rule.id) {
-        throw new TypeError(
-          // eslint-disable-next-line max-len
-          `Configured rule ${JSON.stringify(
-            rule
-          )} is invalid. Rules must be an object with at least an id property`
-        );
-      }
-
-      modifiedRules.push(rule.id);
-      audit.addRule(rule);
-    });
-  }
-
-  if (spec.disableOtherRules) {
-    audit.rules.forEach(rule => {
-      if (modifiedRules.includes(rule.id) === false) {
-        rule.enabled = false;
-      }
-    });
-  }
-
-  if (typeof spec.branding !== 'undefined') {
-    audit.setBranding(spec.branding);
-  } else {
-    audit._constructHelpUrls();
-  }
-
-  if (spec.tagExclude) {
-    audit.tagExclude = spec.tagExclude;
-  }
-
-  // Support runtime localization
-  if (spec.locale) {
-    audit.applyLocale(spec.locale);
-  }
-
-  if (spec.standards) {
-    configureStandards(spec.standards);
-  }
-
-  if (spec.noHtml) {
-    audit.noHtml = true;
-  }
+	var audit;
+
+	audit = axe._audit;
+	if (!audit) {
+		throw new Error('No audit configured');
+	}
+
+	if (spec.axeVersion || spec.ver) {
+		const specVersion = spec.axeVersion || spec.ver;
+		if (!/^\d+\.\d+\.\d+(-canary)?/.test(specVersion)) {
+			throw new Error(`Invalid configured version ${specVersion}`);
+		}
+
+		const [version, canary] = specVersion.split('-');
+		const [major, minor, patch] = version.split('.').map(Number);
+
+		const [axeVersion, axeCanary] = axe.version.split('-');
+		const [axeMajor, axeMinor, axePatch] = axeVersion.split('.').map(Number);
+
+		if (
+			major !== axeMajor ||
+			axeMinor < minor ||
+			(axeMinor === minor && axePatch < patch) ||
+			(major === axeMajor &&
+				minor === axeMinor &&
+				patch === axePatch &&
+				canary &&
+				canary !== axeCanary)
+		) {
+			throw new Error(
+				`Configured version ${specVersion} is not compatible with current axe version ${axe.version}`
+			);
+		}
+	}
+
+	if (
+		spec.reporter &&
+		(typeof spec.reporter === 'function' || hasReporter(spec.reporter))
+	) {
+		audit.reporter = spec.reporter;
+	}
+
+	if (spec.checks) {
+		if (!Array.isArray(spec.checks)) {
+			throw new TypeError('Checks property must be an array');
+		}
+
+		spec.checks.forEach(check => {
+			if (!check.id) {
+				throw new TypeError(
+					// eslint-disable-next-line max-len
+					`Configured check ${JSON.stringify(
+						check
+					)} is invalid. Checks must be an object with at least an id property`
+				);
+			}
+
+			audit.addCheck(check);
+		});
+	}
+
+	const modifiedRules = [];
+	if (spec.rules) {
+		if (!Array.isArray(spec.rules)) {
+			throw new TypeError('Rules property must be an array');
+		}
+
+		spec.rules.forEach(rule => {
+			if (!rule.id) {
+				throw new TypeError(
+					// eslint-disable-next-line max-len
+					`Configured rule ${JSON.stringify(
+						rule
+					)} is invalid. Rules must be an object with at least an id property`
+				);
+			}
+
+			modifiedRules.push(rule.id);
+			audit.addRule(rule);
+		});
+	}
+
+	if (spec.disableOtherRules) {
+		audit.rules.forEach(rule => {
+			if (modifiedRules.includes(rule.id) === false) {
+				rule.enabled = false;
+			}
+		});
+	}
+
+	if (typeof spec.branding !== 'undefined') {
+		audit.setBranding(spec.branding);
+	} else {
+		audit._constructHelpUrls();
+	}
+
+	if (spec.tagExclude) {
+		audit.tagExclude = spec.tagExclude;
+	}
+
+	// Support runtime localization
+	if (spec.locale) {
+		audit.applyLocale(spec.locale);
+	}
+
+	if (spec.standards) {
+		configureStandards(spec.standards);
+	}
+
+	if (spec.noHtml) {
+		audit.noHtml = true;
+	}
 }
 
 export default configure;

package/lib/core/public/get-rules.js

@@ -4,26 +4,26 @@
  * @return {Array}  Array of rules
  */
 function getRules(tags) {
-  tags = tags || [];
-  var matchingRules = !tags.length
-    ? axe._audit.rules
-    : axe._audit.rules.filter(item => {
-        return !!tags.filter(tag => {
-          return item.tags.indexOf(tag) !== -1;
-        }).length;
-      });
+	tags = tags || [];
+	var matchingRules = !tags.length
+		? axe._audit.rules
+		: axe._audit.rules.filter(function(item) {
+				return !!tags.filter(function(tag) {
+					return item.tags.indexOf(tag) !== -1;
+				}).length;
+		  });
 
-  var ruleData = axe._audit.data.rules || {};
-  return matchingRules.map(matchingRule => {
-    var rd = ruleData[matchingRule.id] || {};
-    return {
-      ruleId: matchingRule.id,
-      description: rd.description,
-      help: rd.help,
-      helpUrl: rd.helpUrl,
-      tags: matchingRule.tags
-    };
-  });
+	var ruleData = axe._audit.data.rules || {};
+	return matchingRules.map(function(matchingRule) {
+		var rd = ruleData[matchingRule.id] || {};
+		return {
+			ruleId: matchingRule.id,
+			description: rd.description,
+			help: rd.help,
+			helpUrl: rd.helpUrl,
+			tags: matchingRule.tags
+		};
+	});
 }
 
 export default getRules;