govuk_publishing_components 21.16.3 → 21.17.0

data/node_modules/axe-core/lib/commons/text/is-valid-autocomplete.js

@@ -74,7 +74,6 @@ text.isValidAutocomplete = function isValidAutocomplete(
 		qualifiedTerms = []
 	} = {}
 ) {
-	/*eslint max-statements: ["error", 23] */
 	autocomplete = autocomplete.toLowerCase().trim();
 	stateTerms = stateTerms.concat(text.autocomplete.stateTerms);
 	if (stateTerms.includes(autocomplete) || autocomplete === '') {

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

@@ -9,7 +9,7 @@
  * @return {String} Label text
  */
 text.labelText = function labelText(virtualNode, context = {}) {
-	const { alreadyProcessed } = text.accessibleTextVirtual
+	const { alreadyProcessed } = text.accessibleTextVirtual;
 	if (
 		context.inControlContext ||
 		context.inLabelledByContext ||

data/node_modules/axe-core/lib/commons/text/label-virtual.js

@@ -48,6 +48,6 @@ text.labelVirtual = function(node) {
  * @return {Mixed} String of visible text, or `null` if no label is found
  */
 text.label = function(node) {
-	node = axe.utils.getNodeFromTree(axe._tree[0], node);
+	node = axe.utils.getNodeFromTree(node);
 	return text.labelVirtual(node);
 };

data/node_modules/axe-core/lib/commons/text/native-text-methods.js

@@ -95,7 +95,7 @@ text.nativeTextMethods = {
 	 * @return {String} Returns ` `
 	 */
 	singleSpace: function singleSpace() {
-		return ' '
+		return ' ';
 	}
 };
 

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

@@ -8,11 +8,11 @@
  * @return {String} Accessible text
  */
 text.subtreeText = function subtreeText(virtualNode, context = {}) {
-	const { alreadyProcessed } = text.accessibleTextVirtual
+	const { alreadyProcessed } = text.accessibleTextVirtual;
 	context.startNode = context.startNode || virtualNode;
 	const { strict } = context;
 	if (
-		alreadyProcessed(virtualNode, context ) ||
+		alreadyProcessed(virtualNode, context) ||
 		!aria.namedFromContents(virtualNode, { strict })
 	) {
 		return '';
@@ -72,7 +72,7 @@ function appendAccessibleText(contentText, virtualNode, context) {
 	const nodeName = virtualNode.actualNode.nodeName.toUpperCase();
 	let contentTextAdd = text.accessibleTextVirtual(virtualNode, context);
 	if (!contentTextAdd) {
-		return contentText
+		return contentText;
 	}
 
 	if (!phrasingElements.includes(nodeName)) {

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

@@ -48,6 +48,7 @@ text.removeUnicode = function removeUnicode(str, options) {
 	}
 	if (nonBmp) {
 		str = str.replace(getUnicodeNonBmpRegExp(), '');
+		str = str.replace(getSupplementaryPrivateUseRegExp(), '');
 	}
 	if (punctuations) {
 		str = str.replace(getPunctuationRegExp(), '');
@@ -91,6 +92,7 @@ function getUnicodeNonBmpRegExp() {
 		'\u25A0-\u25FF' + // Geometric Shapes
 		'\u2600-\u26FF' + // Misc Symbols
 		'\u2700-\u27BF' + // Dingbats
+		'\uE000-\uF8FF' + // Private Use
 			']'
 	);
 }
@@ -115,3 +117,16 @@ function getPunctuationRegExp() {
 	 */
 	return /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]/g;
 }
+
+/**
+ * Get regular expression for supplementary private use
+ *
+ * @returns {RegExp}
+ */
+function getSupplementaryPrivateUseRegExp() {
+	/**
+	 * Reference: https://www.unicode.org/charts/PDF/UD800.pdf
+	 * https://www.unicode.org/charts/PDF/UDC00.pdf
+	 */
+	return /[\uDB80-\uDBBF][\uDC00-\uDFFD]/g;
+}

data/node_modules/axe-core/lib/commons/text/visible-text-nodes.js

@@ -0,0 +1,25 @@
+/* global text */
+
+/**
+ * Returns an array of visible text virtual nodes
+
+ * @method visibleTextNodes
+ * @memberof axe.commons.text
+ * @instance
+ * @param {VirtualNode} vNode
+ * @return {VitrualNode[]}
+ */
+text.visibleTextNodes = function(vNode) {
+	const parentVisible = axe.commons.dom.isVisible(vNode.actualNode);
+	let nodes = [];
+	vNode.children.forEach(child => {
+		if (child.actualNode.nodeType === 3) {
+			if (parentVisible) {
+				nodes.push(child);
+			}
+		} else {
+			nodes = nodes.concat(text.visibleTextNodes(child));
+		}
+	});
+	return nodes;
+};

data/node_modules/axe-core/lib/commons/text/visible-virtual.js

@@ -41,6 +41,6 @@ text.visibleVirtual = function(element, screenReader, noRecursing) {
  * @return {String}
  */
 text.visible = function(element, screenReader, noRecursing) {
-	element = axe.utils.getNodeFromTree(axe._tree[0], element);
+	element = axe.utils.getNodeFromTree(element);
 	return text.visibleVirtual(element, screenReader, noRecursing);
 };

data/node_modules/axe-core/lib/core/base/audit.js

@@ -37,6 +37,7 @@ function Audit(audit) {
 	this.brand = 'axe';
 	this.application = 'axeAPI';
 	this.tagExclude = ['experimental'];
+	this.lang = 'en';
 
 	this.defaultConfig = audit;
 	this._init();
@@ -60,7 +61,10 @@ Audit.prototype._setDefaultLocale = function() {
 
 	const locale = {
 		checks: {},
-		rules: {}
+		rules: {},
+		failureSummaries: {},
+		incompleteFallbackMessage: '',
+		lang: this.lang
 	};
 
 	// XXX: unable to use `for-of` here, as doing so would
@@ -85,6 +89,16 @@ Audit.prototype._setDefaultLocale = function() {
 		locale.rules[id] = { description, help };
 	}
 
+	const failureSummaries = Object.keys(this.data.failureSummaries);
+	for (let i = 0; i < failureSummaries.length; i++) {
+		const type = failureSummaries[i];
+		const failureSummary = this.data.failureSummaries[type];
+		const { failureMessage } = failureSummary;
+		locale.failureSummaries[type] = { failureMessage };
+	}
+
+	locale.incompleteFallbackMessage = this.data.incompleteFallbackMessage;
+
 	this._defaultLocale = locale;
 };
 
@@ -176,6 +190,34 @@ const mergeRuleLocale = (a, b) => {
 	};
 };
 
+/**
+ * Merge two failure messages (a, b), favoring `b`.
+ */
+
+const mergeFailureMessage = (a, b) => {
+	let { failureMessage } = b;
+	// If the message(s) are Strings, they have not yet been run
+	// thru doT (which will return a Function).
+	if (typeof failureMessage === 'string') {
+		failureMessage = axe.imports.doT.compile(failureMessage);
+	}
+	return {
+		...a,
+		failureMessage: failureMessage || a.failureMessage
+	};
+};
+
+/**
+ * Merge two incomplete fallback messages (a, b), favoring `b`.
+ */
+
+const mergeFallbackMessage = (a, b) => {
+	if (typeof b === 'string') {
+		b = axe.imports.doT.compile(b);
+	}
+	return b || a;
+};
+
 /**
  * Apply locale for the given `checks`.
  */
@@ -207,6 +249,24 @@ Audit.prototype._applyRuleLocale = function(rules) {
 	}
 };
 
+/**
+ * Apply locale for the given failureMessage
+ */
+
+Audit.prototype._applyFailureSummaries = function(messages) {
+	const keys = Object.keys(messages);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		if (!this.data.failureSummaries[key]) {
+			throw new Error(`Locale provided for unknown failureMessage: "${key}"`);
+		}
+		this.data.failureSummaries[key] = mergeFailureMessage(
+			this.data.failureSummaries[key],
+			messages[key]
+		);
+	}
+};
+
 /**
  * Apply the given `locale`.
  *
@@ -223,6 +283,21 @@ Audit.prototype.applyLocale = function(locale) {
 	if (locale.rules) {
 		this._applyRuleLocale(locale.rules);
 	}
+
+	if (locale.failureSummaries) {
+		this._applyFailureSummaries(locale.failureSummaries, 'failureSummaries');
+	}
+
+	if (locale.incompleteFallbackMessage) {
+		this.data.incompleteFallbackMessage = mergeFallbackMessage(
+			this.data.incompleteFallbackMessage,
+			locale.incompleteFallbackMessage
+		);
+	}
+
+	if (locale.lang) {
+		this.lang = locale.lang;
+	}
 };
 
 /**
@@ -233,6 +308,7 @@ Audit.prototype._init = function() {
 
 	axe.commons = commons = audit.commons;
 
+	this.lang = audit.lang || 'en';
 	this.reporter = audit.reporter;
 	this.commands = {};
 	this.rules = [];
@@ -436,21 +512,20 @@ Audit.prototype.run = function(context, options, resolve, reject) {
 	const preloaderQueue = axe.utils.queue();
 	// defer preload if preload dependent rules exist
 	if (runLaterRules.length) {
-		preloaderQueue.defer((res, rej) => {
+		preloaderQueue.defer(resolve => {
 			// handle both success and fail of preload
 			// and resolve, to allow to run all checks
 			axe.utils
 				.preload(options)
-				.then(preloadResults => {
-					// pluck first item in results (because it is a queue - meh!) and resolve
-					const assets = preloadResults[0];
-					res(assets);
-				})
+				.then(assets => resolve(assets))
 				.catch(err => {
-					// resolve as undefined, to allow rule.run to continue
+					/**
+					 * Note:
+					 * we do not reject, to allow other (non-preload) rules to `run`
+					 * -> instead we resolve as `undefined`
+					 */
 					console.warn(`Couldn't load preload assets: `, err);
-					const assets = undefined;
-					res(assets);
+					resolve(undefined);
 				});
 		});
 	}
@@ -526,9 +601,9 @@ Audit.prototype.after = function(results, options) {
 	return results.map(function(ruleResult) {
 		var rule = axe.utils.findBy(rules, 'id', ruleResult.id);
 		if (!rule) {
-			// If you see this, you're probably running the Mocha tests with the aXe extension installed
+			// If you see this, you're probably running the Mocha tests with the axe extension installed
 			throw new Error(
-				'Result for unknown rule. You may be running mismatch aXe-core versions'
+				'Result for unknown rule. You may be running mismatch axe-core versions'
 			);
 		}
 
@@ -552,7 +627,6 @@ Audit.prototype.getRule = function(ruleId) {
  * @return {Object}          Validated options object
  */
 Audit.prototype.normalizeOptions = function(options) {
-	/* eslint max-statements: ["error", 22] */
 	'use strict';
 	var audit = this;
 
@@ -644,7 +718,7 @@ Audit.prototype.setBranding = function(branding) {
 /**
  * For all the rules, create the helpUrl and add it to the data for that rule
  */
-function getHelpUrl({ brand, application }, ruleId, version) {
+function getHelpUrl({ brand, application, lang }, ruleId, version) {
 	return (
 		axe.constants.helpUrlBase +
 		brand +
@@ -653,7 +727,8 @@ function getHelpUrl({ brand, application }, ruleId, version) {
 		'/' +
 		ruleId +
 		'?application=' +
-		application
+		encodeURIComponent(application) +
+		(lang && lang !== 'en' ? '&lang=' + encodeURIComponent(lang) : '')
 	);
 }
 

data/node_modules/axe-core/lib/core/base/cache.js

@@ -0,0 +1,33 @@
+(function() {
+	'use strict';
+	let _cache = {};
+
+	const cache = {
+		/**
+		 * Set an item in the cache.
+		 * @param {String} key - Name of the key.
+		 * @param {*} value - Value to store.
+		 */
+		set(key, value) {
+			_cache[key] = value;
+		},
+
+		/**
+		 * Retrieve an item from the cache.
+		 * @param {String} key - Name of the key the value was stored as.
+		 * @returns {*} The item stored
+		 */
+		get(key) {
+			return _cache[key];
+		},
+
+		/**
+		 * Clear the cache.
+		 */
+		clear() {
+			_cache = {};
+		}
+	};
+
+	axe._cache = cache;
+})();

data/node_modules/axe-core/lib/core/base/check.js

@@ -58,7 +58,6 @@ Check.prototype.enabled = true;
  * @param  {Function} callback Function to fire when check is complete
  */
 Check.prototype.run = function(node, options, context, resolve, reject) {
-	/* eslint max-statements: ["error", 17] */
 	'use strict';
 	options = options || {};
 	var enabled = options.hasOwnProperty('enabled')
@@ -105,6 +104,54 @@ Check.prototype.run = function(node, options, context, resolve, reject) {
 	}
 };
 
+/**
+ * Run the check's evaluate function (call `this.evaluate(node, options)`) synchronously
+ * @param  {HTMLElement} node  The node to test
+ * @param  {Object} options    The options that override the defaults and provide additional
+ *                             information for the check
+ */
+Check.prototype.runSync = function(node, options, context) {
+	options = options || {};
+	const { enabled = this.enabled } = options;
+
+	if (!enabled) {
+		return null;
+	}
+
+	const checkOptions = options.options || this.options;
+	const checkResult = new CheckResult(this);
+	const checkHelper = axe.utils.checkHelper(checkResult, options);
+
+	// throw error if a check is run that requires async behavior
+	checkHelper.async = function() {
+		throw new Error('Cannot run async check while in a synchronous run');
+	};
+
+	let result;
+
+	try {
+		result = this.evaluate.call(
+			checkHelper,
+			node.actualNode,
+			checkOptions,
+			node,
+			context
+		);
+	} catch (e) {
+		// In the "Audit#run: should run all the rules" test, there is no `node` here. I do
+		// not know if this is intentional or not, so to be safe, we guard against the
+		// possible reference error.
+		if (node && node.actualNode) {
+			// Save a reference to the node we errored on for futher debugging.
+			e.errorNode = new DqElement(node.actualNode).toJSON();
+		}
+		throw e;
+	}
+
+	checkResult.result = result;
+	return checkResult;
+};
+
 /**
  * Override a check's settings after construction to allow for changing options
  * without having to implement the entire check

data/node_modules/axe-core/lib/core/base/context.js

@@ -68,7 +68,6 @@ function pushUniqueFrameSelector(context, type, selectorArray) {
  * @return {Object}         Normalized context spec to include both `include` and `exclude` arrays
  */
 function normalizeContext(context) {
-	/*eslint complexity: ["error", 13] */
 	'use strict';
 
 	// typeof NodeList.length in PhantomJS === function
@@ -135,7 +134,7 @@ function parseSelectorArray(context, type) {
 			//eslint no-loop-func:0
 			result = result.concat(
 				nodeList.map(node => {
-					return axe.utils.getNodeFromTree(context.flatTree[0], node);
+					return axe.utils.getNodeFromTree(node);
 				})
 			);
 			break;
@@ -147,7 +146,7 @@ function parseSelectorArray(context, type) {
 				//eslint no-loop-func:0
 				result = result.concat(
 					nodeList.map(node => {
-						return axe.utils.getNodeFromTree(context.flatTree[0], node);
+						return axe.utils.getNodeFromTree(node);
 					})
 				);
 			}
@@ -155,7 +154,7 @@ function parseSelectorArray(context, type) {
 			if (item.documentElement instanceof Node) {
 				result.push(context.flatTree[0]);
 			} else {
-				result.push(axe.utils.getNodeFromTree(context.flatTree[0], item));
+				result.push(axe.utils.getNodeFromTree(item));
 			}
 		}
 	}
@@ -196,17 +195,19 @@ function validateContext(context) {
 function getRootNode({ include, exclude }) {
 	const selectors = Array.from(include).concat(Array.from(exclude));
 	// Find the first Element.ownerDocument or Document
-	const localDocument = selectors.reduce((result, item) => {
-		if (result) {
-			return result;
-		} else if (item instanceof Element) {
-			return item.ownerDocument;
-		} else if (item instanceof Document) {
-			return item;
+	for (var i = 0; i < selectors.length; ++i) {
+		var item = selectors[i];
+
+		if (item instanceof Element) {
+			return item.ownerDocument.documentElement;
+		}
+
+		if (item instanceof Document) {
+			return item.documentElement;
 		}
-	}, null);
+	}
 
-	return (localDocument || document).documentElement;
+	return document.documentElement;
 }
 
 /**
@@ -230,7 +231,7 @@ function getRootNode({ include, exclude }) {
  * @param {Object} spec Configuration or "specification" object
  */
 function Context(spec) {
-	/* eslint max-statements:["error",22], no-unused-vars:0 */
+	/* eslint no-unused-vars:0 */
 	'use strict';
 
 	this.frames = [];