govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/core/utils/preload.js

@@ -0,0 +1,109 @@
+/**
+ * Validated the preload object
+ * @param {Object | boolean} preload configuration object or boolean passed via the options parameter to axe.run
+ * @return {boolean}
+ * @private
+ */
+function isValidPreloadObject(preload) {
+	return typeof preload === 'object' && Array.isArray(preload.assets);
+}
+
+/**
+ * Returns a boolean which decides if preload is configured
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {boolean} defaults to true
+ */
+axe.utils.shouldPreload = function shouldPreload(options) {
+	if (!options || options.preload === undefined || options.preload === null) {
+		return true; // by default `preload` requested assets eg: ['cssom']
+	}
+	if (typeof options.preload === 'boolean') {
+		return options.preload;
+	}
+	return isValidPreloadObject(options.preload);
+};
+
+/**
+ * Constructs a configuration object representing the preload requested assets & timeout
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {Object}
+ */
+axe.utils.getPreloadConfig = function getPreloadConfig(options) {
+	// default fallback configuration
+	const config = {
+		assets: axe.constants.preloadAssets,
+		timeout: axe.constants.preloadAssetsTimeout
+	};
+
+	// if no `preload` is configured via `options` - return default config
+	if (!options.preload) {
+		return config;
+	}
+
+	// if type is boolean
+	if (typeof options.preload === 'boolean') {
+		return config;
+	}
+
+	// check if requested assets to preload are valid items
+	const areRequestedAssetsValid = options.preload.assets.every(a =>
+		axe.constants.preloadAssets.includes(a.toLowerCase())
+	);
+
+	if (!areRequestedAssetsValid) {
+		throw new Error(
+			`Requested assets, not supported. ` +
+				`Supported assets are: ${axe.constants.preloadAssets.join(', ')}.`
+		);
+	}
+
+	// unique assets to load, in case user had requested same asset type many times.
+	config.assets = axe.utils.uniqueArray(
+		options.preload.assets.map(a => a.toLowerCase()),
+		[]
+	);
+
+	if (
+		options.preload.timeout &&
+		typeof options.preload.timeout === 'number' &&
+		!Number.isNaN(options.preload.timeout)
+	) {
+		config.timeout = options.preload.timeout;
+	}
+	return config;
+};
+
+/**
+ * Returns a then(able) queue with results of all requested preload(able) assets. Eg: ['cssom'].
+ * If preload is set to false, returns an empty queue.
+ * @param {Object} options run configuration options (or defaults) passed via axe.run
+ * @return {Object} queue
+ */
+axe.utils.preload = function preload(options) {
+	const preloadFunctionsMap = {
+		cssom: axe.utils.preloadCssom
+	};
+
+	const q = axe.utils.queue();
+
+	const shouldPreload = axe.utils.shouldPreload(options);
+	if (!shouldPreload) {
+		return q;
+	}
+
+	const preloadConfig = axe.utils.getPreloadConfig(options);
+
+	preloadConfig.assets.forEach(asset => {
+		q.defer((resolve, reject) => {
+			preloadFunctionsMap[asset](preloadConfig)
+				.then(results => {
+					resolve({
+						[asset]: results[0]
+					});
+				})
+				.catch(reject);
+		});
+	});
+
+	return q;
+};

data/node_modules/axe-core/lib/core/utils/publish-metadata.js

@@ -0,0 +1,93 @@
+/*global helpers */
+/**
+ * Construct incomplete message from check.data
+ * @param  {Object} checkData Check result with reason specified
+ * @param  {Object} messages Source data object with message options
+ * @return  {String}
+ * @private
+ */
+function getIncompleteReason(checkData, messages) {
+	function getDefaultMsg(messages) {
+		if (messages.incomplete && messages.incomplete.default) {
+			// fall back to the default message if no reason specified
+			return messages.incomplete.default;
+		} else {
+			return helpers.incompleteFallbackMessage();
+		}
+	}
+	if (checkData && checkData.missingData) {
+		try {
+			var msg = messages.incomplete[checkData.missingData[0].reason];
+			if (!msg) {
+				throw new Error();
+			}
+			return msg;
+		} catch (e) {
+			if (typeof checkData.missingData === 'string') {
+				// return a string with the appropriate reason
+				return messages.incomplete[checkData.missingData];
+			} else {
+				return getDefaultMsg(messages);
+			}
+		}
+	} else {
+		return getDefaultMsg(messages);
+	}
+}
+/**
+ * Extend checksData with the correct result message
+ * @param  {Object} checksData The check result data
+ * @param  {Boolean} shouldBeTrue Result of pass/fail check run
+ * @return {Function}
+ * @private
+ */
+function extender(checksData, shouldBeTrue) {
+	'use strict';
+	return function(check) {
+		var sourceData = checksData[check.id] || {};
+		var messages = sourceData.messages || {};
+		var data = Object.assign({}, sourceData);
+		delete data.messages;
+		if (check.result === undefined) {
+			if (typeof messages.incomplete === 'object') {
+				data.message = function() {
+					return getIncompleteReason(check.data, messages);
+				};
+			} else {
+				// fall back to string function
+				data.message = messages.incomplete;
+			}
+		} else {
+			data.message =
+				check.result === shouldBeTrue ? messages.pass : messages.fail;
+		}
+		axe.utils.extendMetaData(check, data);
+	};
+}
+
+/**
+ * Publish metadata from axe._audit.data
+ * @param  {RuleResult} result Result to publish to
+ * @private
+ */
+axe.utils.publishMetaData = function(ruleResult) {
+	'use strict';
+
+	var checksData = axe._audit.data.checks || {};
+	var rulesData = axe._audit.data.rules || {};
+	var rule = axe.utils.findBy(axe._audit.rules, 'id', ruleResult.id) || {};
+
+	ruleResult.tags = axe.utils.clone(rule.tags || []);
+
+	var shouldBeTrue = extender(checksData, true);
+	var shouldBeFalse = extender(checksData, false);
+	ruleResult.nodes.forEach(function(detail) {
+		detail.any.forEach(shouldBeTrue);
+		detail.all.forEach(shouldBeTrue);
+		detail.none.forEach(shouldBeFalse);
+	});
+	axe.utils.extendMetaData(
+		ruleResult,
+		axe.utils.clone(rulesData[ruleResult.id] || {})
+	);
+};

data/node_modules/axe-core/lib/core/utils/qsa.js

@@ -0,0 +1,322 @@
+// The lines below is because the latedef option does not work
+var convertExpressions = function() {};
+var matchExpressions = function() {};
+
+// todo: implement an option to follow aria-owns
+
+function matchesTag(node, exp) {
+	return (
+		node.nodeType === 1 &&
+		(exp.tag === '*' || node.nodeName.toLowerCase() === exp.tag)
+	);
+}
+
+function matchesClasses(node, exp) {
+	return (
+		!exp.classes ||
+		exp.classes.reduce((result, cl) => {
+			return result && (node.className && node.className.match(cl.regexp));
+		}, true)
+	);
+}
+
+function matchesAttributes(node, exp) {
+	return (
+		!exp.attributes ||
+		exp.attributes.reduce((result, att) => {
+			var nodeAtt = node.getAttribute(att.key);
+			return result && nodeAtt !== null && (!att.value || att.test(nodeAtt));
+		}, true)
+	);
+}
+
+function matchesId(node, exp) {
+	return !exp.id || node.id === exp.id;
+}
+
+function matchesPseudos(target, exp) {
+	if (
+		!exp.pseudos ||
+		exp.pseudos.reduce((result, pseudo) => {
+			if (pseudo.name === 'not') {
+				return (
+					result &&
+					!matchExpressions([target], pseudo.expressions, false).length
+				);
+			}
+			throw new Error(
+				'the pseudo selector ' + pseudo.name + ' has not yet been implemented'
+			);
+		}, true)
+	) {
+		return true;
+	}
+	return false;
+}
+
+var escapeRegExp = (function() {
+	/*! Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License */
+	var from = /(?=[\-\[\]{}()*+?.\\\^$|,#\s])/g;
+	var to = '\\';
+	return function(string) {
+		return string.replace(from, to);
+	};
+})();
+
+var reUnescape = /\\/g;
+
+function convertAttributes(atts) {
+	/*eslint indent:0*/
+	/*! Credit Mootools Copyright Mootools, MIT License */
+	if (!atts) {
+		return;
+	}
+	return atts.map(att => {
+		// eslint complexity:["error", 13]
+		var attributeKey = att.name.replace(reUnescape, '');
+		var attributeValue = (att.value || '').replace(reUnescape, '');
+		var test, regexp;
+
+		switch (att.operator) {
+			case '^=':
+				regexp = new RegExp('^' + escapeRegExp(attributeValue));
+				break;
+			case '$=':
+				regexp = new RegExp(escapeRegExp(attributeValue) + '$');
+				break;
+			case '~=':
+				regexp = new RegExp(
+					'(^|\\s)' + escapeRegExp(attributeValue) + '(\\s|$)'
+				);
+				break;
+			case '|=':
+				regexp = new RegExp('^' + escapeRegExp(attributeValue) + '(-|$)');
+				break;
+			case '=':
+				test = function(value) {
+					return attributeValue === value;
+				};
+				break;
+			case '*=':
+				test = function(value) {
+					return value && value.includes(attributeValue);
+				};
+				break;
+			case '!=':
+				test = function(value) {
+					return attributeValue !== value;
+				};
+				break;
+			default:
+				test = function(value) {
+					return !!value;
+				};
+		}
+
+		if (attributeValue === '' && /^[*$^]=$/.test(att.operator)) {
+			test = function() {
+				return false;
+			};
+		}
+
+		if (!test) {
+			test = function(value) {
+				return value && regexp.test(value);
+			};
+		}
+		return {
+			key: attributeKey,
+			value: attributeValue,
+			test: test
+		};
+	});
+}
+
+function convertClasses(classes) {
+	if (!classes) {
+		return;
+	}
+	return classes.map(className => {
+		className = className.replace(reUnescape, '');
+
+		return {
+			value: className,
+			regexp: new RegExp('(^|\\s)' + escapeRegExp(className) + '(\\s|$)')
+		};
+	});
+}
+
+function convertPseudos(pseudos) {
+	if (!pseudos) {
+		return;
+	}
+	return pseudos.map(p => {
+		var expressions;
+
+		if (p.name === 'not') {
+			expressions = axe.utils.cssParser.parse(p.value);
+			expressions = expressions.selectors
+				? expressions.selectors
+				: [expressions];
+			expressions = convertExpressions(expressions);
+		}
+		return {
+			name: p.name,
+			expressions: expressions,
+			value: p.value
+		};
+	});
+}
+
+/**
+ * convert the css-selector-parser format into the Slick format
+ * @private
+ * @param Array {Object} expressions
+ * @return Array {Object}
+ *
+ */
+convertExpressions = function(expressions) {
+	return expressions.map(exp => {
+		var newExp = [];
+		var rule = exp.rule;
+		while (rule) {
+			/* eslint no-restricted-syntax: 0 */
+			// `.tagName` is a property coming from the `CSSSelectorParser` library
+			newExp.push({
+				tag: rule.tagName ? rule.tagName.toLowerCase() : '*',
+				combinator: rule.nestingOperator ? rule.nestingOperator : ' ',
+				id: rule.id,
+				attributes: convertAttributes(rule.attrs),
+				classes: convertClasses(rule.classNames),
+				pseudos: convertPseudos(rule.pseudos)
+			});
+			rule = rule.rule;
+		}
+		return newExp;
+	});
+};
+
+function createLocalVariables(nodes, anyLevel, thisLevel, parentShadowId) {
+	let retVal = {
+		nodes: nodes.slice(),
+		anyLevel: anyLevel,
+		thisLevel: thisLevel,
+		parentShadowId: parentShadowId
+	};
+	retVal.nodes.reverse();
+	return retVal;
+}
+
+function matchesSelector(node, exp) {
+	return (
+		matchesTag(node.actualNode, exp[0]) &&
+		matchesClasses(node.actualNode, exp[0]) &&
+		matchesAttributes(node.actualNode, exp[0]) &&
+		matchesId(node.actualNode, exp[0]) &&
+		matchesPseudos(node, exp[0])
+	);
+}
+
+matchExpressions = function(domTree, expressions, recurse, filter) {
+	/*eslint max-statements:["error", 34], complexity:["error", 22]*/
+	let stack = [];
+	let nodes = Array.isArray(domTree) ? domTree : [domTree];
+	let currentLevel = createLocalVariables(
+		nodes,
+		expressions,
+		[],
+		domTree[0].shadowId
+	);
+	let result = [];
+
+	while (currentLevel.nodes.length) {
+		let node = currentLevel.nodes.pop();
+		let childOnly = []; // we will add hierarchical '>' selectors here
+		let childAny = [];
+		let combined = currentLevel.anyLevel.slice().concat(currentLevel.thisLevel);
+		let added = false;
+		// see if node matches
+		for (let i = 0; i < combined.length; i++) {
+			let exp = combined[i];
+			if (
+				matchesSelector(node, exp) &&
+				(!exp[0].id || node.shadowId === currentLevel.parentShadowId)
+			) {
+				if (exp.length === 1) {
+					if (!added && (!filter || filter(node))) {
+						result.push(node);
+						added = true;
+					}
+				} else {
+					let rest = exp.slice(1);
+					if ([' ', '>'].includes(rest[0].combinator) === false) {
+						throw new Error(
+							'axe.utils.querySelectorAll does not support the combinator: ' +
+								exp[1].combinator
+						);
+					}
+					if (rest[0].combinator === '>') {
+						// add the rest to the childOnly array
+						childOnly.push(rest);
+					} else {
+						// add the rest to the childAny array
+						childAny.push(rest);
+					}
+				}
+			}
+			if (
+				currentLevel.anyLevel.includes(exp) &&
+				(!exp[0].id || node.shadowId === currentLevel.parentShadowId)
+			) {
+				childAny.push(exp);
+			}
+		}
+		// "recurse"
+		if (node.children && node.children.length && recurse) {
+			stack.push(currentLevel);
+			currentLevel = createLocalVariables(
+				node.children,
+				childAny,
+				childOnly,
+				node.shadowId
+			);
+		}
+		// check for "return"
+		while (!currentLevel.nodes.length && stack.length) {
+			currentLevel = stack.pop();
+		}
+	}
+	return result;
+};
+
+/**
+ * querySelectorAll implementation that operates on the flattened tree (supports shadow DOM)
+ * @method querySelectorAll
+ * @memberof axe.utils
+ * @param	{NodeList} domTree flattened tree collection to search
+ * @param	{String} selector String containing one or more CSS selectors separated by commas
+ * @return {NodeList} Elements matched by any of the selectors
+ */
+axe.utils.querySelectorAll = function(domTree, selector) {
+	return axe.utils.querySelectorAllFilter(domTree, selector);
+};
+
+/**
+ * querySelectorAllFilter implements querySelectorAll on the virtual DOM with
+ * ability to filter the returned nodes using an optional supplied filter function
+ *
+ * @method querySelectorAllFilter
+ * @memberof axe.utils
+ * @param	{NodeList} domTree flattened tree collection to search
+ * @param	{String} selector String containing one or more CSS selectors separated by commas
+ * @param	{Function} filter function (optional)
+ * @return {Array} Elements matched by any of the selectors and filtered by the filter function
+ */
+
+axe.utils.querySelectorAllFilter = function(domTree, selector, filter) {
+	domTree = Array.isArray(domTree) ? domTree : [domTree];
+	var expressions = axe.utils.cssParser.parse(selector);
+	expressions = expressions.selectors ? expressions.selectors : [expressions];
+	expressions = convertExpressions(expressions);
+	return matchExpressions(domTree, expressions, true, filter);
+};