govuk_publishing_components 30.3.0 → 30.5.0

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

@@ -1,110 +0,0 @@
-function createLocalVariables(vNodes, anyLevel, thisLevel, parentShadowId) {
-	let retVal = {
-		vNodes: vNodes.slice(),
-		anyLevel: anyLevel,
-		thisLevel: thisLevel,
-		parentShadowId: parentShadowId
-	};
-	retVal.vNodes.reverse();
-	return retVal;
-}
-
-function matchExpressions(domTree, expressions, filter) {
-	let stack = [];
-	let vNodes = Array.isArray(domTree) ? domTree : [domTree];
-	let currentLevel = createLocalVariables(
-		vNodes,
-		expressions,
-		[],
-		domTree[0].shadowId
-	);
-	let result = [];
-
-	while (currentLevel.vNodes.length) {
-		let vNode = currentLevel.vNodes.pop();
-		let childOnly = []; // we will add hierarchical '>' selectors here
-		let childAny = [];
-		let combined = currentLevel.anyLevel.slice().concat(currentLevel.thisLevel);
-		let added = false;
-		// see if node matches
-		for (let i = 0; i < combined.length; i++) {
-			let exp = combined[i];
-			if (
-				(!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
-				axe.utils.matchesExpression(vNode, exp[0])
-			) {
-				if (exp.length === 1) {
-					if (!added && (!filter || filter(vNode))) {
-						result.push(vNode);
-						added = true;
-					}
-				} else {
-					let rest = exp.slice(1);
-					if ([' ', '>'].includes(rest[0].combinator) === false) {
-						throw new Error(
-							'axe.utils.querySelectorAll does not support the combinator: ' +
-								exp[1].combinator
-						);
-					}
-					if (rest[0].combinator === '>') {
-						// add the rest to the childOnly array
-						childOnly.push(rest);
-					} else {
-						// add the rest to the childAny array
-						childAny.push(rest);
-					}
-				}
-			}
-			if (
-				(!exp[0].id || vNode.shadowId === currentLevel.parentShadowId) &&
-				currentLevel.anyLevel.includes(exp)
-			) {
-				childAny.push(exp);
-			}
-		}
-
-		if (vNode.children && vNode.children.length) {
-			stack.push(currentLevel);
-			currentLevel = createLocalVariables(
-				vNode.children,
-				childAny,
-				childOnly,
-				vNode.shadowId
-			);
-		}
-		// check for "return"
-		while (!currentLevel.vNodes.length && stack.length) {
-			currentLevel = stack.pop();
-		}
-	}
-	return result;
-}
-
-/**
- * querySelectorAll implementation that operates on the flattened tree (supports shadow DOM)
- * @method querySelectorAll
- * @memberof axe.utils
- * @param	{NodeList} domTree flattened tree collection to search
- * @param	{String} selector String containing one or more CSS selectors separated by commas
- * @return {NodeList} Elements matched by any of the selectors
- */
-axe.utils.querySelectorAll = function(domTree, selector) {
-	return axe.utils.querySelectorAllFilter(domTree, selector);
-};
-
-/**
- * querySelectorAllFilter implements querySelectorAll on the virtual DOM with
- * ability to filter the returned nodes using an optional supplied filter function
- *
- * @method querySelectorAllFilter
- * @memberof axe.utils
- * @param	{NodeList} domTree flattened tree collection to search
- * @param	{String} selector String containing one or more CSS selectors separated by commas
- * @param	{Function} filter function (optional)
- * @return {Array} Elements matched by any of the selectors and filtered by the filter function
- */
-axe.utils.querySelectorAllFilter = function(domTree, selector, filter) {
-	domTree = Array.isArray(domTree) ? domTree : [domTree];
-	const expressions = axe.utils.convertSelector(selector);
-	return matchExpressions(domTree, expressions, filter);
-};

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

@@ -1,138 +0,0 @@
-(function() {
-	'use strict';
-	function noop() {}
-	function funcGuard(f) {
-		if (typeof f !== 'function') {
-			throw new TypeError('Queue methods require functions as arguments');
-		}
-	}
-
-	/**
-	 * Create an asynchronous "queue", list of functions to be invoked in parallel, but not necessarily returned in order
-	 * @return {Queue} The newly generated "queue"
-	 */
-	function queue() {
-		var tasks = [];
-		var started = 0;
-		var remaining = 0; // number of tasks not yet finished
-		var completeQueue = noop;
-		var complete = false;
-		var err;
-
-		// By default, wait until the next tick,
-		// if no catch was set, throw to console.
-		var defaultFail = function(e) {
-			err = e;
-			setTimeout(function() {
-				if (err !== undefined && err !== null) {
-					axe.log('Uncaught error (of queue)', err);
-				}
-			}, 1);
-		};
-		var failed = defaultFail;
-
-		function createResolve(i) {
-			return function(r) {
-				tasks[i] = r;
-				remaining -= 1;
-				if (!remaining && completeQueue !== noop) {
-					complete = true;
-					completeQueue(tasks);
-				}
-			};
-		}
-
-		function abort(msg) {
-			// reset tasks
-			completeQueue = noop;
-
-			// notify catch
-			failed(msg);
-			// return unfinished work
-			return tasks;
-		}
-
-		function pop() {
-			var length = tasks.length;
-			for (; started < length; started++) {
-				var task = tasks[started];
-
-				try {
-					task.call(null, createResolve(started), abort);
-				} catch (e) {
-					abort(e);
-				}
-			}
-		}
-
-		var q = {
-			/**
-			 * Defer a function that may or may not run asynchronously.
-			 *
-			 * First parameter should be the function to execute with subsequent
-			 * parameters being passed as arguments to that function
-			 */
-			defer: function(fn) {
-				if (typeof fn === 'object' && fn.then && fn.catch) {
-					var defer = fn;
-					fn = function(resolve, reject) {
-						defer.then(resolve).catch(reject);
-					};
-				}
-				funcGuard(fn);
-				if (err !== undefined) {
-					return;
-				} else if (complete) {
-					throw new Error('Queue already completed');
-				}
-
-				tasks.push(fn);
-				++remaining;
-				pop();
-				return q;
-			},
-
-			/**
-			 * The callback to execute once all "deferred" functions have completed.  Will only be invoked once.
-			 * @param  {Function} f The callback, receives an array of the return/callbacked
-			 * values of each of the "deferred" functions
-			 */
-			then: function(fn) {
-				funcGuard(fn);
-				if (completeQueue !== noop) {
-					throw new Error('queue `then` already set');
-				}
-				if (!err) {
-					completeQueue = fn;
-					if (!remaining) {
-						complete = true;
-						completeQueue(tasks);
-					}
-				}
-				return q;
-			},
-
-			catch: function(fn) {
-				funcGuard(fn);
-				if (failed !== defaultFail) {
-					throw new Error('queue `catch` already set');
-				}
-				if (!err) {
-					failed = fn;
-				} else {
-					fn(err);
-					err = null;
-				}
-				return q;
-			},
-			/**
-			 * Abort the "queue" and prevent `then` function from firing
-			 * @param  {Function} fn The callback to execute; receives an array of the results which have completed
-			 */
-			abort: abort
-		};
-		return q;
-	}
-
-	axe.utils.queue = queue;
-})();

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

@@ -1,261 +0,0 @@
-/*global uuid, utils, axe */
-(function(exports) {
-	'use strict';
-	var messages = {},
-		subscribers = {},
-		errorTypes = Object.freeze([
-			'EvalError',
-			'RangeError',
-			'ReferenceError',
-			'SyntaxError',
-			'TypeError',
-			'URIError'
-		]);
-
-	/**
-	 * get the unique string to be used to identify our instance of axe
-	 * @private
-	 */
-	function _getSource() {
-		var application = 'axeAPI',
-			version = '',
-			src;
-		if (typeof axe !== 'undefined' && axe._audit && axe._audit.application) {
-			application = axe._audit.application;
-		}
-		if (typeof axe !== 'undefined') {
-			version = axe.version;
-		}
-		src = application + '.' + version;
-		return src;
-	}
-	/**
-	 * Verify the received message is from the "respondable" module
-	 * @private
-	 * @param  {Object} postedMessage The message received via postMessage
-	 * @return {Boolean}              `true` if the message is verified from respondable
-	 */
-	function verify(postedMessage) {
-		if (
-			// Check incoming message is valid
-			typeof postedMessage === 'object' &&
-			typeof postedMessage.uuid === 'string' &&
-			postedMessage._respondable === true
-		) {
-			var messageSource = _getSource();
-			return (
-				// Check the version matches
-				postedMessage._source === messageSource ||
-				// Allow free communication with axe test
-				postedMessage._source === 'axeAPI.x.y.z' ||
-				messageSource === 'axeAPI.x.y.z'
-			);
-		}
-		return false;
-	}
-
-	/**
-	 * Posts the message to correct frame.
-	 * This abstraction necessary because IE9 & 10 do not support posting Objects; only strings
-	 * @private
-	 * @param  {Window}   win      The `window` to post the message to
-	 * @param  {String}   topic    The topic of the message
-	 * @param  {Object}   message  The message content
-	 * @param  {String}   uuid     The UUID, or pseudo-unique ID of the message
-	 * @param  {Boolean}  keepalive Whether to allow multiple responses - default is false
-	 * @param  {Function} callback The function to invoke when/if the message is responded to
-	 */
-	function post(win, topic, message, uuid, keepalive, callback) {
-		var error;
-		if (message instanceof Error) {
-			error = {
-				name: message.name,
-				message: message.message,
-				stack: message.stack
-			};
-			message = undefined;
-		}
-
-		var data = {
-			uuid: uuid,
-			topic: topic,
-			message: message,
-			error: error,
-			_respondable: true,
-			_source: _getSource(),
-			_axeuuid: axe._uuid,
-			_keepalive: keepalive
-		};
-
-		var axeRespondables = axe._cache.get('axeRespondables');
-		if (!axeRespondables) {
-			axeRespondables = {};
-			axe._cache.set('axeRespondables', axeRespondables);
-		}
-		axeRespondables[uuid] = true;
-		if (typeof callback === 'function') {
-			messages[uuid] = callback;
-		}
-
-		win.postMessage(JSON.stringify(data), '*');
-	}
-
-	/**
-	 * Post a message to a window who may or may not respond to it.
-	 * @param  {Window}   win      The window to post the message to
-	 * @param  {String}   topic    The topic of the message
-	 * @param  {Object}   message  The message content
-	 * @param  {Boolean}  keepalive Whether to allow multiple responses - default is false
-	 * @param  {Function} callback The function to invoke when/if the message is responded to
-	 */
-	function respondable(win, topic, message, keepalive, callback) {
-		var id = uuid.v1();
-		post(win, topic, message, id, keepalive, callback);
-	}
-
-	/**
-	 * Subscribe to messages sent via the `respondable` module.
-	 *
-	 * Axe._load uses this to listen for messages from other frames
-	 *
-	 * @param  {String}   topic    The topic to listen to
-	 * @param  {Function} callback The function to invoke when a message is received
-	 */
-	respondable.subscribe = function(topic, callback) {
-		subscribers[topic] = callback;
-	};
-
-	/**
-	 * checks if the current context is inside a frame
-	 * @return {Boolean}
-	 */
-	respondable.isInFrame = function(win) {
-		win = win || window;
-		return !!win.frameElement;
-	};
-
-	/**
-	 * Helper closure to create a function that may be used to respond to a message
-	 * @private
-	 * @param  {Window} source The window from which the message originated
-	 * @param  {String} topic  The topic of the message
-	 * @param  {String} uuid   The "unique" ID of the original message
-	 * @return {Function}      A function that may be invoked to respond to the message
-	 */
-	function createResponder(source, topic, uuid) {
-		return function(message, keepalive, callback) {
-			post(source, topic, message, uuid, keepalive, callback);
-		};
-	}
-
-	/**
-	 * Publishes the "respondable" message to the appropriate subscriber
-	 * @private
-	 * @param  {Window}  source    The window from which the message originated
-	 * @param  {Object}  data      The data sent with the message
-	 * @param  {Boolean} keepalive Whether to allow multiple responses - default is false
-	 */
-	function publish(source, data, keepalive) {
-		var topic = data.topic;
-		var subscriber = subscribers[topic];
-
-		if (subscriber) {
-			var responder = createResponder(source, null, data.uuid);
-			subscriber(data.message, keepalive, responder);
-		}
-	}
-
-	/**
-	 * Convert a javascript Error into something that can be stringified
-	 * @param  {Error} error  Any type of error
-	 * @return {Object}       Processable object
-	 */
-	function buildErrorObject(error) {
-		var msg = error.message || 'Unknown error occurred';
-		var errorName = errorTypes.includes(error.name) ? error.name : 'Error';
-		var ErrConstructor = window[errorName] || Error;
-
-		if (error.stack) {
-			msg += '\n' + error.stack.replace(error.message, '');
-		}
-		return new ErrConstructor(msg);
-	}
-
-	/**
-	 * Parse the received message for processing
-	 * @param  {string} dataString Message received
-	 * @return {object}            Object to be used for pub/sub
-	 */
-	function parseMessage(dataString) {
-		/*eslint no-empty: 0*/
-		var data;
-		if (typeof dataString !== 'string') {
-			return;
-		}
-
-		try {
-			data = JSON.parse(dataString);
-		} catch (ex) {}
-
-		if (!verify(data)) {
-			return;
-		}
-
-		if (typeof data.error === 'object') {
-			data.error = buildErrorObject(data.error);
-		} else {
-			data.error = undefined;
-		}
-		return data;
-	}
-
-	if (typeof window.addEventListener === 'function') {
-		window.addEventListener(
-			'message',
-			function(e) {
-				var data = parseMessage(e.data);
-				if (!data || !data._axeuuid) {
-					return;
-				}
-
-				var uuid = data.uuid;
-
-				/**
-				 * NOTE: messages from other contexts (frames) in response
-				 * to a message should not contain the same axe._uuid. We
-				 * ignore these messages to prevent rogue postMessage
-				 * handlers reflecting our messages.
-				 * @see https://github.com/dequelabs/axe-core/issues/1754
-				 */
-				var axeRespondables = axe._cache.get('axeRespondables') || {};
-				if (axeRespondables[uuid] && data._axeuuid === axe._uuid) {
-					return;
-				}
-
-				var keepalive = data._keepalive;
-				var callback = messages[uuid];
-
-				if (callback) {
-					var result = data.error || data.message;
-					var responder = createResponder(e.source, data.topic, uuid);
-					callback(result, keepalive, responder);
-
-					if (!keepalive) {
-						delete messages[uuid];
-					}
-				}
-
-				if (!data.error) {
-					try {
-						publish(e.source, data, keepalive);
-					} catch (err) {
-						post(e.source, null, err, uuid, false);
-					}
-				}
-			},
-			false
-		);
-	}
-
-	exports.respondable = respondable;
-})(utils);

data/node_modules/axe-core/lib/core/utils/rule-should-run.js

@@ -1,82 +0,0 @@
-/**
- * Check if a rule matches the value of runOnly type=tag
- * @private
- * @param  {object} rule
- * @param  {object}	runOnly Value of runOnly with type=tags
- * @return {bool}
- */
-function matchTags(rule, runOnly) {
-	'use strict';
-	var include, exclude, matching;
-	var defaultExclude =
-		axe._audit && axe._audit.tagExclude ? axe._audit.tagExclude : [];
-
-	// normalize include/exclude
-	if (runOnly.hasOwnProperty('include') || runOnly.hasOwnProperty('exclude')) {
-		// Wrap include and exclude if it's not already an array
-		include = runOnly.include || [];
-		include = Array.isArray(include) ? include : [include];
-
-		exclude = runOnly.exclude || [];
-		exclude = Array.isArray(exclude) ? exclude : [exclude];
-		// add defaults, unless mentioned in include
-		exclude = exclude.concat(
-			defaultExclude.filter(function(tag) {
-				return include.indexOf(tag) === -1;
-			})
-		);
-
-		// Otherwise, only use the include value, ignore exclude
-	} else {
-		include = Array.isArray(runOnly) ? runOnly : [runOnly];
-		// exclude the defaults not included
-		exclude = defaultExclude.filter(function(tag) {
-			return include.indexOf(tag) === -1;
-		});
-	}
-
-	matching = include.some(function(tag) {
-		return rule.tags.indexOf(tag) !== -1;
-	});
-	if (matching || (include.length === 0 && rule.enabled !== false)) {
-		return exclude.every(function(tag) {
-			return rule.tags.indexOf(tag) === -1;
-		});
-	} else {
-		return false;
-	}
-}
-
-/**
- * Determines whether a rule should run
- * @param  {Rule}    rule     The rule to test
- * @param  {Context} context  The context of the Audit
- * @param  {Object}  options  Options object
- * @return {Boolean}
- */
-axe.utils.ruleShouldRun = function(rule, context, options) {
-	'use strict';
-	var runOnly = options.runOnly || {};
-	var ruleOptions = (options.rules || {})[rule.id];
-
-	// Never run page level rules if the context is not on the page
-	if (rule.pageLevel && !context.page) {
-		return false;
-
-		// First, runOnly type rule overrides anything else
-	} else if (runOnly.type === 'rule') {
-		return runOnly.values.indexOf(rule.id) !== -1;
-
-		// Second, if options.rules[rule].enabled is set, it overrides all
-	} else if (ruleOptions && typeof ruleOptions.enabled === 'boolean') {
-		return ruleOptions.enabled;
-
-		// Third, if tags are set, look at those
-	} else if (runOnly.type === 'tag' && runOnly.values) {
-		return matchTags(rule, runOnly.values);
-
-		// If nothing is set, only check for default excludes
-	} else {
-		return matchTags(rule, []);
-	}
-};

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

@@ -1,57 +0,0 @@
-/**
- * set the scroll position of an element
- */
-function setScroll(elm, top, left) {
-	if (elm === window) {
-		return elm.scroll(left, top);
-	} else {
-		elm.scrollTop = top;
-		elm.scrollLeft = left;
-	}
-}
-
-/**
- * Create an array scroll positions from descending elements
- */
-function getElmScrollRecursive(root) {
-	// Need to also get .childNodes since SVGs in IE don't have .children.
-	return Array.from(root.children || root.childNodes || []).reduce(
-		(scrolls, elm) => {
-			const scroll = axe.utils.getScroll(elm);
-			if (scroll) {
-				scrolls.push(scroll);
-			}
-			return scrolls.concat(getElmScrollRecursive(elm));
-		},
-		[]
-	);
-}
-
-/**
- * Get the scroll position of all scrollable elements in a page
- */
-axe.utils.getScrollState = function getScrollState(win = window) {
-	const root = win.document.documentElement;
-	const windowScroll = [
-		win.pageXOffset !== undefined
-			? {
-					elm: win,
-					top: win.pageYOffset,
-					left: win.pageXOffset
-			  }
-			: {
-					elm: root,
-					top: root.scrollTop,
-					left: root.scrollLeft
-			  }
-	];
-
-	return windowScroll.concat(getElmScrollRecursive(document.body));
-};
-
-/**
- * set the scroll position of all items in the scrollState array
- */
-axe.utils.setScrollState = function setScrollState(scrollState) {
-	scrollState.forEach(({ elm, top, left }) => setScroll(elm, top, left));
-};