govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,77 @@
+/* global dom */
+/* eslint complexity: ["error", 20] */
+
+/**
+ * Determines if an element is hidden with the clip rect technique
+ * @method isClipped
+ * @memberof axe.commons.dom
+ * @private
+ * @param  {String}  clip Computed property value of clip
+ * @return {Boolean}
+ */
+function isClipped(clip) {
+	'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;
+	}
+
+	return false;
+}
+
+/**
+ * Determine whether an element is visible
+ * @method isVisible
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {HTMLElement} el The HTMLElement
+ * @param {Boolean} screenReader When provided, will evaluate visibility from the perspective of a screen reader
+ * @param {Boolean} recursed
+ * @return {Boolean} The element's visibilty status
+ */
+dom.isVisible = function(el, screenReader, recursed) {
+	//eslint complexity: 13
+	'use strict';
+	var style, nodeName, parent;
+
+	// 9 === Node.DOCUMENT
+	if (el.nodeType === 9) {
+		return true;
+	}
+
+	// 11 === Node.DOCUMENT_FRAGMENT_NODE
+	if (el.nodeType === 11) {
+		el = el.host; // grab the host Node
+	}
+
+	style = window.getComputedStyle(el, null);
+	if (style === null) {
+		return false;
+	}
+
+	nodeName = el.nodeName.toUpperCase();
+
+	if (
+		style.getPropertyValue('display') === 'none' ||
+		['STYLE', 'SCRIPT', 'NOSCRIPT', 'TEMPLATE'].includes(nodeName) ||
+		(!screenReader && isClipped(style.getPropertyValue('clip'))) ||
+		(!recursed &&
+			// visibility is only accurate on the first element
+			(style.getPropertyValue('visibility') === 'hidden' ||
+				// position does not matter if it was already calculated
+				(!screenReader && dom.isOffscreen(el)))) ||
+		(screenReader && el.getAttribute('aria-hidden') === 'true')
+	) {
+		return false;
+	}
+
+	parent = el.assignedSlot ? el.assignedSlot : el.parentNode;
+	if (parent) {
+		return dom.isVisible(parent, screenReader, true);
+	}
+
+	return false;
+};

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

@@ -0,0 +1,50 @@
+/*global dom */
+/*eslint complexity: ["error",20] */
+
+const visualRoles = [
+	'checkbox',
+	'img',
+	'radio',
+	'range',
+	'slider',
+	'spinbutton',
+	'textbox'
+];
+
+/**
+ * Check if an element is an inherently visual element
+ * @method isVisualContent
+ * @memberof axe.commons.dom
+ * @instance
+ * @param  {Element} element The element to check
+ * @return {Boolean}
+ */
+dom.isVisualContent = function(element) {
+	/*eslint indent: 0*/
+	const role = element.getAttribute('role');
+	if (role) {
+		return visualRoles.indexOf(role) !== -1;
+	}
+
+	switch (element.nodeName.toUpperCase()) {
+		case 'IMG':
+		case 'IFRAME':
+		case 'OBJECT':
+		case 'VIDEO':
+		case 'AUDIO':
+		case 'CANVAS':
+		case 'SVG':
+		case 'MATH':
+		case 'BUTTON':
+		case 'SELECT':
+		case 'TEXTAREA':
+		case 'KEYGEN':
+		case 'PROGRESS':
+		case 'METER':
+			return true;
+		case 'INPUT':
+			return element.type !== 'hidden';
+		default:
+			return false;
+	}
+};

data/node_modules/axe-core/lib/commons/dom/shadow-elements-from-point.js

@@ -0,0 +1,41 @@
+/* global axe, dom */
+/**
+ * Get elements from point across shadow dom boundaries
+ * @method shadowElementsFromPoint
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Number} nodeX X coordinates of point
+ * @param {Number} nodeY Y coordinates of point
+ * @param {Object} [root] Shadow root or document root
+ * @return {Array}
+ */
+dom.shadowElementsFromPoint = function(nodeX, nodeY, root = document, i = 0) {
+	if (i > 999) {
+		throw new Error('Infinite loop detected');
+	}
+	return (
+		Array.from(root.elementsFromPoint(nodeX, nodeY))
+			// As of Chrome 66, elementFromPoint will return elements from parent trees.
+			// We only want to touch each tree once, so we're filtering out nodes on other trees.
+			.filter(nodes => dom.getRootNode(nodes) === root)
+			.reduce((stack, elm) => {
+				if (axe.utils.isShadowRoot(elm)) {
+					const shadowStack = dom.shadowElementsFromPoint(
+						nodeX,
+						nodeY,
+						elm.shadowRoot,
+						i + 1
+					);
+					stack = stack.concat(shadowStack);
+					// filter host nodes which get included regardless of overlap
+					// TODO: refactor multiline overlap checking inside shadow dom
+					if (stack.length && axe.commons.dom.visuallyContains(stack[0], elm)) {
+						stack.push(elm);
+					}
+				} else {
+					stack.push(elm);
+				}
+				return stack;
+			}, [])
+	);
+};

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

@@ -0,0 +1,62 @@
+/* global dom */
+/* eslint complexity: ["error",17] */
+
+/**
+ * Checks whether a parent element visually contains its child, either directly or via scrolling.
+ * Assumes that |parent| is an ancestor of |node|.
+ * @method visuallyContains
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {Element} node
+ * @param {Element} parent
+ * @return {boolean} True if node is visually contained within parent
+ */
+dom.visuallyContains = function(node, parent) {
+	var rectBound = node.getBoundingClientRect();
+	var margin = 0.01;
+	var rect = {
+		top: rectBound.top + margin,
+		bottom: rectBound.bottom - margin,
+		left: rectBound.left + margin,
+		right: rectBound.right - margin
+	};
+	var parentRect = parent.getBoundingClientRect();
+	var parentTop = parentRect.top;
+	var parentLeft = parentRect.left;
+	var parentScrollArea = {
+		top: parentTop - parent.scrollTop,
+		bottom: parentTop - parent.scrollTop + parent.scrollHeight,
+		left: parentLeft - parent.scrollLeft,
+		right: parentLeft - parent.scrollLeft + parent.scrollWidth
+	};
+
+	var style = window.getComputedStyle(parent);
+
+	// if parent element is inline, scrollArea will be too unpredictable
+	if (style.getPropertyValue('display') === 'inline') {
+		return true;
+	}
+
+	//In theory, we should just be able to look at the scroll area as a superset of the parentRect,
+	//but that's not true in Firefox
+	if (
+		(rect.left < parentScrollArea.left && rect.left < parentRect.left) ||
+		(rect.top < parentScrollArea.top && rect.top < parentRect.top) ||
+		(rect.right > parentScrollArea.right && rect.right > parentRect.right) ||
+		(rect.bottom > parentScrollArea.bottom && rect.bottom > parentRect.bottom)
+	) {
+		return false;
+	}
+
+	if (rect.right > parentRect.right || rect.bottom > parentRect.bottom) {
+		return (
+			style.overflow === 'scroll' ||
+			style.overflow === 'auto' ||
+			style.overflow === 'hidden' ||
+			parent instanceof HTMLBodyElement ||
+			parent instanceof HTMLHtmlElement
+		);
+	}
+
+	return true;
+};

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

@@ -0,0 +1,47 @@
+/* global dom */
+/* eslint complexity: ["error",15] */
+
+/**
+ * Checks whether a parent element visually overlaps a rectangle, either directly or via scrolling.
+ * @method visuallyOverlaps
+ * @memberof axe.commons.dom
+ * @instance
+ * @param {DOMRect} rect
+ * @param {Element} parent
+ * @return {boolean} True if rect is visually contained within parent
+ */
+dom.visuallyOverlaps = function(rect, parent) {
+	var parentRect = parent.getBoundingClientRect();
+	var parentTop = parentRect.top;
+	var parentLeft = parentRect.left;
+	var parentScrollArea = {
+		top: parentTop - parent.scrollTop,
+		bottom: parentTop - parent.scrollTop + parent.scrollHeight,
+		left: parentLeft - parent.scrollLeft,
+		right: parentLeft - parent.scrollLeft + parent.scrollWidth
+	};
+
+	//In theory, we should just be able to look at the scroll area as a superset of the parentRect,
+	//but that's not true in Firefox
+	if (
+		(rect.left > parentScrollArea.right && rect.left > parentRect.right) ||
+		(rect.top > parentScrollArea.bottom && rect.top > parentRect.bottom) ||
+		(rect.right < parentScrollArea.left && rect.right < parentRect.left) ||
+		(rect.bottom < parentScrollArea.top && rect.bottom < parentRect.top)
+	) {
+		return false;
+	}
+
+	var style = window.getComputedStyle(parent);
+
+	if (rect.left > parentRect.right || rect.top > parentRect.bottom) {
+		return (
+			style.overflow === 'scroll' ||
+			style.overflow === 'auto' ||
+			parent instanceof HTMLBodyElement ||
+			parent instanceof HTMLHtmlElement
+		);
+	}
+
+	return true;
+};

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

@@ -0,0 +1,11 @@
+/*exported commons */
+/*eslint no-unused-vars: 0*/
+/** @namespace axe */
+
+/**
+ * Namespace for axe common methods.
+ * @namespace commons
+ * @memberof axe
+ */
+
+var commons = {};

data/node_modules/axe-core/lib/commons/intro.stub

@@ -0,0 +1 @@
+(function () {

data/node_modules/axe-core/lib/commons/matches/attributes.js

@@ -0,0 +1,23 @@
+/* global matches */
+/**
+ * Check if a node matches some attribute(s)
+ *
+ * Note: matches.attributes(node, matcher) can be indirectly used through
+ * matches(node, { attributes: matcher })
+ *
+ * Example:
+ * ```js
+ * matches.attributes(node, {
+ *   'aria-live': 'assertive', // Simple string match
+ *   'aria-expanded': /true|false/i, // either boolean, case insensitive
+ * })
+ * ```
+ *
+ * @param {HTMLElement|VirtualNode} node
+ * @param {Object} Attribute matcher
+ * @returns {Boolean}
+ */
+matches.attributes = function matchesAttributes(node, matcher) {
+	node = node.actualNode || node;
+	return matches.fromFunction(attrName => node.getAttribute(attrName), matcher);
+};

data/node_modules/axe-core/lib/commons/matches/condition.js

@@ -0,0 +1,19 @@
+/* global matches */
+/**
+ * Check if a "thing" is truthy according to a "condition"
+ *
+ * Note: matches.condition(node, matcher) can be indirectly used through
+ * matches(node, { condition: matcher })
+ *
+ * Example:
+ * ```js
+ * matches.condition(node, (arg) => arg === null)
+ * ```
+ *
+ * @param {any} argument
+ * @param {Function|Null|undefined} condition
+ * @returns {Boolean}
+ */
+matches.condition = function(arg, condition) {
+	return !!condition(arg);
+};

data/node_modules/axe-core/lib/commons/matches/from-definition.js

@@ -0,0 +1,47 @@
+/* global matches */
+const matchers = ['nodeName', 'attributes', 'properties', 'condition'];
+
+/**
+ * Check if a node matches some definition
+ *
+ * Note: matches.fromDefinition(node, definition) can be indirectly used through
+ * matches(node, definition)
+ *
+ * Example:
+ * ```js
+ * matches.fromDefinition(node, {
+ *   nodeName: ['div', 'span']
+ *   attributes: {
+ *     'aria-live': 'assertive'
+ *   }
+ * })
+ * ```
+ *
+ * @private
+ * @param {HTMLElement|VirtualNode} node
+ * @param {Object|Array<Object>} definition
+ * @returns {Boolean}
+ */
+matches.fromDefinition = function matchFromDefinition(node, definition) {
+	node = node.actualNode || node;
+	if (Array.isArray(definition)) {
+		return definition.some(definitionItem => matches(node, definitionItem));
+	}
+	if (typeof definition === 'string') {
+		return axe.utils.matchesSelector(node, definition);
+	}
+
+	return Object.keys(definition).every(matcherName => {
+		if (!matchers.includes(matcherName)) {
+			throw new Error(`Unknown matcher type "${matcherName}"`);
+		}
+		// Find the specific matches method to.
+		// matches.attributes, matches.nodeName, matches.properties, etc.
+		const matchMethod = matches[matcherName];
+
+		// Find the matcher that goes into the matches method.
+		// 'div', /^div$/, (str) => str === 'div', etc.
+		const matcher = definition[matcherName];
+		return matchMethod(node, matcher);
+	});
+};

data/node_modules/axe-core/lib/commons/matches/from-function.js

@@ -0,0 +1,38 @@
+/* global matches */
+
+/**
+ * Check if the value from a function matches some condition
+ *
+ * Each key on the matcher object is passed to getValue, the returned value must match
+ * with the value of that matcher
+ *
+ * Example:
+ * ```js
+ * matches.fromFunction(
+ * 	 (attr => node.getAttribute(attr),
+ * 	 {
+ * 	   'aria-hidden': /^true|false$/i
+ * 	 }
+ * )
+ * ```
+ *
+ * @private
+ * @param {Function} getValue
+ * @param {Object} matcher matcher
+ * @returns {Boolean}
+ */
+matches.fromFunction = function matchFromFunction(getValue, matcher) {
+	const matcherType = typeof matcher;
+	if (
+		matcherType !== 'object' ||
+		Array.isArray(matcher) ||
+		matcher instanceof RegExp
+	) {
+		throw new Error('Expect matcher to be an object');
+	}
+
+	// Check that the property has all the expected values
+	return Object.keys(matcher).every(propName => {
+		return matches.fromPrimative(getValue(propName), matcher[propName]);
+	});
+};

data/node_modules/axe-core/lib/commons/matches/from-primative.js

@@ -0,0 +1,30 @@
+/* global matches */
+
+/**
+ * Check if some value matches
+ *
+ * ```js
+ * match.fromPrimative('foo', 'foo') // true, string is the same
+ * match.fromPrimative('foo', ['foo', 'bar']) // true, string is included
+ * match.fromPrimative('foo', /foo/) // true, string matches regex
+ * match.fromPrimative('foo', str => str.toUpperCase() === 'FOO') // true, function return is truthy
+ * ```
+ *
+ * @private
+ * @param {String|Boolean|Array|Number|Null|Undefined} someString
+ * @param {String|RegExp|Function|Array<String>|Null|Undefined} matcher
+ * @returns {Boolean}
+ */
+matches.fromPrimative = function matchFromPrimative(someString, matcher) {
+	const matcherType = typeof matcher;
+	if (Array.isArray(matcher) && typeof someString !== 'undefined') {
+		return matcher.includes(someString);
+	}
+	if (matcherType === 'function') {
+		return !!matcher(someString);
+	}
+	if (matcher instanceof RegExp) {
+		return matcher.test(someString);
+	}
+	return matcher === someString;
+};