govuk_publishing_components 21.16.3 → 21.17.0

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

@@ -26,13 +26,13 @@ axe.utils.shouldPreload = function shouldPreload(options) {
 /**
  * Constructs a configuration object representing the preload requested assets & timeout
  * @param {Object} options run configuration options (or defaults) passed via axe.run
- * @return {Object}
+ * @return {Object} configuration
  */
 axe.utils.getPreloadConfig = function getPreloadConfig(options) {
-	// default fallback configuration
+	const { assets, timeout } = axe.constants.preload;
 	const config = {
-		assets: axe.constants.preloadAssets,
-		timeout: axe.constants.preloadAssetsTimeout
+		assets,
+		timeout
 	};
 
 	// if no `preload` is configured via `options` - return default config
@@ -47,13 +47,13 @@ axe.utils.getPreloadConfig = function getPreloadConfig(options) {
 
 	// check if requested assets to preload are valid items
 	const areRequestedAssetsValid = options.preload.assets.every(a =>
-		axe.constants.preloadAssets.includes(a.toLowerCase())
+		assets.includes(a.toLowerCase())
 	);
 
 	if (!areRequestedAssetsValid) {
 		throw new Error(
 			`Requested assets, not supported. ` +
-				`Supported assets are: ${axe.constants.preloadAssets.join(', ')}.`
+				`Supported assets are: ${assets.join(', ')}.`
 		);
 	}
 
@@ -74,36 +74,62 @@ axe.utils.getPreloadConfig = function getPreloadConfig(options) {
 };
 
 /**
- * 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.
+ * Returns a Promise with results of all requested preload(able) assets. eg: ['cssom'].
+ *
  * @param {Object} options run configuration options (or defaults) passed via axe.run
- * @return {Object} queue
+ * @return {Object} Promise
  */
 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;
+		return Promise.resolve();
 	}
 
-	const preloadConfig = axe.utils.getPreloadConfig(options);
+	return new Promise((resolve, reject) => {
+		const { assets, timeout } = axe.utils.getPreloadConfig(options);
+
+		/**
+		 * Start `timeout` timer for preloading assets
+		 * -> reject if allowed time expires.
+		 */
+		setTimeout(() => reject(`Preload assets timed out.`), timeout);
+
+		/**
+		 * Fetch requested `assets`
+		 */
 
-	preloadConfig.assets.forEach(asset => {
-		q.defer((resolve, reject) => {
-			preloadFunctionsMap[asset](preloadConfig)
-				.then(results => {
-					resolve({
-						[asset]: results[0]
-					});
+		Promise.all(
+			assets.map(asset =>
+				preloadFunctionsMap[asset](options).then(results => {
+					return {
+						[asset]: results
+					};
 				})
-				.catch(reject);
+			)
+		).then(results => {
+			/**
+			 * Combine array of results into an object map
+			 *
+			 * From ->
+			 * 	[{cssom: [...], aom: [...]}]
+			 * To ->
+			 * 	{
+			 * 		cssom: [...]
+			 * 	 	aom: [...]
+			 * 	}
+			 */
+			const preloadAssets = results.reduce((out, result) => {
+				return {
+					...out,
+					...result
+				};
+			}, {});
+
+			resolve(preloadAssets);
 		});
 	});
-
-	return q;
 };

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

@@ -4,50 +4,42 @@ var matchExpressions = function() {};
 
 // todo: implement an option to follow aria-owns
 
-function matchesTag(node, exp) {
+function matchesTag(vNode, exp) {
 	return (
-		node.nodeType === 1 &&
-		(exp.tag === '*' || node.nodeName.toLowerCase() === exp.tag)
+		vNode.props.nodeType === 1 &&
+		(exp.tag === '*' || vNode.props.nodeName === 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 matchesClasses(vNode, exp) {
+	return !exp.classes || exp.classes.every(cl => vNode.hasClass(cl.value));
 }
 
-function matchesAttributes(node, exp) {
+function matchesAttributes(vNode, 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)
+		exp.attributes.every(att => {
+			var nodeAtt = vNode.attr(att.key);
+			return nodeAtt !== null && (!att.value || att.test(nodeAtt));
+		})
 	);
 }
 
-function matchesId(node, exp) {
-	return !exp.id || node.id === exp.id;
+function matchesId(vNode, exp) {
+	return !exp.id || vNode.props.id === exp.id;
 }
 
 function matchesPseudos(target, exp) {
 	if (
 		!exp.pseudos ||
-		exp.pseudos.reduce((result, pseudo) => {
+		exp.pseudos.every(pseudo => {
 			if (pseudo.name === 'not') {
-				return (
-					result &&
-					!matchExpressions([target], pseudo.expressions, false).length
-				);
+				return !matchExpressions([target], pseudo.expressions, false).length;
 			}
 			throw new Error(
 				'the pseudo selector ' + pseudo.name + ' has not yet been implemented'
 			);
-		}, true)
+		})
 	) {
 		return true;
 	}
@@ -66,13 +58,11 @@ var escapeRegExp = (function() {
 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;
@@ -154,7 +144,7 @@ function convertPseudos(pseudos) {
 		var expressions;
 
 		if (p.name === 'not') {
-			expressions = axe.utils.cssParser.parse(p.value);
+			expressions = p.value;
 			expressions = expressions.selectors
 				? expressions.selectors
 				: [expressions];
@@ -196,41 +186,40 @@ convertExpressions = function(expressions) {
 	});
 };
 
-function createLocalVariables(nodes, anyLevel, thisLevel, parentShadowId) {
+function createLocalVariables(vNodes, anyLevel, thisLevel, parentShadowId) {
 	let retVal = {
-		nodes: nodes.slice(),
+		vNodes: vNodes.slice(),
 		anyLevel: anyLevel,
 		thisLevel: thisLevel,
 		parentShadowId: parentShadowId
 	};
-	retVal.nodes.reverse();
+	retVal.vNodes.reverse();
 	return retVal;
 }
 
-function matchesSelector(node, exp) {
+function matchesSelector(vNode, 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])
+		matchesTag(vNode, exp[0]) &&
+		matchesClasses(vNode, exp[0]) &&
+		matchesAttributes(vNode, exp[0]) &&
+		matchesId(vNode, exp[0]) &&
+		matchesPseudos(vNode, 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 vNodes = Array.isArray(domTree) ? domTree : [domTree];
 	let currentLevel = createLocalVariables(
-		nodes,
+		vNodes,
 		expressions,
 		[],
 		domTree[0].shadowId
 	);
 	let result = [];
 
-	while (currentLevel.nodes.length) {
-		let node = currentLevel.nodes.pop();
+	while (currentLevel.vNodes.length) {
+		let vNode = currentLevel.vNodes.pop();
 		let childOnly = []; // we will add hierarchical '>' selectors here
 		let childAny = [];
 		let combined = currentLevel.anyLevel.slice().concat(currentLevel.thisLevel);
@@ -239,12 +228,12 @@ matchExpressions = function(domTree, expressions, recurse, filter) {
 		for (let i = 0; i < combined.length; i++) {
 			let exp = combined[i];
 			if (
-				matchesSelector(node, exp) &&
-				(!exp[0].id || node.shadowId === currentLevel.parentShadowId)
+				(!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
+				matchesSelector(vNode, exp)
 			) {
 				if (exp.length === 1) {
-					if (!added && (!filter || filter(node))) {
-						result.push(node);
+					if (!added && (!filter || filter(vNode))) {
+						result.push(vNode);
 						added = true;
 					}
 				} else {
@@ -265,24 +254,24 @@ matchExpressions = function(domTree, expressions, recurse, filter) {
 				}
 			}
 			if (
-				currentLevel.anyLevel.includes(exp) &&
-				(!exp[0].id || node.shadowId === currentLevel.parentShadowId)
+				(!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
+				currentLevel.anyLevel.includes(exp)
 			) {
 				childAny.push(exp);
 			}
 		}
 		// "recurse"
-		if (node.children && node.children.length && recurse) {
+		if (vNode.children && vNode.children.length && recurse) {
 			stack.push(currentLevel);
 			currentLevel = createLocalVariables(
-				node.children,
+				vNode.children,
 				childAny,
 				childOnly,
-				node.shadowId
+				vNode.shadowId
 			);
 		}
 		// check for "return"
-		while (!currentLevel.nodes.length && stack.length) {
+		while (!currentLevel.vNodes.length && stack.length) {
 			currentLevel = stack.pop();
 		}
 	}

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

@@ -13,7 +13,7 @@
 		]);
 
 	/**
-	 * get the unique string to be used to identify our instance of aXe
+	 * get the unique string to be used to identify our instance of axe
 	 * @private
 	 */
 	function _getSource() {
@@ -86,6 +86,12 @@
 			_keepalive: keepalive
 		};
 
+		var axeRespondables = axe._cache.get('axeRespondables');
+		if (!axeRespondables) {
+			axeRespondables = {};
+			axe._cache.set('axeRespondables', axeRespondables);
+		}
+		axeRespondables[uuid] = true;
 		if (typeof callback === 'function') {
 			messages[uuid] = callback;
 		}
@@ -206,7 +212,6 @@
 		window.addEventListener(
 			'message',
 			function(e) {
-				/* eslint max-statements: ["error", 20]*/
 				var data = parseMessage(e.data);
 				if (!data) {
 					return;
@@ -214,6 +219,18 @@
 
 				var uuid = data.uuid;
 
+				/**
+				 * NOTE: messages from other contexts (frames) in response
+				 * to a message should not contain a topic. We ignore these
+				 * messages to prevent rogue postMessage handlers reflecting
+				 * our messages.
+				 * @see https://github.com/dequelabs/axe-core/issues/1754
+				 */
+				var axeRespondables = axe._cache.get('axeRespondables') || {};
+				if (axeRespondables[uuid] && data.topic && e.source !== window) {
+					return;
+				}
+
 				var keepalive = data._keepalive;
 				var callback = messages[uuid];
 
@@ -231,7 +248,7 @@
 					try {
 						publish(e.source, data, keepalive);
 					} catch (err) {
-						post(e.source, data.topic, err, uuid, false);
+						post(e.source, null, err, uuid, false);
 					}
 				}
 			},

data/node_modules/axe-core/lib/core/utils/rule-should-run.js

@@ -5,7 +5,6 @@
  * @param  {object}	runOnly Value of runOnly with type=tags
  * @return {bool}
  */
-/* eslint complexity: ["error", 14]*/
 function matchTags(rule, runOnly) {
 	'use strict';
 	var include, exclude, matching;

data/node_modules/axe-core/lib/core/utils/scroll-state.js

@@ -1,26 +1,9 @@
-/**
- * Return the scroll position of scrollable elements
- */
-function getScroll(elm) {
-	const style = window.getComputedStyle(elm);
-	const visibleOverflowY = style.getPropertyValue('overflow-y') === 'visible';
-	const visibleOverflowX = style.getPropertyValue('overflow-x') === 'visible';
-
-	if (
-		// See if the element hides overflowing content
-		(!visibleOverflowY && elm.scrollHeight > elm.clientHeight) ||
-		(!visibleOverflowX && elm.scrollWidth > elm.clientWidth)
-	) {
-		return { elm, top: elm.scrollTop, left: elm.scrollLeft };
-	}
-}
-
 /**
  * set the scroll position of an element
  */
 function setScroll(elm, top, left) {
 	if (elm === window) {
-		return elm.scroll(top, left);
+		return elm.scroll(left, top);
 	} else {
 		elm.scrollTop = top;
 		elm.scrollLeft = left;
@@ -31,13 +14,17 @@ function setScroll(elm, top, left) {
  * Create an array scroll positions from descending elements
  */
 function getElmScrollRecursive(root) {
-	return Array.from(root.children).reduce((scrolls, elm) => {
-		const scroll = getScroll(elm);
-		if (scroll) {
-			scrolls.push(scroll);
-		}
-		return scrolls.concat(getElmScrollRecursive(elm));
-	}, []);
+	// Need to also get .childNodes since SVGs in IE don't have .children.
+	return Array.from(root.children || root.childNodes || []).reduce(
+		(scrolls, elm) => {
+			const scroll = axe.utils.getScroll(elm);
+			if (scroll) {
+				scrolls.push(scroll);
+			}
+			return scrolls.concat(getElmScrollRecursive(elm));
+		},
+		[]
+	);
 }
 
 /**

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

@@ -25,14 +25,14 @@ function getDeepest(collection) {
 function isNodeInContext(node, context) {
 	'use strict';
 
-	var include =
+	const include =
 		context.include &&
 		getDeepest(
 			context.include.filter(function(candidate) {
 				return axe.utils.contains(candidate, node);
 			})
 		);
-	var exclude =
+	const exclude =
 		context.exclude &&
 		getDeepest(
 			context.exclude.filter(function(candidate) {
@@ -58,7 +58,7 @@ function isNodeInContext(node, context) {
 function pushNode(result, nodes) {
 	'use strict';
 
-	var temp;
+	let temp;
 
 	if (result.length === 0) {
 		return nodes;
@@ -69,7 +69,7 @@ function pushNode(result, nodes) {
 		result = nodes;
 		nodes = temp;
 	}
-	for (var i = 0, l = nodes.length; i < l; i++) {
+	for (let i = 0, l = nodes.length; i < l; i++) {
 		if (!result.includes(nodes[i])) {
 			result.push(nodes[i]);
 		}
@@ -84,10 +84,7 @@ function pushNode(result, nodes) {
  */
 function reduceIncludes(includes) {
 	return includes.reduce((res, el) => {
-		if (
-			!res.length ||
-			!res[res.length - 1].actualNode.contains(el.actualNode)
-		) {
+		if (!res.length || !axe.utils.contains(res[res.length - 1], el)) {
 			res.push(el);
 		}
 		return res;
@@ -100,37 +97,29 @@ function reduceIncludes(includes) {
  * @param  {Context} context  The "resolved" context object, @see Context
  * @return {Array}            Matching virtual DOM nodes sorted by DOM order
  */
-/*eslint max-statements:["error", 20]*/
 axe.utils.select = function select(selector, context) {
 	'use strict';
 
-	var result = [],
-		candidate;
+	let result = [];
+	let candidate;
 	if (axe._selectCache) {
 		// if used outside of run, it will still work
-		for (var j = 0, l = axe._selectCache.length; j < l; j++) {
+		for (let j = 0, l = axe._selectCache.length; j < l; j++) {
 			// First see whether the item exists in the cache
-			let item = axe._selectCache[j];
+			const item = axe._selectCache[j];
 			if (item.selector === selector) {
 				return item.result;
 			}
 		}
 	}
-	var curried = (function(context) {
+	const curried = (function(context) {
 		return function(node) {
 			return isNodeInContext(node, context);
 		};
 	})(context);
-	var reducedIncludes = reduceIncludes(context.include);
-	for (var i = 0; i < reducedIncludes.length; i++) {
+	const reducedIncludes = reduceIncludes(context.include);
+	for (let i = 0; i < reducedIncludes.length; i++) {
 		candidate = reducedIncludes[i];
-		if (
-			candidate.actualNode.nodeType === candidate.actualNode.ELEMENT_NODE &&
-			axe.utils.matchesSelector(candidate.actualNode, selector) &&
-			curried(candidate)
-		) {
-			result = pushNode(result, [candidate]);
-		}
 		result = pushNode(
 			result,
 			axe.utils.querySelectorAllFilter(candidate, selector, curried)