govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,84 @@
+/*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.
+	if (!node) {
+		return [];
+	}
+	if (!path && node.nodeType === 9) {
+		// special case for when we are called and give the document itself as the starting node
+		path = [
+			{
+				str: 'html'
+			}
+		];
+		return path;
+	}
+	path = path || [];
+	if (node.parentNode && node.parentNode !== node) {
+		path = getXPathArray(node.parentNode, path);
+	}
+
+	if (node.previousSibling) {
+		count = 1;
+		sibling = node.previousSibling;
+		do {
+			if (sibling.nodeType === 1 && sibling.nodeName === node.nodeName) {
+				count++;
+			}
+			sibling = sibling.previousSibling;
+		} while (sibling);
+		if (count === 1) {
+			count = null;
+		}
+	} else if (node.nextSibling) {
+		sibling = node.nextSibling;
+		do {
+			if (sibling.nodeType === 1 && sibling.nodeName === node.nodeName) {
+				count = 1;
+				sibling = null;
+			} else {
+				count = null;
+				sibling = sibling.previousSibling;
+			}
+		} while (sibling);
+	}
+
+	if (node.nodeType === 1) {
+		var element = {};
+		element.str = node.nodeName.toLowerCase();
+		// add the id and the count so we can construct robust versions of the xpath
+		var id =
+			node.getAttribute && axe.utils.escapeSelector(node.getAttribute('id'));
+		if (id && node.ownerDocument.querySelectorAll('#' + id).length === 1) {
+			element.id = node.getAttribute('id');
+		}
+		if (count > 1) {
+			element.count = count;
+		}
+		path.push(element);
+	}
+	return path;
+}
+
+// Robust is intended to allow xpaths to be robust to changes in the HTML structure of the page
+// This means always use the id when present
+// Non robust means always use the count (i.e. the exact position of the element)
+// Ironically this is a bit of a misnomer because in very, very dynamic pages (e.g. where ids are generated on the fly)
+// the non-ribust Xpaths will work whereas the robust ones will not work
+function xpathToString(xpathArray) {
+	return xpathArray.reduce((str, elm) => {
+		if (elm.id) {
+			return `/${elm.str}[@id='${elm.id}']`;
+		} else {
+			return str + `/${elm.str}` + (elm.count > 0 ? `[${elm.count}]` : '');
+		}
+	}, '');
+}
+
+axe.utils.getXpath = function getXpath(node) {
+	var xpathArray = getXPathArray(node);
+	return xpathToString(xpathArray);
+};

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

@@ -0,0 +1,10 @@
+/*eslint no-unused-vars: 0*/
+/* exported utils */
+
+/**
+ * Namespace for utility helper methods.
+ * @namespace utils
+ * @memberof axe
+ */
+
+var utils = (axe.utils = {});

data/node_modules/axe-core/lib/core/utils/inject-style.js

@@ -0,0 +1,38 @@
+/*exported injectStyle */
+/*global axe*/
+
+var styleSheet;
+function injectStyle(style) {
+	'use strict';
+
+	if (styleSheet && styleSheet.parentNode) {
+		// append the style to the existing sheet
+		if (styleSheet.styleSheet === undefined) {
+			// Not old IE
+			styleSheet.appendChild(document.createTextNode(style));
+		} else {
+			styleSheet.styleSheet.cssText += style;
+		}
+		return styleSheet;
+	}
+	if (!style) {
+		return;
+	}
+
+	var head = document.head || document.getElementsByTagName('head')[0];
+	styleSheet = document.createElement('style');
+	styleSheet.type = 'text/css';
+
+	if (styleSheet.styleSheet === undefined) {
+		// Not old IE
+		styleSheet.appendChild(document.createTextNode(style));
+	} else {
+		styleSheet.styleSheet.cssText = style;
+	}
+
+	head.appendChild(styleSheet);
+
+	return styleSheet;
+}
+
+axe.utils.injectStyle = injectStyle;

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

@@ -0,0 +1,40 @@
+/**
+ * Determine whether an element is visible
+ * @method isHidden
+ * @memberof axe.utils
+ * @param {HTMLElement} el The HTMLElement
+ * @param {Boolean} recursed
+ * @return {Boolean} The element's visibilty status
+ */
+axe.utils.isHidden = function isHidden(el, recursed) {
+	'use strict';
+	var parent;
+
+	// 9 === Node.DOCUMENT
+	if (el.nodeType === 9) {
+		return false;
+	}
+
+	// 11 === Node.DOCUMENT_FRAGMENT_NODE
+	if (el.nodeType === 11) {
+		el = el.host; // grab the host Node
+	}
+
+	var style = window.getComputedStyle(el, null);
+
+	if (
+		!style ||
+		(!el.parentNode ||
+			(style.getPropertyValue('display') === 'none' ||
+				(!recursed &&
+					// visibility is only accurate on the first element
+					style.getPropertyValue('visibility') === 'hidden') ||
+				el.getAttribute('aria-hidden') === 'true'))
+	) {
+		return true;
+	}
+
+	parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+
+	return axe.utils.isHidden(parent, true);
+};

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

@@ -0,0 +1,135 @@
+const htmlTags = [
+	'a',
+	'abbr',
+	'address',
+	'area',
+	'article',
+	'aside',
+	'audio',
+	'b',
+	'base',
+	'bdi',
+	'bdo',
+	'blockquote',
+	'body',
+	'br',
+	'button',
+	'canvas',
+	'caption',
+	'cite',
+	'code',
+	'col',
+	'colgroup',
+	'data',
+	'datalist',
+	'dd',
+	'del',
+	'details',
+	'dfn',
+	'dialog',
+	'div',
+	'dl',
+	'dt',
+	'em',
+	'embed',
+	'fieldset',
+	'figcaption',
+	'figure',
+	'footer',
+	'form',
+	'h1',
+	'h2',
+	'h3',
+	'h4',
+	'h5',
+	'h6',
+	'head',
+	'header',
+	'hgroup',
+	'hr',
+	'html',
+	'i',
+	'iframe',
+	'img',
+	'input',
+	'ins',
+	'kbd',
+	'keygen',
+	'label',
+	'legend',
+	'li',
+	'link',
+	'main',
+	'map',
+	'mark',
+	'math',
+	'menu',
+	'menuitem',
+	'meta',
+	'meter',
+	'nav',
+	'noscript',
+	'object',
+	'ol',
+	'optgroup',
+	'option',
+	'output',
+	'p',
+	'param',
+	'picture',
+	'pre',
+	'progress',
+	'q',
+	'rb',
+	'rp',
+	'rt',
+	'rtc',
+	'ruby',
+	's',
+	'samp',
+	'script',
+	'section',
+	'select',
+	'slot',
+	'small',
+	'source',
+	'span',
+	'strong',
+	'style',
+	'sub',
+	'summary',
+	'sup',
+	'svg',
+	'table',
+	'tbody',
+	'td',
+	'template',
+	'textarea',
+	'tfoot',
+	'th',
+	'thead',
+	'time',
+	'title',
+	'tr',
+	'track',
+	'u',
+	'ul',
+	'var',
+	'video',
+	'wbr'
+];
+
+/**
+ * Verifies that if a given html tag is valid
+ * @method isHtmlElement
+ * @memberof axe.utils
+ * @param htmlTag htmlTag to check if valid
+ * @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'
+	);
+};

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

@@ -0,0 +1,40 @@
+/* global axe */
+
+const possibleShadowRoots = [
+	'article',
+	'aside',
+	'blockquote',
+	'body',
+	'div',
+	'footer',
+	'h1',
+	'h2',
+	'h3',
+	'h4',
+	'h5',
+	'h6',
+	'header',
+	'main',
+	'nav',
+	'p',
+	'section',
+	'span'
+];
+/**
+ * Test a node to see if it has a spec-conforming shadow root
+ *
+ * @param {Node}   node  The HTML DOM node
+ * @return {Boolean}
+ */
+axe.utils.isShadowRoot = function isShadowRoot(node) {
+	const nodeName = node.nodeName.toLowerCase();
+	if (node.shadowRoot) {
+		if (
+			/^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName) ||
+			possibleShadowRoots.includes(nodeName)
+		) {
+			return true;
+		}
+	}
+	return false;
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Determines if a document node is XHTML
+ * @method isXHTML
+ * @memberof axe.utils
+ * @param {Node} doc a document node
+ * @return {Boolean}
+ */
+axe.utils.isXHTML = function(doc) {
+	'use strict';
+	if (!doc.createElement) {
+		return false;
+	}
+	return doc.createElement('A').localName === 'A';
+};

data/node_modules/axe-core/lib/core/utils/merge-results.js

@@ -0,0 +1,116 @@
+/**
+ * Adds the owning frame's CSS selector onto each instance of DqElement
+ * @private
+ * @param	{Array} resultSet `nodes` array on a `RuleResult`
+ * @param	{HTMLElement} frameElement	The frame element
+ * @param	{String} frameSelector		 Unique CSS selector for the frame
+ */
+function pushFrame(resultSet, options, frameElement, frameSelector) {
+	'use strict';
+	var frameXpath = axe.utils.getXpath(frameElement);
+	var frameSpec = {
+		element: frameElement,
+		selector: frameSelector,
+		xpath: frameXpath
+	};
+
+	resultSet.forEach(function(res) {
+		res.node = axe.utils.DqElement.fromFrame(res.node, options, frameSpec);
+
+		var checks = axe.utils.getAllChecks(res);
+		if (checks.length) {
+			checks.forEach(function(check) {
+				check.relatedNodes = check.relatedNodes.map(node =>
+					axe.utils.DqElement.fromFrame(node, options, frameSpec)
+				);
+			});
+		}
+	});
+}
+
+/**
+ * Adds `to` to `from` and then re-sorts by DOM order
+ * @private
+ * @param	{Array} target	`nodes` array on a `RuleResult`
+ * @param	{Array} to	 `nodes` array on a `RuleResult`
+ * @return {Array}			The merged and sorted result
+ */
+function spliceNodes(target, to) {
+	'use strict';
+
+	var firstFromFrame = to[0].node,
+		sorterResult,
+		t;
+	for (var i = 0, l = target.length; i < l; i++) {
+		t = target[i].node;
+		sorterResult = axe.utils.nodeSorter(
+			{ actualNode: t.element },
+			{ actualNode: firstFromFrame.element }
+		);
+		if (
+			sorterResult > 0 ||
+			(sorterResult === 0 && firstFromFrame.selector.length < t.selector.length)
+		) {
+			target.splice.apply(target, [i, 0].concat(to));
+			return;
+		}
+	}
+
+	target.push.apply(target, to);
+}
+
+function normalizeResult(result) {
+	'use strict';
+
+	if (!result || !result.results) {
+		return null;
+	}
+
+	if (!Array.isArray(result.results)) {
+		return [result.results];
+	}
+
+	if (!result.results.length) {
+		return null;
+	}
+
+	return result.results;
+}
+
+/**
+ * Merges one or more RuleResults (possibly from different frames) into one RuleResult
+ * @private
+ * @param	{Array} frameResults	Array of objects including the RuleResults as `results` and frame as `frame`
+ * @return {Array}							The merged RuleResults; should only have one result per rule
+ */
+axe.utils.mergeResults = function mergeResults(frameResults, options) {
+	'use strict';
+	var result = [];
+	frameResults.forEach(function(frameResult) {
+		var results = normalizeResult(frameResult);
+		if (!results || !results.length) {
+			return;
+		}
+
+		results.forEach(function(ruleResult) {
+			if (ruleResult.nodes && frameResult.frame) {
+				pushFrame(
+					ruleResult.nodes,
+					options,
+					frameResult.frameElement,
+					frameResult.frame
+				);
+			}
+
+			var res = axe.utils.findBy(result, 'id', ruleResult.id);
+			if (!res) {
+				result.push(ruleResult);
+			} else {
+				if (ruleResult.nodes.length) {
+					spliceNodes(res.nodes, ruleResult.nodes);
+				}
+			}
+		});
+	});
+	return result;
+};