govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,5 @@
+(function(axe) {
+	var parser = new axe.imports.CssSelectorParser();
+	parser.registerNestingOperators('>');
+	axe.utils.cssParser = parser;
+})(axe);

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

@@ -0,0 +1,97 @@
+/*exported DqElement */
+
+function truncate(str, maxLength) {
+	maxLength = maxLength || 300;
+
+	if (str.length > maxLength) {
+		var index = str.indexOf('>');
+		str = str.substring(0, index + 1);
+	}
+
+	return str;
+}
+
+function getSource(element) {
+	var source = element.outerHTML;
+	if (!source && typeof XMLSerializer === 'function') {
+		source = new XMLSerializer().serializeToString(element);
+	}
+	return truncate(source || '');
+}
+
+/**
+ * "Serialized" `HTMLElement`. It will calculate the CSS selector,
+ * grab the source (outerHTML) and offer an array for storing frame paths
+ * @param {HTMLElement} element The element to serialize
+ * @param {Object} spec Properties to use in place of the element when instantiated on Elements from other frames
+ */
+function DqElement(element, options, spec) {
+	this._fromFrame = !!spec;
+
+	this.spec = spec || {};
+	if (options && options.absolutePaths) {
+		this._options = { toRoot: true };
+	}
+
+	/**
+	 * The generated HTML source code of the element
+	 * @type {String}
+	 */
+	this.source =
+		this.spec.source !== undefined ? this.spec.source : getSource(element);
+
+	/**
+	 * The element which this object is based off or the containing frame, used for sorting.
+	 * Excluded in toJSON method.
+	 * @type {HTMLElement}
+	 */
+	this._element = element;
+}
+
+DqElement.prototype = {
+	/**
+	 * A unique CSS selector for the element
+	 * @return {String}
+	 */
+	get selector() {
+		return (
+			this.spec.selector || [axe.utils.getSelector(this.element, this._options)]
+		);
+	},
+
+	/**
+	 * Xpath to the element
+	 * @return {String}
+	 */
+	get xpath() {
+		return this.spec.xpath || [axe.utils.getXpath(this.element)];
+	},
+
+	/**
+	 * Direct reference to the `HTMLElement` wrapped by this `DQElement`.
+	 */
+	get element() {
+		return this._element;
+	},
+
+	get fromFrame() {
+		return this._fromFrame;
+	},
+
+	toJSON: function() {
+		'use strict';
+		return {
+			selector: this.selector,
+			source: this.source,
+			xpath: this.xpath
+		};
+	}
+};
+
+DqElement.fromFrame = function(node, options, frame) {
+	node.selector.unshift(frame.selector);
+	node.xpath.unshift(frame.xpath);
+	return new axe.utils.DqElement(frame.element, options, node);
+};
+
+axe.utils.DqElement = DqElement;

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

@@ -0,0 +1,39 @@
+/**
+ * Polyfill for Element#matches
+ * @param {HTMLElement} node The element to test
+ * @param {String} selector The selector to test element against
+ * @return {Boolean}
+ */
+axe.utils.matchesSelector = (function() {
+	'use strict';
+
+	var method;
+
+	function getMethod(node) {
+		var index,
+			candidate,
+			candidates = [
+				'matches',
+				'matchesSelector',
+				'mozMatchesSelector',
+				'webkitMatchesSelector',
+				'msMatchesSelector'
+			],
+			length = candidates.length;
+
+		for (index = 0; index < length; index++) {
+			candidate = candidates[index];
+			if (node[candidate]) {
+				return candidate;
+			}
+		}
+	}
+
+	return function(node, selector) {
+		if (!method || !node[method]) {
+			method = getMethod(node);
+		}
+
+		return node[method](selector);
+	};
+})();

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

@@ -0,0 +1,79 @@
+/**
+ * Escapes a property value of a CSS selector
+ * @see https://github.com/mathiasbynens/CSS.escape/
+ * @see http://dev.w3.org/csswg/cssom/#serialize-an-identifier
+ * @param  {String} value The piece of the selector to escape
+ * @return {String}        The escaped selector
+ */
+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 */
+	var string = String(value);
+	var length = string.length;
+	var index = -1;
+	var codeUnit;
+	var result = '';
+	var firstCodeUnit = string.charCodeAt(0);
+	while (++index < length) {
+		codeUnit = string.charCodeAt(index);
+		// Note: there’s no need to special-case astral symbols, surrogate
+		// pairs, or lone surrogates.
+
+		// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+		// (U+FFFD).
+		if (codeUnit == 0x0000) {
+			result += '\uFFFD';
+			continue;
+		}
+
+		if (
+			// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+			// U+007F, […]
+			(codeUnit >= 0x0001 && codeUnit <= 0x001f) ||
+			codeUnit == 0x007f ||
+			// If the character is the first character and is in the range [0-9]
+			// (U+0030 to U+0039), […]
+			(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+			// If the character is the second character and is in the range [0-9]
+			// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+			(index == 1 &&
+				codeUnit >= 0x0030 &&
+				codeUnit <= 0x0039 &&
+				firstCodeUnit == 0x002d)
+		) {
+			// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+			result += '\\' + codeUnit.toString(16) + ' ';
+			continue;
+		}
+
+		// If the character is the first character and is a `-` (U+002D), and
+		// there is no second character, […]
+		if (index == 0 && length == 1 && codeUnit == 0x002d) {
+			result += '\\' + string.charAt(index);
+			continue;
+		}
+
+		// If the character is not handled by one of the above rules and is
+		// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+		// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+		// U+005A), or [a-z] (U+0061 to U+007A), […]
+		if (
+			codeUnit >= 0x0080 ||
+			codeUnit == 0x002d ||
+			codeUnit == 0x005f ||
+			(codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+			(codeUnit >= 0x0041 && codeUnit <= 0x005a) ||
+			(codeUnit >= 0x0061 && codeUnit <= 0x007a)
+		) {
+			// the character itself
+			result += string.charAt(index);
+			continue;
+		}
+
+		// Otherwise, the escaped character.
+		// https://drafts.csswg.org/cssom/#escape-a-character
+		result += '\\' + string.charAt(index);
+	}
+	return result;
+};

data/node_modules/axe-core/lib/core/utils/extend-meta-data.js

@@ -0,0 +1,17 @@
+/*eslint no-empty: 0*/
+/**
+ * Extends metadata onto result object and executes any functions
+ * @param  {Object} to   The target of the extend
+ * @param  {Object} from Metadata to extend
+ */
+axe.utils.extendMetaData = function(to, from) {
+	Object.assign(to, from);
+	Object.keys(from)
+		.filter(prop => typeof from[prop] === 'function')
+		.forEach(prop => {
+			to[prop] = null;
+			try {
+				to[prop] = from[prop](to);
+			} catch (e) {}
+		});
+};

data/node_modules/axe-core/lib/core/utils/finalize-result.js

@@ -0,0 +1,11 @@
+/**
+ * Process rule results, grouping them by outcome
+ * @param ruleResult {object}
+ * @return {object}
+ */
+axe.utils.finalizeRuleResult = function(ruleResult) {
+	Object.assign(ruleResult, axe.utils.aggregateNodeResults(ruleResult.nodes));
+	delete ruleResult.nodes;
+
+	return ruleResult;
+};

data/node_modules/axe-core/lib/core/utils/find-by.js

@@ -0,0 +1,14 @@
+/**
+ * Iterates an array of objects looking for a property with a specific value
+ * @method findBy
+ * @memberof axe.utils
+ * @param  {Array} array  The array of objects to iterate
+ * @param  {String} key   The property name to test against
+ * @param  {Mixed} value  The value to find
+ * @return {Object}       The first matching object or `undefined` if no match
+ */
+axe.utils.findBy = function(array, key, value) {
+	if (Array.isArray(array)) {
+		return array.find(obj => typeof obj === 'object' && obj[key] === value);
+	}
+};

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

@@ -0,0 +1,170 @@
+/*eslint no-use-before-define: 0*/
+var axe = axe || { utils: {} };
+
+/**
+ * This implemnts the flatten-tree algorithm specified:
+ * Originally here https://drafts.csswg.org/css-scoping/#flat-tree
+ * Hopefully soon published here: https://www.w3.org/TR/css-scoping-1/#flat-tree
+ *
+ * Some notable information:
+ ******* NOTE: as of Chrome 59, this is broken in Chrome so that tests fail completely
+ ******* removed functionality for now
+ * 1. <slot> elements do not have boxes by default (i.e. they do not get rendered and
+ *    their CSS properties are ignored)
+ * 2. <slot> elements can be made to have a box by overriding the display property
+ *    which is 'contents' by default
+ * 3. Even boxed <slot> elements do not show up in the accessibility tree until
+ *    they have a tabindex applied to them OR they have a role applied to them AND
+ *    they have a box (this is observed behavior in Safari on OS X, I cannot find
+ *    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
+ *
+ * @param node {Node} - the slot Node
+ * @return Array{Nodes}
+ */
+function getSlotChildren(node) {
+	var retVal = [];
+
+	node = node.firstChild;
+	while (node) {
+		retVal.push(node);
+		node = node.nextSibling;
+	}
+	return retVal;
+}
+
+/**
+ * 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) {
+	// 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);
+		if (replacements) {
+			res = res.concat(replacements);
+		}
+		return res;
+	}
+
+	if (node.documentElement) {
+		// document
+		node = node.documentElement;
+	}
+	nodeName = node.nodeName.toLowerCase();
+
+	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);
+		shadowId =
+			'a' +
+			Math.random()
+				.toString()
+				.substring(2);
+		realArray = Array.from(node.shadowRoot.childNodes);
+		retVal.children = realArray.reduce(reduceShadowDOM, []);
+		return [retVal];
+	} else {
+		if (nodeName === 'content') {
+			realArray = Array.from(node.getDistributedNodes());
+			return realArray.reduce(reduceShadowDOM, []);
+		} else if (
+			nodeName === 'slot' &&
+			typeof node.assignedNodes === 'function'
+		) {
+			realArray = Array.from(node.assignedNodes());
+			if (!realArray.length) {
+				// fallback content
+				realArray = getSlotChildren(node);
+			}
+			var styl = window.getComputedStyle(node);
+			// check the display property
+			if (false && styl.display !== 'contents') {
+				// intentionally commented out
+				// has a box
+				retVal = virtualDOMfromNode(node, shadowId);
+				retVal.children = realArray.reduce(reduceShadowDOM, []);
+				return [retVal];
+			} else {
+				return realArray.reduce(reduceShadowDOM, []);
+			}
+		} else {
+			if (node.nodeType === 1) {
+				retVal = virtualDOMfromNode(node, shadowId);
+				realArray = Array.from(node.childNodes);
+				retVal.children = realArray.reduce(reduceShadowDOM, []);
+				return [retVal];
+			} else if (node.nodeType === 3) {
+				// text
+				return [virtualDOMfromNode(node)];
+			}
+			return undefined;
+		}
+	}
+};
+
+/**
+ * Recursively return a single node from a 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;
+};

data/node_modules/axe-core/lib/core/utils/get-all-checks.js

@@ -0,0 +1,12 @@
+/**
+ * Gets all Checks (or CheckResults) for a given Rule or RuleResult
+ * @param {RuleResult|Rule} rule
+ */
+axe.utils.getAllChecks = function getAllChecks(object) {
+	'use strict';
+	var result = [];
+	return result
+		.concat(object.any || [])
+		.concat(object.all || [])
+		.concat(object.none || []);
+};