govuk_publishing_components 30.4.1 → 30.5.2

data/node_modules/axe-core/lib/commons/color/element-has-image.js

@@ -1,36 +0,0 @@
-/* global color */
-
-/**
- * Reports if an element has a background image or gradient
- *
- * @method elementHasImage
- * @memberof axe.commons.color
- * @private
- * @param {Element} elm
- * @param {Object|null} style
- * @return {Boolean}
- */
-color.elementHasImage = function elementHasImage(elm, style) {
-	const graphicNodes = ['IMG', 'CANVAS', 'OBJECT', 'IFRAME', 'VIDEO', 'SVG'];
-	const nodeName = elm.nodeName.toUpperCase();
-
-	if (graphicNodes.includes(nodeName)) {
-		axe.commons.color.incompleteData.set('bgColor', 'imgNode');
-		return true;
-	}
-
-	style = style || window.getComputedStyle(elm);
-
-	const bgImageStyle = style.getPropertyValue('background-image');
-	const hasBgImage = bgImageStyle !== 'none';
-
-	if (hasBgImage) {
-		const hasGradient = /gradient/.test(bgImageStyle);
-		axe.commons.color.incompleteData.set(
-			'bgColor',
-			hasGradient ? 'bgGradient' : 'bgImage'
-		);
-	}
-
-	return hasBgImage;
-};

data/node_modules/axe-core/lib/commons/color/element-is-distinct.js

@@ -1,88 +0,0 @@
-/* global color */
-
-/**
- * Creates a string array of fonts for given CSSStyleDeclaration object
- * @private
- * @param {Object} style CSSStyleDeclaration object
- * @return {Array}
- */
-function _getFonts(style) {
-	return style
-		.getPropertyValue('font-family')
-		.split(/[,;]/g)
-		.map(function(font) {
-			return font.trim().toLowerCase();
-		});
-}
-
-/**
- * Determine if the text content of two nodes is styled in a way that they can be distinguished without relying on color
- * @method elementIsDistinct
- * @memberof axe.commons.color
- * @instance
- * @param  {HTMLElement} node The element to check
- * @param  {HTMLElement} ancestorNode The ancestor node element to check
- * @return {Boolean}
- */
-function elementIsDistinct(node, ancestorNode) {
-	var nodeStyle = window.getComputedStyle(node);
-
-	// Check if the link has a background
-	if (nodeStyle.getPropertyValue('background-image') !== 'none') {
-		return true;
-	}
-
-	// Check if the link has a border or outline
-	var hasBorder = ['border-bottom', 'border-top', 'outline'].reduce(function(
-		result,
-		edge
-	) {
-		var borderClr = new color.Color();
-		borderClr.parseRgbString(nodeStyle.getPropertyValue(edge + '-color'));
-
-		// Check if a border/outline was specified
-		return (
-			result ||
-			// or if the current border edge / outline
-			(nodeStyle.getPropertyValue(edge + '-style') !== 'none' &&
-				parseFloat(nodeStyle.getPropertyValue(edge + '-width')) > 0 &&
-				borderClr.alpha !== 0)
-		);
-	},
-	false);
-
-	if (hasBorder) {
-		return true;
-	}
-
-	var parentStyle = window.getComputedStyle(ancestorNode);
-	// Compare fonts
-	if (_getFonts(nodeStyle)[0] !== _getFonts(parentStyle)[0]) {
-		return true;
-	}
-
-	var hasStyle = [
-		'text-decoration-line',
-		'text-decoration-style',
-		'font-weight',
-		'font-style',
-		'font-size'
-	].reduce(function(result, cssProp) {
-		return (
-			result ||
-			nodeStyle.getPropertyValue(cssProp) !==
-				parentStyle.getPropertyValue(cssProp)
-		);
-	}, false);
-
-	var tDec = nodeStyle.getPropertyValue('text-decoration');
-	if (tDec.split(' ').length < 3) {
-		// old style CSS text decoration
-		hasStyle =
-			hasStyle || tDec !== parentStyle.getPropertyValue('text-decoration');
-	}
-
-	return hasStyle;
-}
-
-color.elementIsDistinct = elementIsDistinct;

data/node_modules/axe-core/lib/commons/color/get-background-color.js

@@ -1,285 +0,0 @@
-/* global axe, color, dom */
-
-/**
- * Returns background color for element
- * Uses getBackgroundStack() to get all elements rendered underneath the current element,
- * to help determine the composite background color.
- *
- * @method getBackgroundColor
- * @memberof axe.commons.color
- * @param	{Element} elm Element to determine background color
- * @param	{Array}	 [bgElms=[]] elements to inspect
- * @returns {Color}
- */
-color.getBackgroundColor = function getBackgroundColor(elm, bgElms = []) {
-	let bgColors = [];
-	let elmStack = color.getBackgroundStack(elm);
-
-	// Search the stack until we have an alpha === 1 background
-	(elmStack || []).some(bgElm => {
-		const bgElmStyle = window.getComputedStyle(bgElm);
-
-		// Get the background color
-		let bgColor = color.getOwnBackgroundColor(bgElmStyle);
-
-		if (
-			// abort if a node is partially obscured and obscuring element has a background
-			elmPartiallyObscured(elm, bgElm, bgColor) ||
-			// OR if the background elm is a graphic
-			color.elementHasImage(bgElm, bgElmStyle)
-		) {
-			bgColors = null;
-			bgElms.push(bgElm);
-
-			return true;
-		}
-
-		if (bgColor.alpha !== 0) {
-			// store elements contributing to the br color.
-			bgElms.push(bgElm);
-			bgColors.push(bgColor);
-
-			// Exit if the background is opaque
-			return bgColor.alpha === 1;
-		} else {
-			return false;
-		}
-	});
-
-	if (bgColors !== null && elmStack !== null) {
-		// Mix the colors together, on top of a default white
-		bgColors.push(new color.Color(255, 255, 255, 1));
-		var colors = bgColors.reduce(color.flattenColors);
-		return colors;
-	}
-
-	return null;
-};
-
-/**
- * Get all elements rendered underneath the current element,
- * In the order they are displayed (front to back)
- *
- * @method getBackgroundStack
- * @memberof axe.commons.color
- * @param {Element} elm
- * @return {Array}
- */
-color.getBackgroundStack = function getBackgroundStack(elm) {
-	let elmStack = color.filteredRectStack(elm);
-
-	if (elmStack === null) {
-		return null;
-	}
-	elmStack = dom.reduceToElementsBelowFloating(elmStack, elm);
-	elmStack = sortPageBackground(elmStack);
-
-	// Return all elements BELOW the current element, null if the element is undefined
-	let elmIndex = elmStack.indexOf(elm);
-	if (calculateObscuringElement(elmIndex, elmStack, elm)) {
-		// if the total of the elements above our element results in total obscuring, return null
-		axe.commons.color.incompleteData.set('bgColor', 'bgOverlap');
-		return null;
-	}
-	return elmIndex !== -1 ? elmStack : null;
-};
-
-/**
- * Get filtered stack of block and inline elements, excluding line breaks
- * @method filteredRectStack
- * @memberof axe.commons.color
- * @param {Element} elm
- * @return {Array}
- */
-color.filteredRectStack = function filteredRectStack(elm) {
-	const rectStack = color.getRectStack(elm);
-
-	if (rectStack && rectStack.length === 1) {
-		return rectStack[0];
-	}
-
-	if (rectStack && rectStack.length > 1) {
-		const boundingStack = rectStack.shift();
-		let isSame;
-
-		// iterating over arrays of DOMRects
-		rectStack.forEach((rectList, index) => {
-			if (index === 0) {
-				return;
-			}
-			// if the stacks are the same, use the first one. otherwise, return null.
-			let rectA = rectStack[index - 1],
-				rectB = rectStack[index];
-
-			// if elements in clientRects are the same
-			// or the boundingClientRect contains the differing element, pass it
-			isSame =
-				rectA.every(
-					(element, elementIndex) => element === rectB[elementIndex]
-				) || boundingStack.includes(elm);
-		});
-		if (!isSame) {
-			axe.commons.color.incompleteData.set('bgColor', 'elmPartiallyObscuring');
-			return null;
-		}
-		// pass the first stack if it wasn't partially covered
-		return rectStack[0];
-	}
-
-	// rect outside of viewport
-	axe.commons.color.incompleteData.set('bgColor', 'outsideViewport');
-	return null;
-};
-
-/**
- * Get relevant stacks of block and inline elements, excluding line breaks
- * @method getRectStack
- * @memberof axe.commons.color
- * @param {Element} elm
- * @return {Array}
- */
-color.getRectStack = function(elm) {
-	const boundingStack = axe.commons.dom.getElementStack(elm);
-
-	// Handle inline elements spanning multiple lines to be evaluated
-	const filteredArr = axe.commons.dom.getTextElementStack(elm);
-
-	// If the element does not have multiple rects, like for display:block, return a single stack
-	if (!filteredArr || filteredArr.length <= 1) {
-		return [boundingStack];
-	}
-
-	if (filteredArr.some(stack => stack === undefined)) {
-		// Can be happen when one or more of the rects sits outside the viewport
-		return null;
-	}
-
-	// add bounding client rect stack for comparison later
-	filteredArr.splice(0, 0, boundingStack);
-	return filteredArr;
-};
-
-/**
- * Look at document and body elements for relevant background information
- * @method sortPageBackground
- * @private
- * @param {Array} elmStack
- * @returns {Array}
- */
-function sortPageBackground(elmStack) {
-	let bodyIndex = elmStack.indexOf(document.body);
-	let bgNodes = elmStack;
-
-	// Body can sometimes appear out of order in the stack:
-	//   1) Body is not the first element due to negative z-index elements
-	//   2) Elements are positioned outside of body's rect coordinates
-	//      (see https://github.com/dequelabs/axe-core/issues/1456)
-	// In those instances we want to reinsert body back into the element stack
-	// when not using the root document element as the html canvas for bgcolor
-	// prettier-ignore
-	let sortBodyElement =
-		bodyIndex > 1 || // negative z-index elements
-		bodyIndex === -1; // element does not intersect with body
-
-	if (
-		sortBodyElement &&
-		!color.elementHasImage(document.documentElement) &&
-		color.getOwnBackgroundColor(
-			window.getComputedStyle(document.documentElement)
-		).alpha === 0
-	) {
-		// Only remove document.body if it was originally contained within the element stack
-		if (bodyIndex > 1) {
-			bgNodes.splice(bodyIndex, 1);
-		}
-		// Remove document element since body will be used for bgcolor
-		bgNodes.splice(elmStack.indexOf(document.documentElement), 1);
-
-		// Put the body background as the lowest element
-		bgNodes.push(document.body);
-	}
-	return bgNodes;
-}
-
-/**
- * Determine if element is partially overlapped, triggering a Can't Tell result
- * @private
- * @param {Element} elm
- * @param {Element} bgElm
- * @param {Object} bgColor
- * @return {Boolean}
- */
-function elmPartiallyObscured(elm, bgElm, bgColor) {
-	var obscured =
-		elm !== bgElm && !dom.visuallyContains(elm, bgElm) && bgColor.alpha !== 0;
-	if (obscured) {
-		axe.commons.color.incompleteData.set('bgColor', 'elmPartiallyObscured');
-	}
-	return obscured;
-}
-
-/**
- * Calculate alpha transparency of a background element obscuring the current node
- * @private
- * @param {Number} elmIndex
- * @param {Array} elmStack
- * @param {Element} originalElm
- * @return {Number|undefined}
- */
-function calculateObscuringElement(elmIndex, elmStack, originalElm) {
-	if (elmIndex > 0) {
-		// there are elements above our element, check if they contribute to the background
-		for (var i = elmIndex - 1; i >= 0; i--) {
-			let bgElm = elmStack[i];
-			if (contentOverlapping(originalElm, bgElm)) {
-				return true;
-			} else {
-				// remove elements not contributing to the background
-				elmStack.splice(i, 1);
-			}
-		}
-	}
-
-	return false;
-}
-
-/**
- * Determines overlap of node's content with a bgNode. Used for inline elements
- * @private
- * @param {Element} targetElement
- * @param {Element} bgNode
- * @return {Boolean}
- */
-function contentOverlapping(targetElement, bgNode) {
-	// get content box of target element
-	// check to see if the current bgNode is overlapping
-	var targetRect = targetElement.getClientRects()[0];
-	var obscuringElements = dom.shadowElementsFromPoint(
-		targetRect.left,
-		targetRect.top
-	);
-	if (obscuringElements) {
-		for (var i = 0; i < obscuringElements.length; i++) {
-			if (
-				obscuringElements[i] !== targetElement &&
-				obscuringElements[i] === bgNode
-			) {
-				return true;
-			}
-		}
-	}
-	return false;
-}
-
-/**
- * Determines whether an element has a fully opaque background, whether solid color or an image
- * @param {Element} node
- * @return {Boolean} false if the background is transparent, true otherwise
- */
-dom.isOpaque = function(node) {
-	const style = window.getComputedStyle(node);
-	return (
-		color.elementHasImage(node, style) ||
-		color.getOwnBackgroundColor(style).alpha === 1
-	);
-};

data/node_modules/axe-core/lib/commons/color/get-foreground-color.js

@@ -1,61 +0,0 @@
-/* global axe, color */
-
-function getOpacity(node) {
-	if (!node) {
-		return 1;
-	}
-
-	const vNode = axe.utils.getNodeFromTree(node);
-
-	if (vNode && vNode._opacity !== undefined && vNode._opacity !== null) {
-		return vNode._opacity;
-	}
-
-	const nodeStyle = window.getComputedStyle(node);
-	const opacity = nodeStyle.getPropertyValue('opacity');
-	const finalOpacity = opacity * getOpacity(node.parentElement);
-
-	// cache the results of the getOpacity check on the parent tree
-	// so we don't have to look at the parent tree again for all its
-	// descendants
-	if (vNode) {
-		vNode._opacity = finalOpacity;
-	}
-
-	return finalOpacity;
-}
-
-/**
- * Returns the flattened foreground color of an element, or null if it can't be determined because
- * of transparency
- * @method getForegroundColor
- * @memberof axe.commons.color
- * @instance
- * @param {Element} node
- * @param {Boolean} noScroll (default false)
- * @param {Color} bgColor
- * @return {Color|null}
- */
-color.getForegroundColor = function(node, noScroll, bgColor) {
-	const nodeStyle = window.getComputedStyle(node);
-
-	const fgColor = new color.Color();
-	fgColor.parseRgbString(nodeStyle.getPropertyValue('color'));
-	const opacity = getOpacity(node);
-	fgColor.alpha = fgColor.alpha * opacity;
-	if (fgColor.alpha === 1) {
-		return fgColor;
-	}
-
-	if (!bgColor) {
-		bgColor = color.getBackgroundColor(node, [], noScroll);
-	}
-
-	if (bgColor === null) {
-		const reason = axe.commons.color.incompleteData.get('bgColor');
-		axe.commons.color.incompleteData.set('fgColor', reason);
-		return null;
-	}
-
-	return color.flattenColors(fgColor, bgColor);
-};

data/node_modules/axe-core/lib/commons/color/get-own-background-color.js

@@ -1,22 +0,0 @@
-/* global color */
-
-/**
- * Returns the non-alpha-blended background color of an element
- *
- * @method getOwnBackgroundColor
- * @memberof axe.commons.color
- *
- * @param {Object} elmStyle style of the element
- * @return {Color}
- */
-color.getOwnBackgroundColor = function getOwnBackgroundColor(elmStyle) {
-	const bgColor = new color.Color();
-	bgColor.parseRgbString(elmStyle.getPropertyValue('background-color'));
-
-	if (bgColor.alpha !== 0) {
-		const opacity = elmStyle.getPropertyValue('opacity');
-		bgColor.alpha = bgColor.alpha * opacity;
-	}
-
-	return bgColor;
-};

data/node_modules/axe-core/lib/commons/color/incomplete-data.js

@@ -1,50 +0,0 @@
-/* global color */
-
-/**
- * API for handling incomplete color data
- * @namespace axe.commons.color.incompleteData
- * @inner
- */
-
-color.incompleteData = (function() {
-	var data = {};
-	return {
-		/**
-		 * Store incomplete data by key with a string value
-		 * @method set
-		 * @memberof axe.commons.color.incompleteData
-		 * @instance
-		 * @param {String} key Identifier for missing data point (fgColor, bgColor, etc.)
-		 * @param {String} reason Missing data reason to match message template
-		 */
-		set: function(key, reason) {
-			if (typeof key !== 'string') {
-				throw new Error('Incomplete data: key must be a string');
-			}
-			if (reason) {
-				data[key] = reason;
-			}
-			return data[key];
-		},
-		/**
-		 * Get incomplete data by key
-		 * @method get
-		 * @memberof axe.commons.color.incompleteData
-		 * @instance
-		 * @param {String} key 	Identifier for missing data point (fgColor, bgColor, etc.)
-		 * @return {String} String for reason we couldn't tell
-		 */
-		get: function(key) {
-			return data[key];
-		},
-		/**
-		 * Clear incomplete data on demand
-		 * @method clear
-		 * @memberof axe.commons.color.incompleteData
-		 * @instance
-		 */
-		clear: function() {
-			data = {};
-		}
-	};
-})();

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

@@ -1,8 +0,0 @@
-/**
- * Namespace for color-related utilities.
- * @namespace commons.color
- * @memberof axe
- */
-
-var color = {};
-commons.color = color;

data/node_modules/axe-core/lib/commons/dom/elements-below-floating.js

@@ -1,39 +0,0 @@
-/* global dom */
-
-/**
- * Reduce an array of elements to only those that are below a 'floating' element.
- * @method reduceToElementsBelowFloating
- * @memberof axe.commons.dom
- * @instance
- * @param {Array} elements
- * @param {Element} targetNode
- * @returns {Array}
- */
-dom.reduceToElementsBelowFloating = function(elements, targetNode) {
-	var floatingPositions = ['fixed', 'sticky'],
-		finalElements = [],
-		targetFound = false,
-		index,
-		currentNode,
-		style;
-
-	// Filter out elements that are temporarily floating above the target
-	for (index = 0; index < elements.length; ++index) {
-		currentNode = elements[index];
-		if (currentNode === targetNode) {
-			targetFound = true;
-		}
-
-		style = window.getComputedStyle(currentNode);
-
-		if (!targetFound && floatingPositions.indexOf(style.position) !== -1) {
-			//Target was not found yet, so it must be under this floating thing (and will not always be under it)
-			finalElements = [];
-			continue;
-		}
-
-		finalElements.push(currentNode);
-	}
-
-	return finalElements;
-};

data/node_modules/axe-core/lib/commons/dom/find-elms-in-context.js

@@ -1,28 +0,0 @@
-/* global axe, dom */
-
-/**
- * Find elements referenced from a given context
- * @method findElmsInContext
- * @memberof axe.commons.dom
- * @instance
- * @param {Object} element
- * @param {String} element.context Element in the same context
- * @param {String} element.value Attribute value to search for
- * @param {String} element.attr Attribute name to search for
- * @param {String} element.elm NodeName to search for (optional)
- * @return {Array<Node>}
- */
-dom.findElmsInContext = function({ context, value, attr, elm = '' }) {
-	let root;
-	const escapedValue = axe.utils.escapeSelector(value);
-
-	if (context.nodeType === 9 || context.nodeType === 11) {
-		// It's already root
-		root = context;
-	} else {
-		root = dom.getRootNode(context);
-	}
-	return Array.from(
-		root.querySelectorAll(elm + '[' + attr + '=' + escapedValue + ']')
-	);
-};

data/node_modules/axe-core/lib/commons/dom/find-up.js

@@ -1,63 +0,0 @@
-/* global dom, axe */
-/**
- * Find the virtual node and call dom.fundUpVirtual
- *
- * **WARNING:** this should be used sparingly, as it's not even close to being performant
- * @method findUp
- * @memberof axe.commons.dom
- * @instance
- * @param {HTMLElement} element The starting HTMLElement
- * @param {String} target The selector for the HTMLElement
- * @return {HTMLElement|null} Either the matching HTMLElement or `null` if there was no match
- */
-dom.findUp = function(element, target) {
-	return dom.findUpVirtual(axe.utils.getNodeFromTree(element), target);
-};
-
-/**
- * recusively walk up the DOM, checking for a node which matches a selector
- *
- * **WARNING:** this should be used sparingly, as it's not even close to being performant
- * @method findUpVirtual
- * @memberof axe.commons.dom
- * @instance
- * @param {VirtualNode} element The starting virtualNode
- * @param {String} target The selector for the HTMLElement
- * @return {HTMLElement|null} Either the matching HTMLElement or `null` if there was no match
- */
-dom.findUpVirtual = function(element, target) {
-	let parent;
-
-	parent = element.actualNode;
-	// virtualNode will have a shadowId if the element lives inside a shadow DOM or is
-	// slotted into a shadow DOM
-	if (!element.shadowId && typeof element.actualNode.closest === 'function') {
-		// non-shadow DOM elements
-		let match = element.actualNode.closest(target);
-		if (match) {
-			return match;
-		}
-		return null;
-	}
-	// handle shadow DOM elements and older browsers
-	do {
-		// recursively walk up the DOM, checking each parent node
-		parent = parent.assignedSlot ? parent.assignedSlot : parent.parentNode;
-		if (parent && parent.nodeType === 11) {
-			parent = parent.host;
-		}
-	} while (
-		parent &&
-		!axe.utils.matchesSelector(parent, target) &&
-		parent !== document.documentElement
-	);
-
-	if (!parent) {
-		return null;
-	}
-
-	if (!axe.utils.matchesSelector(parent, target)) {
-		return null;
-	}
-	return parent;
-};