govuk_publishing_components 21.22.1 → 21.22.2

data/node_modules/axe-core/lib/commons/matches/attributes.js

@@ -1,23 +1,27 @@
 /* global matches */
 /**
- * Check if a node matches some attribute(s)
+ * Check if a virtual node matches some attribute(s)
  *
- * Note: matches.attributes(node, matcher) can be indirectly used through
- * matches(node, { attributes: matcher })
+ * Note: matches.attributes(vNode, matcher) can be indirectly used through
+ * matches(vNode, { attributes: matcher })
  *
  * Example:
  * ```js
- * matches.attributes(node, {
+ * matches.attributes(vNode, {
  *   'aria-live': 'assertive', // Simple string match
  *   'aria-expanded': /true|false/i, // either boolean, case insensitive
  * })
  * ```
  *
- * @param {HTMLElement|VirtualNode} node
+ * @deprecated HTMLElement is deprecated, use VirtualNode instead
+ *
+ * @param {HTMLElement|VirtualNode} vNode
  * @param {Object} Attribute matcher
  * @returns {Boolean}
  */
-matches.attributes = function matchesAttributes(node, matcher) {
-	node = node.actualNode || node;
-	return matches.fromFunction(attrName => node.getAttribute(attrName), matcher);
+matches.attributes = function matchesAttributes(vNode, matcher) {
+	if (!(vNode instanceof axe.AbstractVirtualNode)) {
+		vNode = axe.utils.getNodeFromTree(vNode);
+	}
+	return matches.fromFunction(attrName => vNode.attr(attrName), matcher);
 };

data/node_modules/axe-core/lib/commons/matches/from-definition.js

@@ -2,14 +2,14 @@
 const matchers = ['nodeName', 'attributes', 'properties', 'condition'];
 
 /**
- * Check if a node matches some definition
+ * Check if a virtual node matches some definition
  *
- * Note: matches.fromDefinition(node, definition) can be indirectly used through
- * matches(node, definition)
+ * Note: matches.fromDefinition(vNode, definition) can be indirectly used through
+ * matches(vNode, definition)
  *
  * Example:
  * ```js
- * matches.fromDefinition(node, {
+ * matches.fromDefinition(vNode, {
  *   nodeName: ['div', 'span']
  *   attributes: {
  *     'aria-live': 'assertive'
@@ -17,18 +17,23 @@ const matchers = ['nodeName', 'attributes', 'properties', 'condition'];
  * })
  * ```
  *
+ * @deprecated HTMLElement is deprecated, use VirtualNode instead
+ *
  * @private
- * @param {HTMLElement|VirtualNode} node
+ * @param {HTMLElement|VirtualNode} vNode
  * @param {Object|Array<Object>} definition
  * @returns {Boolean}
  */
-matches.fromDefinition = function matchFromDefinition(node, definition) {
-	node = node.actualNode || node;
+matches.fromDefinition = function matchFromDefinition(vNode, definition) {
+	if (!(vNode instanceof axe.AbstractVirtualNode)) {
+		vNode = axe.utils.getNodeFromTree(vNode);
+	}
+
 	if (Array.isArray(definition)) {
-		return definition.some(definitionItem => matches(node, definitionItem));
+		return definition.some(definitionItem => matches(vNode, definitionItem));
 	}
 	if (typeof definition === 'string') {
-		return axe.utils.matchesSelector(node, definition);
+		return axe.utils.matches(vNode, definition);
 	}
 
 	return Object.keys(definition).every(matcherName => {
@@ -42,6 +47,6 @@ matches.fromDefinition = function matchFromDefinition(node, definition) {
 		// Find the matcher that goes into the matches method.
 		// 'div', /^div$/, (str) => str === 'div', etc.
 		const matcher = definition[matcherName];
-		return matchMethod(node, matcher);
+		return matchMethod(vNode, matcher);
 	});
 };

data/node_modules/axe-core/lib/commons/matches/index.js

@@ -1,37 +1,39 @@
 /* exported matches */
 
 /**
- * Check if a DOM element matches a definition
+ * Check if a virtual node matches a definition
  *
  * Example:
  * ```js
  * // Match a single nodeName:
- * axe.commons.matches(elm, 'div')
+ * axe.commons.matches(vNode, 'div')
  *
  * // Match one of multiple nodeNames:
- * axe.commons.matches(elm, ['ul', 'ol'])
+ * axe.commons.matches(vNode, ['ul', 'ol'])
  *
  * // Match a node with nodeName 'button' and with aria-hidden: true:
- * axe.commons.matches(elm, {
+ * axe.commons.matches(vNode, {
  * 	 nodeName: 'button',
  * 	 attributes: { 'aria-hidden': 'true' }
  * })
  *
  * // Mixed input. Match button nodeName, input[type=button] and input[type=reset]
- * axe.commons.matches(elm, ['button', {
+ * axe.commons.matches(vNode, ['button', {
  * 	nodeName: 'input', // nodeName match isn't case sensitive
  * 	properties: { type: ['button', 'reset'] }
  * }])
  * ```
  *
+ * @deprecated HTMLElement is deprecated, use VirtualNode instead
+ *
  * @namespace matches
  * @memberof axe.commons
- * @param {HTMLElement|VirtualNode} node node to verify attributes against constraints
+ * @param {HTMLElement|VirtualNode} vNode virtual node to verify attributes against constraints
  * @param {Array<ElementDefinition>|String|Object|Function|Regex} definition
- * @return {Boolean} true/ false based on if node passes the constraints expected
+ * @return {Boolean} true/ false based on if vNode passes the constraints expected
  */
-function matches(node, definition) {
-	return matches.fromDefinition(node, definition);
+function matches(vNode, definition) {
+	return matches.fromDefinition(vNode, definition);
 }
 
 commons.matches = matches;

data/node_modules/axe-core/lib/commons/matches/node-name.js

@@ -1,34 +1,24 @@
 /* global matches */
-let isXHTMLGlobal;
 /**
- * Check if the nodeName of a node matches some value
+ * Check if the nodeName of a virtual node matches some value.
  *
- * Note: matches.nodeName(node, matcher) can be indirectly used through
- * matches(node, { nodeName: matcher })
+ * Note: matches.nodeName(vNode, matcher) can be indirectly used through
+ * matches(vNode, { nodeName: matcher })
  *
  * Example:
  * ```js
- * matches.nodeName(node, ['div', 'span'])
+ * matches.nodeName(vNode, ['div', 'span'])
  * ```
  *
- * @param {HTMLElement|VirtualNode} node
+ * @deprecated HTMLElement is deprecated, use VirtualNode instead
+ *
+ * @param {HTMLElement|VirtualNode} vNode
  * @param {Object} Attribute matcher
  * @returns {Boolean}
  */
-matches.nodeName = function matchNodeName(node, matcher, { isXHTML } = {}) {
-	node = node.actualNode || node;
-	if (typeof isXHTML === 'undefined') {
-		// When the matcher is a string, use native .matches() function:
-		if (typeof matcher === 'string') {
-			return axe.utils.matchesSelector(node, matcher);
-		}
-
-		if (typeof isXHTMLGlobal === 'undefined') {
-			isXHTMLGlobal = axe.utils.isXHTML(node.ownerDocument);
-		}
-		isXHTML = isXHTMLGlobal;
+matches.nodeName = function matchNodeName(vNode, matcher) {
+	if (!(vNode instanceof axe.AbstractVirtualNode)) {
+		vNode = axe.utils.getNodeFromTree(vNode);
 	}
-
-	const nodeName = isXHTML ? node.nodeName : node.nodeName.toLowerCase();
-	return matches.fromPrimative(nodeName, matcher);
+	return matches.fromPrimative(vNode.props.nodeName, matcher);
 };

data/node_modules/axe-core/lib/commons/matches/properties.js

@@ -1,25 +1,28 @@
 /* global matches */
 
 /**
- * Check if a node matches some attribute(s)
+ * Check if a virtual node matches some attribute(s)
  *
- * Note: matches.properties(node, matcher) can be indirectly used through
- * matches(node, { properties: matcher })
+ * Note: matches.properties(vNode, matcher) can be indirectly used through
+ * matches(vNode, { properties: matcher })
  *
  * Example:
  * ```js
- * matches.properties(node, {
+ * matches.properties(vNode, {
  *   type: 'text', // Simple string match
  *   value: value => value.trim() !== '', // None-empty value, using a function matcher
  * })
  * ```
  *
- * @param {HTMLElement|VirtualNode} node
+ * @deprecated HTMLElement is deprecated, use VirtualNode instead
+ *
+ * @param {HTMLElement|VirtualNode} vNode
  * @param {Object} matcher
  * @returns {Boolean}
  */
-matches.properties = function matchesProperties(node, matcher) {
-	node = node.actualNode || node;
-	const out = matches.fromFunction(propName => node[propName], matcher);
-	return out;
+matches.properties = function matchesProperties(vNode, matcher) {
+	if (!(vNode instanceof axe.AbstractVirtualNode)) {
+		vNode = axe.utils.getNodeFromTree(vNode);
+	}
+	return matches.fromFunction(propName => vNode.props[propName], matcher);
 };

data/node_modules/axe-core/lib/commons/text/unicode.js

@@ -71,30 +71,33 @@ function getUnicodeNonBmpRegExp() {
 	 * Regex for matching astral plane unicode
 	 * - http://kourge.net/projects/regexp-unicode-block
 	 */
-	return new RegExp(
-		'[' +
-		'\u1D00-\u1D7F' + // Phonetic Extensions
-		'\u1D80-\u1DBF' + // Phonetic Extensions Supplement
-		'\u1DC0-\u1DFF' + // Combining Diacritical Marks Supplement
-		// '\u2000-\u206F' + // General punctuation - handled in -> getPunctuationRegExp
-		'\u20A0-\u20CF' + // Currency symbols
-		'\u20D0-\u20FF' + // Combining Diacritical Marks for Symbols
-		'\u2100-\u214F' + // Letter like symbols
-		'\u2150-\u218F' + // Number forms (eg: Roman numbers)
-		'\u2190-\u21FF' + // Arrows
-		'\u2200-\u22FF' + // Mathematical operators
-		'\u2300-\u23FF' + // Misc Technical
-		'\u2400-\u243F' + // Control pictures
-		'\u2440-\u245F' + // OCR
-		'\u2460-\u24FF' + // Enclosed alpha numerics
-		'\u2500-\u257F' + // Box Drawing
-		'\u2580-\u259F' + // Block Elements
-		'\u25A0-\u25FF' + // Geometric Shapes
-		'\u2600-\u26FF' + // Misc Symbols
-		'\u2700-\u27BF' + // Dingbats
-		'\uE000-\uF8FF' + // Private Use
-			']'
-	);
+
+	/**
+	 * Notes on various unicode planes being used in the regex below:
+	 * '\u1D00-\u1D7F'  Phonetic Extensions
+	 * '\u1D80-\u1DBF'  Phonetic Extensions Supplement
+	 * '\u1DC0-\u1DFF'  Combining Diacritical Marks Supplement
+	 * '\u20A0-\u20CF'  Currency symbols
+	 * '\u20D0-\u20FF'  Combining Diacritical Marks for Symbols
+	 * '\u2100-\u214F'  Letter like symbols
+	 * '\u2150-\u218F'  Number forms (eg: Roman numbers)
+	 * '\u2190-\u21FF'  Arrows
+	 * '\u2200-\u22FF'  Mathematical operators
+	 * '\u2300-\u23FF'  Misc Technical
+	 * '\u2400-\u243F'  Control pictures
+	 * '\u2440-\u245F'  OCR
+	 * '\u2460-\u24FF'  Enclosed alpha numerics
+	 * '\u2500-\u257F'  Box Drawing
+	 * '\u2580-\u259F'  Block Elements
+	 * '\u25A0-\u25FF'  Geometric Shapes
+	 * '\u2600-\u26FF'  Misc Symbols
+	 * '\u2700-\u27BF'  Dingbats
+	 * '\uE000-\uF8FF'  Private Use
+	 *
+	 * Note: plane '\u2000-\u206F' used for General punctuation is excluded as it is handled in -> getPunctuationRegExp
+	 */
+
+	return /[\u1D00-\u1D7F\u1D80-\u1DBF\u1DC0-\u1DFF\u20A0-\u20CF\u20D0-\u20FF\u2100-\u214F\u2150-\u218F\u2190-\u21FF\u2200-\u22FF\u2300-\u23FF\u2400-\u243F\u2440-\u245F\u2460-\u24FF\u2500-\u257F\u2580-\u259F\u25A0-\u25FF\u2600-\u26FF\u2700-\u27BF\uE000-\uF8FF]/g;
 }
 
 /**

data/node_modules/axe-core/lib/core/base/virtual-node/virtual-node.js

@@ -1,3 +1,5 @@
+let isXHTMLGlobal;
+
 // class is unused in the file...
 // eslint-disable-next-line no-unused-vars
 class VirtualNode extends axe.AbstractVirtualNode {
@@ -17,6 +19,11 @@ class VirtualNode extends axe.AbstractVirtualNode {
 		this._isHidden = null; // will be populated by axe.utils.isHidden
 		this._cache = {};
 
+		if (typeof isXHTMLGlobal === 'undefined') {
+			isXHTMLGlobal = axe.utils.isXHTML(node.ownerDocument);
+		}
+		this._isXHTML = isXHTMLGlobal;
+
 		if (axe._cache.get('nodeMap')) {
 			axe._cache.get('nodeMap').set(node, this);
 		}
@@ -25,13 +32,14 @@ class VirtualNode extends axe.AbstractVirtualNode {
 	// abstract Node properties so we can run axe in DOM-less environments.
 	// add to the prototype so memory is shared across all virtual nodes
 	get props() {
-		const { nodeType, nodeName, id, type } = this.actualNode;
+		const { nodeType, nodeName, id, type, multiple } = this.actualNode;
 
 		return {
 			nodeType,
-			nodeName: nodeName.toLowerCase(),
+			nodeName: this._isXHTML ? nodeName : nodeName.toLowerCase(),
 			id,
-			type
+			type,
+			multiple
 		};
 	}
 

data/node_modules/axe-core/lib/core/constants.js

@@ -36,7 +36,7 @@
 			/**
 			 * array of supported & preload(able) asset types.
 			 */
-			assets: ['cssom'],
+			assets: ['cssom', 'media'],
 			/**
 			 * timeout value when resolving preload(able) assets
 			 */

data/node_modules/axe-core/lib/core/reporters/v1.js

@@ -9,11 +9,14 @@ axe.addReporter('v1', function(results, options, callback) {
 	}
 	var out = helpers.processAggregate(results, options);
 
-	out.violations.forEach(result =>
+	const addFailureSummaries = result => {
 		result.nodes.forEach(nodeResult => {
 			nodeResult.failureSummary = helpers.failureSummary(nodeResult);
-		})
-	);
+		});
+	};
+
+	out.incomplete.forEach(addFailureSummaries);
+	out.violations.forEach(addFailureSummaries);
 
 	callback({
 		...helpers.getEnvironmentData(),

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

@@ -1,5 +1,5 @@
 /**
- * Wrapper for Node#contains; PhantomJS does not support Node#contains and erroneously reports that it does
+ * Wrapper for Node#contains
  * @method contains
  * @memberof axe.utils
  * @param  {VirtualNode} vNode     The candidate container VirtualNode

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

@@ -28,12 +28,12 @@ axe.utils.isHidden = function isHidden(el, recursed) {
 
 	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'))
+		!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;
 	}

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

@@ -0,0 +1,263 @@
+function matchesTag(vNode, exp) {
+	return (
+		vNode.props.nodeType === 1 &&
+		(exp.tag === '*' || vNode.props.nodeName === exp.tag)
+	);
+}
+
+function matchesClasses(vNode, exp) {
+	return !exp.classes || exp.classes.every(cl => vNode.hasClass(cl.value));
+}
+
+function matchesAttributes(vNode, exp) {
+	return (
+		!exp.attributes ||
+		exp.attributes.every(att => {
+			var nodeAtt = vNode.attr(att.key);
+			return nodeAtt !== null && (!att.value || att.test(nodeAtt));
+		})
+	);
+}
+
+function matchesId(vNode, exp) {
+	return !exp.id || vNode.props.id === exp.id;
+}
+
+function matchesPseudos(target, exp) {
+	if (
+		!exp.pseudos ||
+		exp.pseudos.every(pseudo => {
+			if (pseudo.name === 'not') {
+				return !axe.utils.matchesExpression(target, pseudo.expressions[0]);
+			}
+			throw new Error(
+				'the pseudo selector ' + pseudo.name + ' has not yet been implemented'
+			);
+		})
+	) {
+		return true;
+	}
+	return false;
+}
+
+function matchExpression(vNode, expression) {
+	return (
+		matchesTag(vNode, expression) &&
+		matchesClasses(vNode, expression) &&
+		matchesAttributes(vNode, expression) &&
+		matchesId(vNode, expression) &&
+		matchesPseudos(vNode, expression)
+	);
+}
+
+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);
+	};
+})();
+
+const reUnescape = /\\/g;
+function convertAttributes(atts) {
+	/*! Credit Mootools Copyright Mootools, MIT License */
+	if (!atts) {
+		return;
+	}
+	return atts.map(att => {
+		const attributeKey = att.name.replace(reUnescape, '');
+		const attributeValue = (att.value || '').replace(reUnescape, '');
+		let 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 = 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}
+ *
+ */
+function convertExpressions(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;
+	});
+}
+
+/**
+ * Convert a CSS selector to the Slick format expression
+ *
+ * @private
+ * @param {String} selector CSS selector to convert
+ * @returns {Object[]} Array of Slick format expressions
+ */
+axe.utils.convertSelector = function convertSelector(selector) {
+	var expressions = axe.utils.cssParser.parse(selector);
+	expressions = expressions.selectors ? expressions.selectors : [expressions];
+	return convertExpressions(expressions);
+};
+
+/**
+ * Determine if a virtual node matches a Slick format CSS expression
+ *
+ * @private
+ * @method matchesExpression
+ * @memberof axe.utils
+ * @param {VirtualNode} vNode VirtualNode to match
+ * @param {Object|Object[]} expressions CSS selector expression or array of expressions
+ * @returns {Boolean}
+ */
+axe.utils.matchesExpression = function matchesExpression(
+	vNode,
+	expressions,
+	matchAnyParent
+) {
+	let exps = [].concat(expressions);
+	let expression = exps.pop();
+	let matches = matchExpression(vNode, expression);
+
+	while (!matches && matchAnyParent && vNode.parent) {
+		vNode = vNode.parent;
+		matches = matchExpression(vNode, expression);
+	}
+
+	if (exps.length) {
+		if ([' ', '>'].includes(expression.combinator) === false) {
+			throw new Error(
+				'axe.utils.matchesExpression does not support the combinator: ' +
+					expression.combinator
+			);
+		}
+
+		matches =
+			matches &&
+			axe.utils.matchesExpression(
+				vNode.parent,
+				exps,
+				expression.combinator === ' '
+			);
+	}
+
+	return matches;
+};
+
+/**
+ * matches implementation that operates on a VirtualNode
+ *
+ * @method matches
+ * @memberof axe.utils
+ * @param {VirtualNode} vNode VirtualNode to match
+ * @param {String} selector CSS selector string
+ * @return {Boolean}
+ */
+axe.utils.matches = function matches(vNode, selector) {
+	let expressions = axe.utils.convertSelector(selector);
+	return expressions.some(expression =>
+		axe.utils.matchesExpression(vNode, expression)
+	);
+};