govuk_publishing_components 21.16.3 → 21.17.0

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

@@ -1,5 +1,30 @@
 /* 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
@@ -8,22 +33,26 @@
  * @instance
  * @param {Element} node
  * @param {Boolean} noScroll (default false)
+ * @param {Color} bgColor
  * @return {Color|null}
  */
-color.getForegroundColor = function(node, noScroll) {
-	var nodeStyle = window.getComputedStyle(node);
+color.getForegroundColor = function(node, noScroll, bgColor) {
+	const nodeStyle = window.getComputedStyle(node);
 
-	var fgColor = new color.Color();
+	const fgColor = new color.Color();
 	fgColor.parseRgbString(nodeStyle.getPropertyValue('color'));
-	var opacity = nodeStyle.getPropertyValue('opacity');
+	const opacity = getOpacity(node);
 	fgColor.alpha = fgColor.alpha * opacity;
 	if (fgColor.alpha === 1) {
 		return fgColor;
 	}
 
-	var bgColor = color.getBackgroundColor(node, [], noScroll);
+	if (!bgColor) {
+		bgColor = color.getBackgroundColor(node, [], noScroll);
+	}
+
 	if (bgColor === null) {
-		var reason = axe.commons.color.incompleteData.get('bgColor');
+		const reason = axe.commons.color.incompleteData.get('bgColor');
 		axe.commons.color.incompleteData.set('fgColor', reason);
 		return null;
 	}

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

@@ -0,0 +1,22 @@
+/* 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/dom/find-up.js

@@ -11,10 +11,7 @@
  * @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(axe._tree[0], element),
-		target
-	);
+	return dom.findUpVirtual(axe.utils.getNodeFromTree(element), target);
 };
 
 /**
@@ -29,7 +26,6 @@ dom.findUp = function(element, target) {
  * @return {HTMLElement|null} Either the matching HTMLElement or `null` if there was no match
  */
 dom.findUpVirtual = function(element, target) {
-	/*eslint complexity: ["error", 12]*/
 	let parent;
 
 	parent = element.actualNode;
@@ -56,6 +52,10 @@ dom.findUpVirtual = function(element, target) {
 		parent !== document.documentElement
 	);
 
+	if (!parent) {
+		return null;
+	}
+
 	if (!axe.utils.matchesSelector(parent, target)) {
 		return null;
 	}

data/node_modules/axe-core/lib/commons/dom/get-scroll-offset.js

@@ -1,5 +1,4 @@
 /* global dom */
-/*eslint complexity: ["error", 14]*/
 /**
  * Get the scroll offset of the document passed in
  * @method getScrollOffset

data/node_modules/axe-core/lib/commons/dom/get-tabbable-elements.js

@@ -1,7 +1,7 @@
 /* global dom */
 
 /**
- * Get all elements (including given node) that are part if the tab order
+ * Get all elements (including given node) that are part of the tab order
  * @method getTabbableElements
  * @memberof axe.commons.dom
  * @instance

data/node_modules/axe-core/lib/commons/dom/has-content-virtual.js

@@ -29,16 +29,17 @@ function hasChildTextNodes(elm) {
  * @instance
  * @param	{VirtualNode} elm Virtual Node to search
  * @param	{Boolean} noRecursion If true, only the element is checked, otherwise it will search all child nodes
+ * @param {Boolean} ignoreAria if true, ignores `aria label` computation for content deduction
  * @return {Boolean}
  */
-dom.hasContentVirtual = function(elm, noRecursion) {
+dom.hasContentVirtual = function(elm, noRecursion, ignoreAria) {
 	return (
 		// It has text
 		hasChildTextNodes(elm) ||
 		// It is a graphical element
 		dom.isVisualContent(elm.actualNode) ||
 		// It has an ARIA label
-		!!aria.labelVirtual(elm) ||
+		(!ignoreAria && !!aria.labelVirtual(elm)) ||
 		// or one of it's descendants does
 		(!noRecursion &&
 			elm.children.some(
@@ -56,11 +57,12 @@ dom.hasContentVirtual = function(elm, noRecursion) {
  * @instance
  * @param {DOMNode} elm DOMNode element to check
  * @param	{Boolean} noRecursion If true, only the element is checked, otherwise it will search all child nodes
+ * @param {Boolean} ignoreAria if true, ignores `aria label` computation for content deduction
  * @return {Boolean}
  */
-dom.hasContent = function hasContent(elm, noRecursion) {
-	elm = axe.utils.getNodeFromTree(axe._tree[0], elm);
-	return dom.hasContentVirtual(elm, noRecursion);
+dom.hasContent = function hasContent(elm, noRecursion, ignoreAria) {
+	elm = axe.utils.getNodeFromTree(elm);
+	return dom.hasContentVirtual(elm, noRecursion, ignoreAria);
 };
 
 /**

data/node_modules/axe-core/lib/commons/dom/is-focusable.js

@@ -1,5 +1,4 @@
 /* global dom */
-/* eslint complexity: ["error",20] */
 
 /**
  * Determines if focusing has been disabled on an element.
@@ -9,7 +8,7 @@
 function focusDisabled(el) {
 	return (
 		el.disabled ||
-		(dom.isHiddenWithCSS(el) && el.nodeName.toUpperCase() !== 'AREA')
+		(el.nodeName.toUpperCase() !== 'AREA' && dom.isHiddenWithCSS(el))
 	);
 }
 
@@ -84,7 +83,11 @@ dom.isNativelyFocusable = function(el) {
  * if its tabindex were removed. Else, false.
  */
 dom.insertedIntoFocusOrder = function(el) {
-	return (
-		el.tabIndex > -1 && dom.isFocusable(el) && !dom.isNativelyFocusable(el)
-	);
+	let tabIndex = parseInt(el.getAttribute('tabindex'), 10);
+
+	// an element that has an invalid tabindex will return 0 or -1 based on
+	// if it is natively focusable or not, which will always be false for this
+	// check as NaN is not > 1
+	// @see https://www.w3.org/TR/html51/editing.html#the-tabindex-attribute
+	return tabIndex > -1 && dom.isFocusable(el) && !dom.isNativelyFocusable(el);
 };

data/node_modules/axe-core/lib/commons/dom/is-hidden-with-css.js

@@ -1,4 +1,3 @@
-/* eslint complexity: ["error", 13], max-statements: ["error", 25] */
 /* global dom */
 
 /**
@@ -11,6 +10,20 @@
  * @return {Boolean} the element's hidden status
  */
 dom.isHiddenWithCSS = function isHiddenWithCSS(el, descendentVisibilityValue) {
+	const vNode = axe.utils.getNodeFromTree(el);
+
+	if (!vNode) {
+		return _isHiddenWithCSS(el, descendentVisibilityValue);
+	}
+
+	if (vNode._isHiddenWithCSS === void 0) {
+		vNode._isHiddenWithCSS = _isHiddenWithCSS(el, descendentVisibilityValue);
+	}
+
+	return vNode._isHiddenWithCSS;
+};
+
+function _isHiddenWithCSS(el, descendentVisibilityValue) {
 	if (el.nodeType === 9) {
 		// 9 === Node.DOCUMENT
 		return false;
@@ -57,4 +70,4 @@ dom.isHiddenWithCSS = function isHiddenWithCSS(el, descendentVisibilityValue) {
 		return dom.isHiddenWithCSS(parent, visibilityValue);
 	}
 	return false;
-};
+}

data/node_modules/axe-core/lib/commons/dom/is-in-text-block.js

@@ -17,7 +17,7 @@ function getBlockParent(node) {
 	while (parentBlock && !isBlock(parentBlock)) {
 		parentBlock = dom.getComposedParent(parentBlock);
 	}
-	return axe.utils.getNodeFromTree(axe._tree[0], parentBlock);
+	return axe.utils.getNodeFromTree(parentBlock);
 }
 
 /**
@@ -26,7 +26,6 @@ function getBlockParent(node) {
  * @return {Boolean}      [description]
  */
 dom.isInTextBlock = function isInTextBlock(node) {
-	/* eslint complexity: ["error",17]*/
 	if (isBlock(node)) {
 		// Ignore if the link is a block
 		return false;

data/node_modules/axe-core/lib/commons/dom/is-skip-link.js

@@ -0,0 +1,45 @@
+/* global dom */
+
+// test for hrefs that start with # or /# (for angular)
+const isInternalLinkRegex = /^\/?#[^/!]/;
+
+/**
+ * Determines if element is a skip link
+ * @method isSkipLink
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Element} element
+ * @return {Boolean}
+ */
+dom.isSkipLink = function(element) {
+	if (!isInternalLinkRegex.test(element.getAttribute('href'))) {
+		return false;
+	}
+
+	let firstPageLink;
+	if (typeof axe._cache.get('firstPageLink') !== 'undefined') {
+		firstPageLink = axe._cache.get('firstPageLink');
+	} else {
+		// define a skip link as any anchor element whose href starts with `#...`
+		// and which precedes the first anchor element whose href doesn't start
+		// with  `#...` (that is, a link to a page)
+		firstPageLink = axe.utils.querySelectorAll(
+			axe._tree,
+			'a:not([href^="#"]):not([href^="/#"]):not([href^="javascript"])'
+		)[0];
+
+		// null will signify no first page link
+		axe._cache.set('firstPageLink', firstPageLink || null);
+	}
+
+	// if there are no page links then all all links will need to be
+	// considered as skip links
+	if (!firstPageLink) {
+		return true;
+	}
+
+	return (
+		element.compareDocumentPosition(firstPageLink.actualNode) ===
+		element.DOCUMENT_POSITION_FOLLOWING
+	);
+};

data/node_modules/axe-core/lib/commons/dom/is-visible.js

@@ -1,22 +1,39 @@
 /* global dom */
-/* eslint complexity: ["error", 20] */
+const clipRegex = /rect\s*\(([0-9]+)px,?\s*([0-9]+)px,?\s*([0-9]+)px,?\s*([0-9]+)px\s*\)/;
+const clipPathRegex = /(\w+)\((\d+)/;
 
 /**
- * Determines if an element is hidden with the clip rect technique
+ * Determines if an element is hidden with a clip or clip-path technique
  * @method isClipped
  * @memberof axe.commons.dom
  * @private
- * @param  {String}  clip Computed property value of clip
+ * @param  {CSSStyleDeclaration} style Computed style
  * @return {Boolean}
  */
-function isClipped(clip) {
+function isClipped(style) {
 	'use strict';
 
-	var matches = clip.match(
-		/rect\s*\(([0-9]+)px,?\s*([0-9]+)px,?\s*([0-9]+)px,?\s*([0-9]+)px\s*\)/
-	);
-	if (matches && matches.length === 5) {
-		return matches[3] - matches[1] <= 0 && matches[2] - matches[4] <= 0;
+	const matchesClip = style.getPropertyValue('clip').match(clipRegex);
+	const matchesClipPath = style
+		.getPropertyValue('clip-path')
+		.match(clipPathRegex);
+	if (matchesClip && matchesClip.length === 5) {
+		return (
+			matchesClip[3] - matchesClip[1] <= 0 &&
+			matchesClip[2] - matchesClip[4] <= 0
+		);
+	}
+	if (matchesClipPath) {
+		const type = matchesClipPath[1];
+		const value = parseInt(matchesClipPath[2], 10);
+
+		switch (type) {
+			case 'inset':
+				return value >= 50;
+			case 'circle':
+				return value === 0;
+			default:
+		}
 	}
 
 	return false;
@@ -33,9 +50,9 @@ function isClipped(clip) {
  * @return {Boolean} The element's visibilty status
  */
 dom.isVisible = function(el, screenReader, recursed) {
-	//eslint complexity: 13
 	'use strict';
-	var style, nodeName, parent;
+	const node = axe.utils.getNodeFromTree(el);
+	const cacheName = '_isVisible' + (screenReader ? 'ScreenReader' : '');
 
 	// 9 === Node.DOCUMENT
 	if (el.nodeType === 9) {
@@ -47,17 +64,21 @@ dom.isVisible = function(el, screenReader, recursed) {
 		el = el.host; // grab the host Node
 	}
 
-	style = window.getComputedStyle(el, null);
+	if (node && typeof node[cacheName] !== 'undefined') {
+		return node[cacheName];
+	}
+
+	const style = window.getComputedStyle(el, null);
 	if (style === null) {
 		return false;
 	}
 
-	nodeName = el.nodeName.toUpperCase();
+	const nodeName = el.nodeName.toUpperCase();
 
 	if (
 		style.getPropertyValue('display') === 'none' ||
 		['STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE'].includes(nodeName) ||
-		(!screenReader && isClipped(style.getPropertyValue('clip'))) ||
+		(!screenReader && isClipped(style)) ||
 		(!recursed &&
 			// visibility is only accurate on the first element
 			(style.getPropertyValue('visibility') === 'hidden' ||
@@ -68,10 +89,15 @@ dom.isVisible = function(el, screenReader, recursed) {
 		return false;
 	}
 
-	parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+	const parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+	let isVisible = false;
 	if (parent) {
-		return dom.isVisible(parent, screenReader, true);
+		isVisible = dom.isVisible(parent, screenReader, true);
 	}
 
-	return false;
+	if (node) {
+		node[cacheName] = isVisible;
+	}
+
+	return isVisible;
 };

data/node_modules/axe-core/lib/commons/dom/is-visual-content.js

@@ -1,5 +1,4 @@
 /*global dom */
-/*eslint complexity: ["error",20] */
 
 const visualRoles = [
 	'checkbox',

data/node_modules/axe-core/lib/commons/dom/visually-contains.js

@@ -1,5 +1,4 @@
 /* global dom */
-/* eslint complexity: ["error",17] */
 
 /**
  * Checks whether a parent element visually contains its child, either directly or via scrolling.

data/node_modules/axe-core/lib/commons/dom/visually-overlaps.js

@@ -1,5 +1,4 @@
 /* global dom */
-/* eslint complexity: ["error",15] */
 
 /**
  * Checks whether a parent element visually overlaps a rectangle, either directly or via scrolling.

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

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

data/node_modules/axe-core/lib/commons/forms/is-aria-combobox.js

@@ -0,0 +1,13 @@
+/* global forms */
+
+/**
+ * Determines if an element is an aria combobox element
+ * @method isAriaCombobox
+ * @memberof axe.commons.forms
+ * @param {Element} node Node to determine if aria combobox
+ * @returns {Bool}
+ */
+forms.isAriaCombobox = function(node) {
+	const role = axe.commons.aria.getRole(node, { noImplicit: true });
+	return role === 'combobox';
+};

data/node_modules/axe-core/lib/commons/forms/is-aria-listbox.js

@@ -0,0 +1,13 @@
+/* global forms */
+
+/**
+ * Determines if an element is an aria listbox element
+ * @method isAriaListbox
+ * @memberof axe.commons.forms
+ * @param {Element} node Node to determine if aria listbox
+ * @returns {Bool}
+ */
+forms.isAriaListbox = function(node) {
+	const role = axe.commons.aria.getRole(node, { noImplicit: true });
+	return role === 'listbox';
+};