govuk_publishing_components 16.6.0 → 16.7.0

data/node_modules/axe-core/lib/commons/text/sanitize.js

@@ -0,0 +1,18 @@
+/* global text */
+
+/**
+ * Removes carriage returns, newline characters, tabs, non-breaking spaces, and trailing spaces from string
+ * @method sanitize
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {String} str String to be cleaned
+ * @return {String} Sanitized string
+ */
+text.sanitize = function(str) {
+	'use strict';
+	return str
+		.replace(/\r\n/g, '\n')
+		.replace(/\u00A0/g, ' ')
+		.replace(/[\s]{2,}/g, ' ')
+		.trim();
+};

data/node_modules/axe-core/lib/commons/text/subtree-text.js

@@ -0,0 +1,89 @@
+/* global text, aria */
+/**
+ * Get the accessible text for an element that can get its name from content
+ *
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {Bool} strict Should the name computation strictly follow AccName 1.1
+ * @return {String} Accessible text
+ */
+text.subtreeText = function subtreeText(virtualNode, context = {}) {
+	const { alreadyProcessed } = text.accessibleTextVirtual
+	context.startNode = context.startNode || virtualNode;
+	const { strict } = context;
+	if (
+		alreadyProcessed(virtualNode, context ) ||
+		!aria.namedFromContents(virtualNode, { strict })
+	) {
+		return '';
+	}
+
+	return aria.getOwnedVirtual(virtualNode).reduce((contentText, child) => {
+		return appendAccessibleText(contentText, child, context);
+	}, '');
+};
+
+// TODO: Could do with an "HTML" lookup table, similar to ARIA,
+//  where this sort of stuff can live.
+const phrasingElements = [
+	'A',
+	'EM',
+	'STRONG',
+	'SMALL',
+	'MARK',
+	'ABBR',
+	'DFN',
+	'I',
+	'B',
+	'S',
+	'U',
+	'CODE',
+	'VAR',
+	'SAMP',
+	'KBD',
+	'SUP',
+	'SUB',
+	'Q',
+	'CITE',
+	'SPAN',
+	'BDO',
+	'BDI',
+	'WBR',
+	'INS',
+	'DEL',
+	'MAP',
+	'AREA',
+	'NOSCRIPT',
+	'RUBY',
+	'BUTTON',
+	'LABEL',
+	'OUTPUT',
+	'DATALIST',
+	'KEYGEN',
+	'PROGRESS',
+	'COMMAND',
+	'CANVAS',
+	'TIME',
+	'METER',
+	'#TEXT'
+];
+
+function appendAccessibleText(contentText, virtualNode, context) {
+	const nodeName = virtualNode.actualNode.nodeName.toUpperCase();
+	let contentTextAdd = text.accessibleTextVirtual(virtualNode, context);
+	if (!contentTextAdd) {
+		return contentText
+	}
+
+	if (!phrasingElements.includes(nodeName)) {
+		// Append space, if necessary
+		if (contentTextAdd[0] !== ' ') {
+			contentTextAdd += ' ';
+		}
+		// Prepend space, if necessary
+		if (contentText && contentText[contentText.length - 1] !== ' ') {
+			contentTextAdd = ' ' + contentTextAdd;
+		}
+	}
+	return contentText + contentTextAdd;
+}

data/node_modules/axe-core/lib/commons/text/title-text.js

@@ -0,0 +1,33 @@
+/* global text, aria */
+const alwaysTitleElements = [
+	'button',
+	'iframe',
+	'a[href]',
+	{
+		nodeName: 'input',
+		properties: { type: 'button' }
+	}
+];
+
+/**
+ * Get title text
+ * @param {HTMLElement}node the node to verify
+ * @return {String}
+ */
+text.titleText = function titleText(node) {
+	node = node.actualNode || node;
+	if (node.nodeType !== 1 || !node.hasAttribute('title')) {
+		return '';
+	}
+
+	// Some elements return the title even with role=presentation
+	// This does appear in any spec, but its remarkably consistent
+	if (
+		!axe.commons.matches(node, alwaysTitleElements) &&
+		['none', 'presentation'].includes(aria.getRole(node))
+	) {
+		return '';
+	}
+
+	return node.getAttribute('title');
+};

data/node_modules/axe-core/lib/commons/text/unicode.js

@@ -0,0 +1,117 @@
+/* global text */
+
+/**
+ * Determine if a given string contains unicode characters, specified in options
+ *
+ * @method hasUnicode
+ * @memberof axe.commons.text
+ * @instance
+ * @param {String} str string to verify
+ * @param {Object} options config containing which unicode character sets to verify
+ * @property {Boolean} options.emoji verify emoji unicode
+ * @property {Boolean} options.nonBmp verify nonBmp unicode
+ * @property {Boolean} options.punctuations verify punctuations unicode
+ * @returns {Boolean}
+ */
+text.hasUnicode = function hasUnicode(str, options) {
+	const { emoji, nonBmp, punctuations } = options;
+	if (emoji) {
+		return axe.imports.emojiRegexText().test(str);
+	}
+	if (nonBmp) {
+		return getUnicodeNonBmpRegExp().test(str);
+	}
+	if (punctuations) {
+		return getPunctuationRegExp().test(str);
+	}
+	return false;
+};
+
+/**
+ * Remove specified type(s) unicode characters
+ *
+ * @method removeUnicode
+ * @memberof axe.commons.text
+ * @instance
+ * @param {String} str string to operate on
+ * @param {Object} options config containing which unicode character sets to remove
+ * @property {Boolean} options.emoji remove emoji unicode
+ * @property {Boolean} options.nonBmp remove nonBmp unicode
+ * @property {Boolean} options.punctuations remove punctuations unicode
+ * @returns {String}
+ */
+text.removeUnicode = function removeUnicode(str, options) {
+	const { emoji, nonBmp, punctuations } = options;
+
+	if (emoji) {
+		str = str.replace(axe.imports.emojiRegexText(), '');
+	}
+	if (nonBmp) {
+		str = str.replace(getUnicodeNonBmpRegExp(), '');
+	}
+	if (punctuations) {
+		str = str.replace(getPunctuationRegExp(), '');
+	}
+
+	return str;
+};
+
+/**
+ * Regex for matching unicode values out of Basic Multilingual Plane (BMP)
+ * Reference:
+ * - https://github.com/mathiasbynens/regenerate
+ * - https://unicode-table.com/
+ * - https://mathiasbynens.be/notes/javascript-unicode
+ *
+ * @returns {RegExp}
+ */
+function getUnicodeNonBmpRegExp() {
+	/**
+	 * Regex for matching astral plane unicode
+	 * - http://kourge.net/projects/regexp-unicode-block
+	 */
+	return new RegExp(
+		'[' +
+		'\u1D00-\u1D7F' + // Phonetic Extensions
+		'\u1D80-\u1DBF' + // Phonetic Extensions Supplement
+		'\u1DC0-\u1DFF' + // Combining Diacritical Marks Supplement
+		// '\u2000-\u206F' + // General punctuation - handled in -> getPunctuationRegExp
+		'\u20A0-\u20CF' + // Currency symbols
+		'\u20D0-\u20FF' + // Combining Diacritical Marks for Symbols
+		'\u2100-\u214F' + // Letter like symbols
+		'\u2150-\u218F' + // Number forms (eg: Roman numbers)
+		'\u2190-\u21FF' + // Arrows
+		'\u2200-\u22FF' + // Mathematical operators
+		'\u2300-\u23FF' + // Misc Technical
+		'\u2400-\u243F' + // Control pictures
+		'\u2440-\u245F' + // OCR
+		'\u2460-\u24FF' + // Enclosed alpha numerics
+		'\u2500-\u257F' + // Box Drawing
+		'\u2580-\u259F' + // Block Elements
+		'\u25A0-\u25FF' + // Geometric Shapes
+		'\u2600-\u26FF' + // Misc Symbols
+		'\u2700-\u27BF' + // Dingbats
+			']'
+	);
+}
+
+/**
+ * Get regular expression for matching punctuations
+ *
+ * @returns {RegExp}
+ */
+function getPunctuationRegExp() {
+	/**
+	 * Reference: http://kunststube.net/encoding/
+	 * US-ASCII
+	 * -> !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+	 *
+	 * General Punctuation block
+	 * -> \u2000-\u206F
+	 *
+	 * Supplemental Punctuation block
+	 * Reference: https://en.wikipedia.org/wiki/Supplemental_Punctuation
+	 * -> \u2E00-\u2E7F Reference
+	 */
+	return /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]/g;
+}

data/node_modules/axe-core/lib/commons/text/unsupported.js

@@ -0,0 +1,5 @@
+/* global text */
+
+text.unsupported = {
+	accessibleNameFromFieldValue: ['combobox', 'listbox', 'progressbar']
+};

data/node_modules/axe-core/lib/commons/text/visible-virtual.js

@@ -0,0 +1,46 @@
+/* global text, dom, axe */
+
+/**
+ * Returns the visible text of the virtual node
+ * NOTE: when calculating the text or accessible text of a node that includes shadow
+ * roots attached to it or its children, the flattened tree must be considered
+ * rather than the "light DOM"
+ * @method visibleVirtual
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {VirtualNode} element
+ * @param  {Boolean} screenReader When provided, will evaluate visibility from the perspective of a screen reader
+ * @param  {Boolean} noRecursing When False, the result will contain text from the element and it's children.
+ * When True, the result will only contain text from the element
+ * @return {String}
+ */
+text.visibleVirtual = function(element, screenReader, noRecursing) {
+	const result = element.children
+		.map(child => {
+			if (child.actualNode.nodeType === 3) {
+				// filter on text nodes
+				const nodeValue = child.actualNode.nodeValue;
+				if (nodeValue && dom.isVisible(element.actualNode, screenReader)) {
+					return nodeValue;
+				}
+			} else if (!noRecursing) {
+				return text.visibleVirtual(child, screenReader);
+			}
+		})
+		.join('');
+	return text.sanitize(result);
+};
+
+/**
+ * Finds virtual node and calls visibleVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ * @param  {Element} element
+ * @param  {Boolean} screenReader When provided, will evaluate visibility from the perspective of a screen reader
+ * @param  {Boolean} noRecursing When False, the result will contain text from the element and it's children.
+ * When True, the result will only contain text from the element
+ * @return {String}
+ */
+text.visible = function(element, screenReader, noRecursing) {
+	element = axe.utils.getNodeFromTree(axe._tree[0], element);
+	return text.visibleVirtual(element, screenReader, noRecursing);
+};

data/node_modules/axe-core/lib/commons/utils/index.js

@@ -0,0 +1,10 @@
+/* exported utils */
+/* global axe */
+/*eslint no-unused-vars: 0*/
+/**
+ * Namespace for general utilities.
+ * @namespace utils
+ * @memberof axe.commons
+ */
+
+var utils = (commons.utils = axe.utils);

data/node_modules/axe-core/lib/core/base/audit.js

@@ -0,0 +1,684 @@
+/*global Rule, Check, RuleResult, commons: true */
+/*eslint no-unused-vars: 0*/
+function getDefaultConfiguration(audit) {
+	'use strict';
+	var config;
+	if (audit) {
+		config = axe.utils.clone(audit);
+		// Commons are configured into axe like everything else,
+		// however because things go funky if we have multiple commons objects
+		// we're not using the copy of that.
+		config.commons = audit.commons;
+	} else {
+		config = {};
+	}
+
+	config.reporter = config.reporter || null;
+	config.rules = config.rules || [];
+	config.checks = config.checks || [];
+	config.data = { checks: {}, rules: {}, ...config.data };
+	return config;
+}
+
+function unpackToObject(collection, audit, method) {
+	'use strict';
+
+	var i, l;
+	for (i = 0, l = collection.length; i < l; i++) {
+		audit[method](collection[i]);
+	}
+}
+
+/**
+ * Constructor which holds configured rules and information about the document under test
+ */
+function Audit(audit) {
+	// defaults
+	this.brand = 'axe';
+	this.application = 'axeAPI';
+	this.tagExclude = ['experimental'];
+
+	this.defaultConfig = audit;
+	this._init();
+
+	// A copy of the "default" locale. This will be set if the user
+	// provides a new locale to `axe.configure()` and used to undo
+	// changes in `axe.reset()`.
+	this._defaultLocale = null;
+}
+
+/**
+ * Build and set the previous locale. Will noop if a previous
+ * locale was already set, as we want the ability to "reset"
+ * to the default ("first") configuration.
+ */
+
+Audit.prototype._setDefaultLocale = function() {
+	if (this._defaultLocale) {
+		return;
+	}
+
+	const locale = {
+		checks: {},
+		rules: {}
+	};
+
+	// XXX: unable to use `for-of` here, as doing so would
+	// require us to polyfill `Symbol`.
+	const checkIDs = Object.keys(this.data.checks);
+	for (let i = 0; i < checkIDs.length; i++) {
+		const id = checkIDs[i];
+		const check = this.data.checks[id];
+		const { pass, fail, incomplete } = check.messages;
+		locale.checks[id] = {
+			pass,
+			fail,
+			incomplete
+		};
+	}
+
+	const ruleIDs = Object.keys(this.data.rules);
+	for (let i = 0; i < ruleIDs.length; i++) {
+		const id = ruleIDs[i];
+		const rule = this.data.rules[id];
+		const { description, help } = rule;
+		locale.rules[id] = { description, help };
+	}
+
+	this._defaultLocale = locale;
+};
+
+/**
+ * Reset the locale to the "default".
+ */
+
+Audit.prototype._resetLocale = function() {
+	// If the default locale has not already been set, we can exit early.
+	const defaultLocale = this._defaultLocale;
+	if (!defaultLocale) {
+		return;
+	}
+
+	// Apply the default locale
+	this.applyLocale(defaultLocale);
+};
+
+/**
+ * Merge two check locales (a, b), favoring `b`.
+ *
+ * Both locale `a` and the returned shape resemble:
+ *
+ *    {
+ *      impact: string,
+ *      messages: {
+ *        pass: string | function,
+ *        fail: string | function,
+ *        incomplete: string | {
+ *          [key: string]: string | function
+ *        }
+ *      }
+ *    }
+ *
+ * Locale `b` follows the `axe.CheckLocale` shape and resembles:
+ *
+ *    {
+ *      pass: string,
+ *      fail: string,
+ *      incomplete: string | { [key: string]: string }
+ *    }
+ */
+
+const mergeCheckLocale = (a, b) => {
+	let { pass, fail } = b;
+	// If the message(s) are Strings, they have not yet been run
+	// thru doT (which will return a Function).
+	if (typeof pass === 'string') {
+		pass = axe.imports.doT.compile(pass);
+	}
+	if (typeof fail === 'string') {
+		fail = axe.imports.doT.compile(fail);
+	}
+	return {
+		...a,
+		messages: {
+			pass: pass || a.messages.pass,
+			fail: fail || a.messages.fail,
+			incomplete:
+				typeof a.messages.incomplete === 'object'
+					? // TODO: for compleness-sake, we should be running
+					  // incomplete messages thru doT as well. This was
+					  // out-of-scope for runtime localization, but should
+					  // eventually be addressed.
+					  { ...a.messages.incomplete, ...b.incomplete }
+					: b.incomplete
+		}
+	};
+};
+
+/**
+ * Merge two rule locales (a, b), favoring `b`.
+ */
+
+const mergeRuleLocale = (a, b) => {
+	let { help, description } = b;
+	// If the message(s) are Strings, they have not yet been run
+	// thru doT (which will return a Function).
+	if (typeof help === 'string') {
+		help = axe.imports.doT.compile(help);
+	}
+	if (typeof description === 'string') {
+		description = axe.imports.doT.compile(description);
+	}
+	return {
+		...a,
+		help: help || a.help,
+		description: description || a.description
+	};
+};
+
+/**
+ * Apply locale for the given `checks`.
+ */
+
+Audit.prototype._applyCheckLocale = function(checks) {
+	const keys = Object.keys(checks);
+	for (let i = 0; i < keys.length; i++) {
+		const id = keys[i];
+		if (!this.data.checks[id]) {
+			throw new Error(`Locale provided for unknown check: "${id}"`);
+		}
+
+		this.data.checks[id] = mergeCheckLocale(this.data.checks[id], checks[id]);
+	}
+};
+
+/**
+ * Apply locale for the given `rules`.
+ */
+
+Audit.prototype._applyRuleLocale = function(rules) {
+	const keys = Object.keys(rules);
+	for (let i = 0; i < keys.length; i++) {
+		const id = keys[i];
+		if (!this.data.rules[id]) {
+			throw new Error(`Locale provided for unknown rule: "${id}"`);
+		}
+		this.data.rules[id] = mergeRuleLocale(this.data.rules[id], rules[id]);
+	}
+};
+
+/**
+ * Apply the given `locale`.
+ *
+ * @param {axe.Locale}
+ */
+
+Audit.prototype.applyLocale = function(locale) {
+	this._setDefaultLocale();
+
+	if (locale.checks) {
+		this._applyCheckLocale(locale.checks);
+	}
+
+	if (locale.rules) {
+		this._applyRuleLocale(locale.rules);
+	}
+};
+
+/**
+ * Initializes the rules and checks
+ */
+Audit.prototype._init = function() {
+	var audit = getDefaultConfiguration(this.defaultConfig);
+
+	axe.commons = commons = audit.commons;
+
+	this.reporter = audit.reporter;
+	this.commands = {};
+	this.rules = [];
+	this.checks = {};
+
+	unpackToObject(audit.rules, this, 'addRule');
+	unpackToObject(audit.checks, this, 'addCheck');
+
+	this.data = {};
+	this.data.checks = (audit.data && audit.data.checks) || {};
+	this.data.rules = (audit.data && audit.data.rules) || {};
+	this.data.failureSummaries =
+		(audit.data && audit.data.failureSummaries) || {};
+	this.data.incompleteFallbackMessage =
+		(audit.data && audit.data.incompleteFallbackMessage) || '';
+
+	this._constructHelpUrls(); // create default helpUrls
+};
+
+/**
+ * Adds a new command to the audit
+ */
+
+Audit.prototype.registerCommand = function(command) {
+	'use strict';
+	this.commands[command.id] = command.callback;
+};
+
+/**
+ * Adds a new rule to the Audit.  If a rule with specified ID already exists, it will be overridden
+ * @param {Object} spec Rule specification object
+ */
+Audit.prototype.addRule = function(spec) {
+	'use strict';
+
+	if (spec.metadata) {
+		this.data.rules[spec.id] = spec.metadata;
+	}
+
+	let rule = this.getRule(spec.id);
+	if (rule) {
+		rule.configure(spec);
+	} else {
+		this.rules.push(new Rule(spec, this));
+	}
+};
+
+/**
+ * Adds a new check to the Audit.  If a Check with specified ID already exists, it will be
+ * reconfigured
+ *
+ * @param {Object} spec Check specification object
+ */
+Audit.prototype.addCheck = function(spec) {
+	/*eslint no-eval: 0 */
+	'use strict';
+	let metadata = spec.metadata;
+
+	if (typeof metadata === 'object') {
+		this.data.checks[spec.id] = metadata;
+		// Transform messages into functions:
+		if (typeof metadata.messages === 'object') {
+			Object.keys(metadata.messages)
+				.filter(
+					prop =>
+						metadata.messages.hasOwnProperty(prop) &&
+						typeof metadata.messages[prop] === 'string'
+				)
+				.forEach(prop => {
+					if (metadata.messages[prop].indexOf('function') === 0) {
+						metadata.messages[prop] = new Function(
+							'return ' + metadata.messages[prop] + ';'
+						)();
+					}
+				});
+		}
+	}
+
+	if (this.checks[spec.id]) {
+		this.checks[spec.id].configure(spec);
+	} else {
+		this.checks[spec.id] = new Check(spec);
+	}
+};
+
+/**
+ * Splits a given array of rules to two, with rules that can be run immediately and one's that are dependent on preloadedAssets
+ * @method getRulesToRun
+ * @param {Array<Object>} rules complete list of rules
+ * @param {Object} context
+ * @param {Object} options
+ * @return {Object} out, an object containing two arrays, one being list of rules to run now and list of rules to run later
+ * @private
+ */
+function getRulesToRun(rules, context, options) {
+	// entry object for reduce function below
+	const base = {
+		now: [],
+		later: []
+	};
+
+	// iterate through rules and separate out rules that need to be run now vs later
+	const splitRules = rules.reduce((out, rule) => {
+		// ensure rule can run
+		if (!axe.utils.ruleShouldRun(rule, context, options)) {
+			return out;
+		}
+
+		// does rule require preload assets - push to later array
+		if (rule.preload) {
+			out.later.push(rule);
+			return out;
+		}
+
+		// default to now array
+		out.now.push(rule);
+
+		// return
+		return out;
+	}, base);
+
+	// return
+	return splitRules;
+}
+
+/**
+ * Convenience method, that consturcts a rule `run` function that can be deferred
+ * @param {Object} rule rule to be deferred
+ * @param {Object} context context object essential to be passed into rule `run`
+ * @param {Object} options normalised options to be passed into rule `run`
+ * @param {Object} assets (optional) preloaded assets to be passed into rule and checks (if the rule is preload dependent)
+ * @return {Function} a deferrable function for rule
+ */
+function getDefferedRule(rule, context, options) {
+	// init performance timer of requested via options
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.mark('mark_rule_start_' + rule.id);
+	}
+
+	return (resolve, reject) => {
+		// invoke `rule.run`
+		rule.run(
+			context,
+			options,
+			// resolve callback for rule `run`
+			ruleResult => {
+				// resolve
+				resolve(ruleResult);
+			},
+			// reject callback for rule `run`
+			err => {
+				// if debug - construct error details
+				if (!options.debug) {
+					const errResult = Object.assign(new RuleResult(rule), {
+						result: axe.constants.CANTTELL,
+						description: 'An error occured while running this rule',
+						message: err.message,
+						stack: err.stack,
+						error: err,
+						// Add a serialized reference to the node the rule failed on for easier debugging.
+						// See https://github.com/dequelabs/axe-core/issues/1317.
+						errorNode: err.errorNode
+					});
+					// resolve
+					resolve(errResult);
+				} else {
+					// reject
+					reject(err);
+				}
+			}
+		);
+	};
+}
+
+/**
+ * Runs the Audit; which in turn should call `run` on each rule.
+ * @async
+ * @param  {Context}   context The scope definition/context for analysis (include/exclude)
+ * @param  {Object}    options Options object to pass into rules and/or disable rules or checks
+ * @param  {Function} fn       Callback function to fire when audit is complete
+ */
+Audit.prototype.run = function(context, options, resolve, reject) {
+	'use strict';
+
+	this.normalizeOptions(options);
+	axe._selectCache = [];
+
+	// get a list of rules to run NOW vs. LATER (later are preload assets dependent rules)
+	const allRulesToRun = getRulesToRun(this.rules, context, options);
+	const runNowRules = allRulesToRun.now;
+	const runLaterRules = allRulesToRun.later;
+
+	// init a NOW queue for rules to run immediately
+	const nowRulesQueue = axe.utils.queue();
+	// construct can run NOW rules into NOW queue
+	runNowRules.forEach(rule => {
+		nowRulesQueue.defer(getDefferedRule(rule, context, options));
+	});
+
+	// init a PRELOADER queue to start preloading assets
+	const preloaderQueue = axe.utils.queue();
+	// defer preload if preload dependent rules exist
+	if (runLaterRules.length) {
+		preloaderQueue.defer((res, rej) => {
+			// handle both success and fail of preload
+			// and resolve, to allow to run all checks
+			axe.utils
+				.preload(options)
+				.then(preloadResults => {
+					// pluck first item in results (because it is a queue - meh!) and resolve
+					const assets = preloadResults[0];
+					res(assets);
+				})
+				.catch(err => {
+					// resolve as undefined, to allow rule.run to continue
+					console.warn(`Couldn't load preload assets: `, err);
+					const assets = undefined;
+					res(assets);
+				});
+		});
+	}
+
+	// defer now and preload queue to run immediately
+	const queueForNowRulesAndPreloader = axe.utils.queue();
+	queueForNowRulesAndPreloader.defer(nowRulesQueue);
+	queueForNowRulesAndPreloader.defer(preloaderQueue);
+
+	// invoke the now queue
+	queueForNowRulesAndPreloader
+		.then(nowRulesAndPreloaderResults => {
+			// interpolate results into separate variables
+			const assetsFromQueue = nowRulesAndPreloaderResults.pop();
+			if (assetsFromQueue && assetsFromQueue.length) {
+				// result is a queue (again), hence the index resolution
+				// assets is either an object of key value pairs of asset type and values
+				// eg: cssom: [stylesheets]
+				// or undefined if preload failed
+				const assets = assetsFromQueue[0];
+				// extend context with preloaded assets
+				if (assets) {
+					context = {
+						...context,
+						...assets
+					};
+				}
+			}
+
+			// the reminder of the results are RuleResults
+			const nowRulesResults = nowRulesAndPreloaderResults[0];
+
+			// if there are no rules to run LATER - resolve with rule results
+			if (!runLaterRules.length) {
+				// remove the cache
+				axe._selectCache = undefined;
+				// resolve
+				resolve(nowRulesResults.filter(result => !!result));
+				return;
+			}
+
+			// init a LATER queue for rules that are dependant on preloaded assets
+			const laterRulesQueue = axe.utils.queue();
+			runLaterRules.forEach(rule => {
+				const deferredRule = getDefferedRule(rule, context, options);
+				laterRulesQueue.defer(deferredRule);
+			});
+			// invoke the later queue
+			laterRulesQueue
+				.then(laterRuleResults => {
+					// remove the cache
+					axe._selectCache = undefined;
+					// resolve
+					resolve(
+						nowRulesResults.concat(laterRuleResults).filter(result => !!result)
+					);
+				})
+				.catch(reject);
+		})
+		.catch(reject);
+};
+
+/**
+ * Runs Rule `after` post processing functions
+ * @param  {Array} results  Array of RuleResults to postprocess
+ * @param  {Mixed} options  Options object to pass into rules and/or disable rules or checks
+ */
+Audit.prototype.after = function(results, options) {
+	'use strict';
+
+	var rules = this.rules;
+
+	return results.map(function(ruleResult) {
+		var rule = axe.utils.findBy(rules, 'id', ruleResult.id);
+		if (!rule) {
+			// If you see this, you're probably running the Mocha tests with the aXe extension installed
+			throw new Error(
+				'Result for unknown rule. You may be running mismatch aXe-core versions'
+			);
+		}
+
+		return rule.after(ruleResult, options);
+	});
+};
+
+/**
+ * Get the rule with a given ID
+ * @param  {string}
+ * @return {Rule}
+ */
+Audit.prototype.getRule = function(ruleId) {
+	return this.rules.find(rule => rule.id === ruleId);
+};
+
+/**
+ * Ensure all rules that are expected to run exist
+ * @throws {Error} If any tag or rule specified in options is unknown
+ * @param  {Object} options  Options object
+ * @return {Object}          Validated options object
+ */
+Audit.prototype.normalizeOptions = function(options) {
+	/* eslint max-statements: ["error", 22] */
+	'use strict';
+	var audit = this;
+
+	// Validate runOnly
+	if (typeof options.runOnly === 'object') {
+		if (Array.isArray(options.runOnly)) {
+			options.runOnly = {
+				type: 'tag',
+				values: options.runOnly
+			};
+		}
+		const only = options.runOnly;
+		if (only.value && !only.values) {
+			only.values = only.value;
+			delete only.value;
+		}
+
+		if (!Array.isArray(only.values) || only.values.length === 0) {
+			throw new Error('runOnly.values must be a non-empty array');
+		}
+
+		// Check if every value in options.runOnly is a known rule ID
+		if (['rule', 'rules'].includes(only.type)) {
+			only.type = 'rule';
+			only.values.forEach(function(ruleId) {
+				if (!audit.getRule(ruleId)) {
+					throw new Error('unknown rule `' + ruleId + '` in options.runOnly');
+				}
+			});
+
+			// Validate 'tags' (e.g. anything not 'rule')
+		} else if (['tag', 'tags', undefined].includes(only.type)) {
+			only.type = 'tag';
+			const unmatchedTags = audit.rules.reduce((unmatchedTags, rule) => {
+				return unmatchedTags.length
+					? unmatchedTags.filter(tag => !rule.tags.includes(tag))
+					: unmatchedTags;
+			}, only.values);
+
+			if (unmatchedTags.length !== 0) {
+				axe.log('Could not find tags `' + unmatchedTags.join('`, `') + '`');
+			}
+		} else {
+			throw new Error(`Unknown runOnly type '${only.type}'`);
+		}
+	}
+
+	if (typeof options.rules === 'object') {
+		Object.keys(options.rules).forEach(function(ruleId) {
+			if (!audit.getRule(ruleId)) {
+				throw new Error('unknown rule `' + ruleId + '` in options.rules');
+			}
+		});
+	}
+
+	return options;
+};
+
+/*
+ * Updates the default options and then applies them
+ * @param  {Mixed} options  Options object
+ */
+
+Audit.prototype.setBranding = function(branding) {
+	'use strict';
+	let previous = {
+		brand: this.brand,
+		application: this.application
+	};
+	if (
+		branding &&
+		branding.hasOwnProperty('brand') &&
+		branding.brand &&
+		typeof branding.brand === 'string'
+	) {
+		this.brand = branding.brand;
+	}
+	if (
+		branding &&
+		branding.hasOwnProperty('application') &&
+		branding.application &&
+		typeof branding.application === 'string'
+	) {
+		this.application = branding.application;
+	}
+	this._constructHelpUrls(previous);
+};
+
+/**
+ * For all the rules, create the helpUrl and add it to the data for that rule
+ */
+function getHelpUrl({ brand, application }, ruleId, version) {
+	return (
+		axe.constants.helpUrlBase +
+		brand +
+		'/' +
+		(version || axe.version.substring(0, axe.version.lastIndexOf('.'))) +
+		'/' +
+		ruleId +
+		'?application=' +
+		application
+	);
+}
+
+Audit.prototype._constructHelpUrls = function(previous = null) {
+	var version = (axe.version.match(/^[1-9][0-9]*\.[0-9]+/) || ['x.y'])[0];
+	this.rules.forEach(rule => {
+		if (!this.data.rules[rule.id]) {
+			this.data.rules[rule.id] = {};
+		}
+		let metaData = this.data.rules[rule.id];
+		if (
+			typeof metaData.helpUrl !== 'string' ||
+			(previous && metaData.helpUrl === getHelpUrl(previous, rule.id, version))
+		) {
+			metaData.helpUrl = getHelpUrl(this, rule.id, version);
+		}
+	});
+};
+
+/**
+ * Reset the default rules, checks and meta data
+ */
+
+Audit.prototype.resetRulesAndChecks = function() {
+	'use strict';
+	this._init();
+	this._resetLocale();
+};