govuk_publishing_components 21.16.3 → 21.17.0

data/node_modules/axe-core/lib/core/utils/css-parser.js

@@ -1,5 +1,7 @@
 (function(axe) {
 	var parser = new axe.imports.CssSelectorParser();
+	parser.registerSelectorPseudos('not');
 	parser.registerNestingOperators('>');
+	parser.registerAttrEqualityMods('^', '$', '*');
 	axe.utils.cssParser = parser;
 })(axe);

data/node_modules/axe-core/lib/core/utils/element-matches.js

@@ -34,6 +34,10 @@ axe.utils.matchesSelector = (function() {
 			method = getMethod(node);
 		}
 
-		return node[method](selector);
+		if (node[method]) {
+			return node[method](selector);
+		}
+
+		return false;
 	};
 })();

data/node_modules/axe-core/lib/core/utils/escape-selector.js

@@ -7,8 +7,7 @@
  */
 axe.utils.escapeSelector = function(value) {
 	'use strict';
-	/*eslint no-bitwise: 0, eqeqeq: 0, complexity: ["error",27],
-	max-statements:["error", 25], one-var: 0, -W041: 0 */
+	/*eslint no-bitwise: 0, eqeqeq: 0, one-var: 0 */
 	var string = String(value);
 	var length = string.length;
 	var index = -1;

data/node_modules/axe-core/lib/core/utils/flattened-tree.js

@@ -1,3 +1,4 @@
+/* global VirtualNode */
 /*eslint no-use-before-define: 0*/
 var axe = axe || { utils: {} };
 
@@ -19,36 +20,6 @@ var axe = axe || { utils: {} };
  *    the spec for this)
  */
 
-/**
- * Wrap the real node and provide list of the flattened children
- *
- * @param node {Node} - the node in question
- * @param shadowId {String} - the ID of the shadow DOM to which this node belongs
- * @return {Object} - the wrapped node
- */
-function virtualDOMfromNode(node, shadowId) {
-	const vNodeCache = {};
-	return {
-		shadowId: shadowId,
-		children: [],
-		actualNode: node,
-		get isFocusable() {
-			if (!vNodeCache._isFocusable) {
-				vNodeCache._isFocusable = axe.commons.dom.isFocusable(node);
-			}
-			return vNodeCache._isFocusable;
-		},
-		get tabbableElements() {
-			if (!vNodeCache._tabbableElements) {
-				vNodeCache._tabbableElements = axe.commons.dom.getTabbableElements(
-					this
-				);
-			}
-			return vNodeCache._tabbableElements;
-		}
-	};
-}
-
 /**
  * find all the fallback content for a <slot> and return these as an array
  * this array will also include any #text nodes
@@ -74,13 +45,13 @@ function getSlotChildren(node) {
  * @param {Node} node the current node
  * @param {String} shadowId, optional ID of the shadow DOM that is the closest shadow
  *                           ancestor of the node
+ * @param {VirtualNode} parent the parent VirtualNode
  */
-axe.utils.getFlattenedTree = function(node, shadowId) {
+function flattenTree(node, shadowId, parent) {
 	// using a closure here and therefore cannot easily refactor toreduce the statements
-	/*eslint max-statements: ["error", 31] */
 	var retVal, realArray, nodeName;
-	function reduceShadowDOM(res, child) {
-		var replacements = axe.utils.getFlattenedTree(child, shadowId);
+	function reduceShadowDOM(res, child, parent) {
+		var replacements = flattenTree(child, shadowId, parent);
 		if (replacements) {
 			res = res.concat(replacements);
 		}
@@ -96,19 +67,27 @@ axe.utils.getFlattenedTree = function(node, shadowId) {
 	if (axe.utils.isShadowRoot(node)) {
 		// generate an ID for this shadow root and overwrite the current
 		// closure shadowId with this value so that it cascades down the tree
-		retVal = virtualDOMfromNode(node, shadowId);
+		retVal = new VirtualNode(node, parent, shadowId);
 		shadowId =
 			'a' +
 			Math.random()
 				.toString()
 				.substring(2);
 		realArray = Array.from(node.shadowRoot.childNodes);
-		retVal.children = realArray.reduce(reduceShadowDOM, []);
+		retVal.children = realArray.reduce((res, child) => {
+			return reduceShadowDOM(res, child, retVal);
+		}, []);
+
 		return [retVal];
 	} else {
-		if (nodeName === 'content') {
+		if (
+			nodeName === 'content' &&
+			typeof node.getDistributedNodes === 'function'
+		) {
 			realArray = Array.from(node.getDistributedNodes());
-			return realArray.reduce(reduceShadowDOM, []);
+			return realArray.reduce((res, child) => {
+				return reduceShadowDOM(res, child, parent);
+			}, []);
 		} else if (
 			nodeName === 'slot' &&
 			typeof node.assignedNodes === 'function'
@@ -123,48 +102,55 @@ axe.utils.getFlattenedTree = function(node, shadowId) {
 			if (false && styl.display !== 'contents') {
 				// intentionally commented out
 				// has a box
-				retVal = virtualDOMfromNode(node, shadowId);
-				retVal.children = realArray.reduce(reduceShadowDOM, []);
+				retVal = new VirtualNode(node, parent, shadowId);
+				retVal.children = realArray.reduce((res, child) => {
+					return reduceShadowDOM(res, child, retVal);
+				}, []);
+
 				return [retVal];
 			} else {
-				return realArray.reduce(reduceShadowDOM, []);
+				return realArray.reduce((res, child) => {
+					return reduceShadowDOM(res, child, parent);
+				}, []);
 			}
 		} else {
 			if (node.nodeType === 1) {
-				retVal = virtualDOMfromNode(node, shadowId);
+				retVal = new VirtualNode(node, parent, shadowId);
 				realArray = Array.from(node.childNodes);
-				retVal.children = realArray.reduce(reduceShadowDOM, []);
+				retVal.children = realArray.reduce((res, child) => {
+					return reduceShadowDOM(res, child, retVal);
+				}, []);
+
 				return [retVal];
 			} else if (node.nodeType === 3) {
 				// text
-				return [virtualDOMfromNode(node)];
+				return [new VirtualNode(node, parent)];
 			}
 			return undefined;
 		}
 	}
+}
+
+/**
+ * Recursvely returns an array of the virtual DOM nodes at this level
+ * excluding comment nodes and the shadow DOM nodes <content> and <slot>
+ *
+ * @param {Node} node the current node
+ * @param {String} shadowId, optional ID of the shadow DOM that is the closest shadow
+ *                           ancestor of the node
+ */
+axe.utils.getFlattenedTree = function(node, shadowId) {
+	axe._cache.set('nodeMap', new WeakMap());
+	return flattenTree(node, shadowId);
 };
 
 /**
- * Recursively return a single node from a virtual dom tree
+ * Return a single node from the virtual dom tree
  *
  * @param {Object} vNode The flattened, virtual DOM tree
  * @param {Node}   node  The HTML DOM node
  */
 axe.utils.getNodeFromTree = function(vNode, node) {
-	var found;
-
-	if (vNode.actualNode === node) {
-		return vNode;
-	}
-	vNode.children.forEach(candidate => {
-		if (found) {
-			return;
-		}
-		if (candidate.actualNode === node) {
-			found = candidate;
-		} else {
-			found = axe.utils.getNodeFromTree(candidate, node);
-		}
-	});
-	return found;
+	const el = node || vNode;
+	return axe._cache.get('nodeMap') ? axe._cache.get('nodeMap').get(el) : null;
 };

data/node_modules/axe-core/lib/core/utils/get-check-option.js

@@ -1,4 +1,3 @@
-/*eslint complexity: ["error", 12]*/
 /**
  * Determines which CheckOption to use, either defined on the rule options, global check options or the check itself
  * @param  {Check} check    The Check object

data/node_modules/axe-core/lib/core/utils/get-friendly-uri-end.js

@@ -1,4 +1,4 @@
-/* eslint max-statements:["error",18], complexity:["error",27], no-script-url:0 */
+/* eslint no-script-url:0 */
 /**
  * Check if a string contains mostly numbers
  */

data/node_modules/axe-core/lib/core/utils/get-node-attributes.js

@@ -0,0 +1,21 @@
+/* global axe */
+
+/**
+ * Return the list of attributes of a node.
+ * @method getNodeAttributes
+ * @memberof axe.utils
+ * @param {Element} node
+ * @returns {NamedNodeMap}
+ */
+axe.utils.getNodeAttributes = function getNodeAttributes(node) {
+	// eslint-disable-next-line no-restricted-syntax
+	if (node.attributes instanceof window.NamedNodeMap) {
+		// eslint-disable-next-line no-restricted-syntax
+		return node.attributes;
+	}
+
+	// if the attributes property is not of type NamedNodeMap then the DOM
+	// has been clobbered. E.g. <form><input name="attributes"></form>.
+	// We can clone the node to isolate it and then return the attributes
+	return node.cloneNode(false).attributes;
+};

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

@@ -0,0 +1,39 @@
+/**
+ * Get the scroll position of given element
+ * @method getScroll
+ * @memberof axe.utils
+ * @param {Element} node
+ * @param {buffer} (Optional) allowed negligence in overflow
+ * @returns {Object | undefined}
+ */
+axe.utils.getScroll = function getScroll(elm, buffer = 0) {
+	const overflowX = elm.scrollWidth > elm.clientWidth + buffer;
+	const overflowY = elm.scrollHeight > elm.clientHeight + buffer;
+
+	/**
+	 * if there is neither `overflow-x` or `overflow-y`
+	 * -> return
+	 */
+	if (!(overflowX || overflowY)) {
+		return;
+	}
+
+	const style = window.getComputedStyle(elm);
+	const overflowXStyle = style.getPropertyValue('overflow-x');
+	const overflowYStyle = style.getPropertyValue('overflow-y');
+	const scrollableX =
+		overflowXStyle !== 'visible' && overflowXStyle !== 'hidden';
+	const scrollableY =
+		overflowYStyle !== 'visible' && overflowYStyle !== 'hidden';
+
+	/**
+	 * check direction of `overflow` and `scrollable`
+	 */
+	if ((overflowX && scrollableX) || (overflowY && scrollableY)) {
+		return {
+			elm,
+			top: elm.scrollTop,
+			left: elm.scrollLeft
+		};
+	}
+};

data/node_modules/axe-core/lib/core/utils/get-selector.js

@@ -79,7 +79,7 @@ function filterAttributes(at) {
  *														the counts for how many elements with that feature exist
  */
 axe.utils.getSelectorData = function(domTree) {
-	/* eslint max-statements:["error", 22], no-loop-func:0*/
+	/* eslint no-loop-func:0*/
 
 	// Initialize the return structure with the three maps
 	let data = {
@@ -119,8 +119,8 @@ axe.utils.getSelectorData = function(domTree) {
 			}
 
 			// count all the filtered attributes
-			if (node.attributes) {
-				Array.from(node.attributes)
+			if (node.hasAttributes()) {
+				Array.from(axe.utils.getNodeAttributes(node))
 					.filter(filterAttributes)
 					.forEach(at => {
 						let atnv = getAttributeNameValue(node, at);
@@ -238,8 +238,8 @@ function uncommonAttributes(node, selectorData) {
 	let attData = selectorData.attributes;
 	let tagData = selectorData.tags;
 
-	if (node.attributes) {
-		Array.from(node.attributes)
+	if (node.hasAttributes()) {
+		Array.from(axe.utils.getNodeAttributes(node))
 			.filter(filterAttributes)
 			.forEach(at => {
 				const atnv = getAttributeNameValue(node, at);
@@ -334,7 +334,7 @@ function getThreeLeastCommonFeatures(elm, selectorData) {
  */
 
 function generateSelector(elm, options, doc) {
-	/*eslint max-statements:["error", 22], no-loop-func:0*/
+	/*eslint no-loop-func:0*/
 	if (!axe._selectorData) {
 		throw new Error('Expect axe._selectorData to be set up');
 	}
@@ -392,6 +392,9 @@ axe.utils.getSelector = function createUniqueSelector(elm, options = {}) {
 		// DOCUMENT_FRAGMENT
 		let stack = [];
 		while (doc.nodeType === 11) {
+			if (!doc.host) {
+				return '';
+			}
 			stack.push({ elm: elm, doc: doc });
 			elm = doc.host;
 			doc = elm.getRootNode();

data/node_modules/axe-core/lib/core/utils/get-stylesheet-factory.js

@@ -0,0 +1,51 @@
+/**
+ * Function which converts given text to `CSSStyleSheet`
+ * - used in `CSSOM` computation.
+ * - factory (closure) function, initialized with `document.implementation.createHTMLDocument()`, which uses DOM API for creating `style` elements.
+ *
+ * @method axe.utils.getStyleSheetFactory
+ * @memberof axe.utils
+ * @param {Object} dynamicDoc `document.implementation.createHTMLDocument()
+ * @param {Object} options an object with properties to construct stylesheet
+ * @property {String} options.data text content of the stylesheet
+ * @property {Boolean} options.isCrossOrigin flag to notify if the resource was fetched from the network
+ * @property {String} options.shadowId (Optional) shadowId if shadowDOM
+ * @property {Object} options.root implementation document to create style elements
+ * @property {String} options.priority a number indicating the loaded priority of CSS, to denote specificity of styles contained in the sheet.
+ * @returns {Function}
+ */
+axe.utils.getStyleSheetFactory = function getStyleSheetFactory(dynamicDoc) {
+	if (!dynamicDoc) {
+		throw new Error(
+			'axe.utils.getStyleSheetFactory should be invoked with an argument'
+		);
+	}
+
+	return options => {
+		const {
+			data,
+			isCrossOrigin = false,
+			shadowId,
+			root,
+			priority,
+			isLink = false
+		} = options;
+		const style = dynamicDoc.createElement('style');
+		if (isLink) {
+			// as creating a stylesheet as link will need to be awaited
+			// till `onload`, it is wise to convert link href to @import statement
+			const text = dynamicDoc.createTextNode(`@import "${data.href}"`);
+			style.appendChild(text);
+		} else {
+			style.appendChild(dynamicDoc.createTextNode(data));
+		}
+		dynamicDoc.head.appendChild(style);
+		return {
+			sheet: style.sheet,
+			isCrossOrigin,
+			shadowId,
+			root,
+			priority
+		};
+	};
+};

data/node_modules/axe-core/lib/core/utils/get-xpath.js

@@ -1,6 +1,5 @@
 /*global axe */
 
-/*eslint max-statements: ["error", 36], complexity: ["error", 22]*/
 function getXPathArray(node, path) {
 	var sibling, count;
 	// Gets an XPath for an element which describes its hierarchical location.

data/node_modules/axe-core/lib/core/utils/is-hidden.js

@@ -8,7 +8,7 @@
  */
 axe.utils.isHidden = function isHidden(el, recursed) {
 	'use strict';
-	var parent;
+	const node = axe.utils.getNodeFromTree(el);
 
 	// 9 === Node.DOCUMENT
 	if (el.nodeType === 9) {
@@ -20,7 +20,11 @@ axe.utils.isHidden = function isHidden(el, recursed) {
 		el = el.host; // grab the host Node
 	}
 
-	var style = window.getComputedStyle(el, null);
+	if (node && node._isHidden !== null) {
+		return node._isHidden;
+	}
+
+	const style = window.getComputedStyle(el, null);
 
 	if (
 		!style ||
@@ -34,7 +38,15 @@ axe.utils.isHidden = function isHidden(el, recursed) {
 		return true;
 	}
 
-	parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+	const parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+	const isHidden = axe.utils.isHidden(parent, true);
+
+	// cache the results of the isHidden check on the parent tree
+	// so we don't have to look at the parent tree again for all its
+	// descendants
+	if (node) {
+		node._isHidden = isHidden;
+	}
 
-	return axe.utils.isHidden(parent, true);
+	return isHidden;
 };

data/node_modules/axe-core/lib/core/utils/is-html-element.js

@@ -127,9 +127,9 @@ const htmlTags = [
  * @return {Boolean} true/ false
  */
 axe.utils.isHtmlElement = function isHtmlElement(node) {
-	const tagName = node.nodeName.toLowerCase();
-	return (
-		htmlTags.includes(tagName) &&
-		node.namespaceURI !== 'http://www.w3.org/2000/svg'
-	);
+	if (node.namespaceURI === 'http://www.w3.org/2000/svg') {
+		return false;
+	}
+
+	return htmlTags.includes(node.nodeName.toLowerCase());
 };

data/node_modules/axe-core/lib/core/utils/is-shadow-root.js

@@ -27,11 +27,11 @@ const possibleShadowRoots = [
  * @return {Boolean}
  */
 axe.utils.isShadowRoot = function isShadowRoot(node) {
-	const nodeName = node.nodeName.toLowerCase();
 	if (node.shadowRoot) {
+		const nodeName = node.nodeName.toLowerCase();
 		if (
-			/^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName) ||
-			possibleShadowRoots.includes(nodeName)
+			possibleShadowRoots.includes(nodeName) ||
+			/^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName)
 		) {
 			return true;
 		}