govuk_publishing_components 30.4.1 → 30.5.0

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

@@ -1,135 +0,0 @@
-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) {
-	if (node.namespaceURI === 'http://www.w3.org/2000/svg') {
-		return false;
-	}
-
-	return htmlTags.includes(node.nodeName.toLowerCase());
-};

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

@@ -1,40 +0,0 @@
-/* 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) {
-	if (node.shadowRoot) {
-		const nodeName = node.nodeName.toLowerCase();
-		if (
-			possibleShadowRoots.includes(nodeName) ||
-			/^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName)
-		) {
-			return true;
-		}
-	}
-	return false;
-};

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

@@ -1,14 +0,0 @@
-/**
- * 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/matches.js

@@ -1,263 +0,0 @@
-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)
-	);
-};

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

@@ -1,17 +0,0 @@
-/**
- * Memoize a function.
- * @method memoize
- * @memberof axe.utils
- * @param {Function} fn Function to memoize
- * @return {Function}
- */
-axe._memoizedFns = [];
-axe.utils.memoize = function(fn) {
-	// keep track of each function that is memoized so it can be cleared at
-	// the end of a run. each memoized function has its own cache, so there is
-	// no method to clear all memoized caches. instead, we have to clear each
-	// individual memoized function ourselves.
-	const memoized = axe.imports.memoize(fn);
-	axe._memoizedFns.push(memoized);
-	return memoized;
-};

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

@@ -1,116 +0,0 @@
-/**
- * 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;
-};

data/node_modules/axe-core/lib/core/utils/node-sorter.js

@@ -1,21 +0,0 @@
-/**
- * Array#sort callback to sort nodes by DOM order
- * @private
- * @param  {Node} nodeA
- * @param  {Node} nodeB
- * @return {Integer}   @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Sort
- */
-axe.utils.nodeSorter = function nodeSorter(nodeA, nodeB) {
-	/*eslint no-bitwise: 0 */
-	nodeA = nodeA.actualNode || nodeA;
-	nodeB = nodeB.actualNode || nodeB;
-	if (nodeA === nodeB) {
-		return 0;
-	}
-
-	if (nodeA.compareDocumentPosition(nodeB) & 4) {
-		return -1; // a before b
-	} else {
-		return 1; // b before a
-	}
-};

data/node_modules/axe-core/lib/core/utils/parse-crossorigin-stylesheet.js

@@ -1,54 +0,0 @@
-/**
- * Parse cross-origin stylesheets
- *
- * @method parseCrossOriginStylesheet
- * @memberof axe.utils
- * @param {String} url url from which to fetch stylesheet
- * @param {Object} options options object from `axe.utils.parseStylesheet`
- * @param {Array<Number>} priority sheet priority
- * @param {Array<String>} importedUrls urls of already imported stylesheets
- * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`
- * @returns {Promise}
- */
-axe.utils.parseCrossOriginStylesheet = function parseCrossOriginStylesheet(
-	url,
-	options,
-	priority,
-	importedUrls,
-	isCrossOrigin
-) {
-	const axiosOptions = {
-		method: 'get',
-		timeout: axe.constants.preload.timeout,
-		url
-	};
-
-	/**
-	 * Add `url` to `importedUrls`
-	 */
-	importedUrls.push(url);
-
-	/**
-	 * Fetch `cross-origin stylesheet` via axios
-	 */
-	return axe.imports.axios(axiosOptions).then(({ data }) => {
-		const result = options.convertDataToStylesheet({
-			data,
-			isCrossOrigin,
-			priority,
-			root: options.rootNode,
-			shadowId: options.shadowId
-		});
-
-		/**
-		 * Parse resolved stylesheet further for any `@import` styles
-		 */
-		return axe.utils.parseStylesheet(
-			result.sheet,
-			options,
-			priority,
-			importedUrls,
-			result.isCrossOrigin
-		);
-	});
-};