govuk_publishing_components 30.4.1 → 30.5.2

data/node_modules/axe-core/lib/commons/aria/is-accessible-ref.js

@@ -1,59 +0,0 @@
-/* global aria, axe, dom */
-const idRefsRegex = /^idrefs?$/;
-
-function cacheIdRefs(node, refAttrs) {
-	if (node.hasAttribute) {
-		const idRefs = axe._cache.get('idRefs');
-
-		if (node.nodeName.toUpperCase() === 'LABEL' && node.hasAttribute('for')) {
-			idRefs[node.getAttribute('for')] = true;
-		}
-
-		for (let i = 0; i < refAttrs.length; ++i) {
-			const attr = refAttrs[i];
-
-			if (!node.hasAttribute(attr)) {
-				continue;
-			}
-
-			const attrValue = node.getAttribute(attr);
-
-			const tokens = axe.utils.tokenList(attrValue);
-
-			for (let k = 0; k < tokens.length; ++k) {
-				idRefs[tokens[k]] = true;
-			}
-		}
-	}
-
-	for (let i = 0; i < node.children.length; i++) {
-		cacheIdRefs(node.children[i], refAttrs);
-	}
-}
-
-/**
- * Check that a DOM node is a reference in the accessibility tree
- * @param {Element} node
- * @returns {Boolean}
- */
-aria.isAccessibleRef = function isAccessibleRef(node) {
-	node = node.actualNode || node;
-	let root = dom.getRootNode(node);
-	root = root.documentElement || root; // account for shadow roots
-	const id = node.id;
-
-	// because axe.commons is not available in axe.utils, we can't do
-	// this caching when we build up the virtual tree
-	if (!axe._cache.get('idRefs')) {
-		axe._cache.set('idRefs', {});
-		// Get all idref(s) attributes on the lookup table
-		const refAttrs = Object.keys(aria.lookupTable.attributes).filter(attr => {
-			const { type } = aria.lookupTable.attributes[attr];
-			return idRefsRegex.test(type);
-		});
-
-		cacheIdRefs(root, refAttrs);
-	}
-
-	return axe._cache.get('idRefs')[id] === true;
-};

data/node_modules/axe-core/lib/commons/aria/is-aria-role-allowed-on-element.js

@@ -1,41 +0,0 @@
-/* global aria, matches */
-/**
- * @description validate if a given role is an allowed ARIA role for the supplied node
- * @method isAriaRoleAllowedOnElement
- * @param {HTMLElement} node the node to verify
- * @param {String} role aria role to check
- * @return {Boolean} retruns true/false
- */
-aria.isAriaRoleAllowedOnElement = function isAriaRoleAllowedOnElement(
-	node,
-	role
-) {
-	const nodeName = node.nodeName.toUpperCase();
-	const lookupTable = axe.commons.aria.lookupTable;
-
-	// if given node can have no role - return false
-	if (matches(node, lookupTable.elementsAllowedNoRole)) {
-		return false;
-	}
-	// if given node allows any role - return true
-	if (matches(node, lookupTable.elementsAllowedAnyRole)) {
-		return true;
-	}
-
-	// get role value (if exists) from lookupTable.role
-	const roleValue = lookupTable.role[role];
-
-	// if given role does not exist in lookupTable - return false
-	if (!roleValue || !roleValue.allowedElements) {
-		return false;
-	}
-
-	// validate attributes and conditions (if any) from allowedElement to given node
-	let out = matches(node, roleValue.allowedElements);
-
-	// if given node type has complex condition to evaluate a given aria-role, execute the same
-	if (Object.keys(lookupTable.evaluateRoleForElement).includes(nodeName)) {
-		return lookupTable.evaluateRoleForElement[nodeName]({ node, role, out });
-	}
-	return out;
-};

data/node_modules/axe-core/lib/commons/aria/is-unsupported-role.js

@@ -1,14 +0,0 @@
-/* global aria */
-
-/**
- * Check if a given role is unsupported
- * @method isUnsupportedRole
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @return {Boolean}
- */
-aria.isUnsupportedRole = function(role) {
-	const roleDefinition = aria.lookupTable.role[role];
-	return roleDefinition ? roleDefinition.unsupported : false;
-};

data/node_modules/axe-core/lib/commons/aria/label-virtual.js

@@ -1,54 +0,0 @@
-/* global axe, aria, dom, text */
-
-/**
- * Gets the accessible ARIA label text of a given element
- * @see http://www.w3.org/WAI/PF/aria/roles#namecalculation
- * @method labelVirtual
- * @memberof axe.commons.aria
- * @instance
- * @param  {Object} actualNode The virtualNode to test
- * @return {Mixed}  String of visible text, or `null` if no label is found
- */
-aria.labelVirtual = function({ actualNode }) {
-	let ref, candidate;
-
-	if (actualNode.getAttribute('aria-labelledby')) {
-		// aria-labelledby
-		ref = dom.idrefs(actualNode, 'aria-labelledby');
-		candidate = ref
-			.map(function(thing) {
-				const vNode = axe.utils.getNodeFromTree(thing);
-				return vNode ? text.visibleVirtual(vNode, true) : '';
-			})
-			.join(' ')
-			.trim();
-
-		if (candidate) {
-			return candidate;
-		}
-	}
-
-	// aria-label
-	candidate = actualNode.getAttribute('aria-label');
-	if (candidate) {
-		candidate = text.sanitize(candidate).trim();
-		if (candidate) {
-			return candidate;
-		}
-	}
-
-	return null;
-};
-
-/**
- * Gets the aria label for a given node
- * @method label
- * @memberof axe.commons.aria
- * @instance
- * @param  {HTMLElement} node The element to check
- * @return {Mixed} String of visible text, or `null` if no label is found
- */
-aria.label = function(node) {
-	node = axe.utils.getNodeFromTree(node);
-	return aria.labelVirtual(node);
-};

data/node_modules/axe-core/lib/commons/aria/named-from-contents.js

@@ -1,39 +0,0 @@
-/* global aria */
-
-/**
- * Check if an element is named from contents
- *
- * @param {Node|VirtualNode} element
- * @param {Object} options
- * @property {Bool} strict Whether or not to follow the spects strictly
- * @return {Bool}
- */
-aria.namedFromContents = function namedFromContents(node, { strict } = {}) {
-	node = node.actualNode || node;
-	if (node.nodeType !== 1) {
-		return false;
-	}
-
-	const role = aria.getRole(node);
-	const roleDef = aria.lookupTable.role[role];
-
-	if (
-		(roleDef && roleDef.nameFrom.includes('contents')) ||
-		// TODO: This is a workaround for axe-core's over-assertive implicitRole computation
-		// once we fix that, this extra noImplicit check can be removed.
-		node.nodeName.toUpperCase() === 'TABLE'
-	) {
-		return true;
-	}
-
-	/**
-	 * Note: Strictly speaking if the role is null, presentation, or none, the element
-	 * isn't named from contents. Axe-core often needs to know if an element
-	 * has content anyway, so we're allowing it here.
-	 * Use { strict: true } to disable this behavior.
-	 */
-	if (strict) {
-		return false;
-	}
-	return !roleDef || ['presentation', 'none'].includes(role);
-};

data/node_modules/axe-core/lib/commons/aria/roles.js

@@ -1,208 +0,0 @@
-/* global aria, axe */
-
-/**
- * Check if a given role is valid
- * @method isValidRole
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @param {Object} options Use `allowAbstract` if you want abstracts, and `flagUnsupported: true` to report unsupported roles
- * @return {Boolean}
- */
-aria.isValidRole = function(
-	role,
-	{ allowAbstract, flagUnsupported = false } = {}
-) {
-	const roleDefinition = aria.lookupTable.role[role];
-	const isRoleUnsupported = roleDefinition ? roleDefinition.unsupported : false;
-	if (!roleDefinition || (flagUnsupported && isRoleUnsupported)) {
-		return false;
-	}
-	return allowAbstract ? true : roleDefinition.type !== 'abstract';
-};
-
-/**
- * Get the roles that get name from the element's contents
- * @method getRolesWithNameFromContents
- * @memberof axe.commons.aria
- * @instance
- * @return {Array} Array of roles that match the type
- */
-aria.getRolesWithNameFromContents = function() {
-	return Object.keys(aria.lookupTable.role).filter(function(r) {
-		return (
-			aria.lookupTable.role[r].nameFrom &&
-			aria.lookupTable.role[r].nameFrom.indexOf('contents') !== -1
-		);
-	});
-};
-
-/**
- * Get the roles that have a certain "type"
- * @method getRolesByType
- * @memberof axe.commons.aria
- * @instance
- * @param {String} roleType The roletype to check
- * @return {Array} Array of roles that match the type
- */
-aria.getRolesByType = function(roleType) {
-	return Object.keys(aria.lookupTable.role).filter(function(r) {
-		return aria.lookupTable.role[r].type === roleType;
-	});
-};
-
-/**
- * Get the "type" of role; either widget, composite, abstract, landmark or `null`
- * @method getRoleType
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @return {Mixed} String if a matching role and its type are found, otherwise `null`
- */
-aria.getRoleType = function(role) {
-	var r = aria.lookupTable.role[role];
-	return (r && r.type) || null;
-};
-
-/**
- * Get the required owned (children) roles for a given role
- * @method requiredOwned
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @return {Mixed} Either an Array of required owned elements or `null` if there are none
- */
-aria.requiredOwned = function(role) {
-	'use strict';
-	var owned = null,
-		roles = aria.lookupTable.role[role];
-
-	if (roles) {
-		owned = axe.utils.clone(roles.owned);
-	}
-	return owned;
-};
-
-/**
- * Get the required context (parent) roles for a given role
- * @method requiredContext
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @return {Mixed} Either an Array of required context elements or `null` if there are none
- */
-aria.requiredContext = function(role) {
-	'use strict';
-	var context = null,
-		roles = aria.lookupTable.role[role];
-
-	if (roles) {
-		context = axe.utils.clone(roles.context);
-	}
-	return context;
-};
-
-/**
- * Get a list of CSS selectors of nodes that have an implicit role
- * @method implicitNodes
- * @memberof axe.commons.aria
- * @instance
- * @param {String} role The role to check
- * @return {Mixed} Either an Array of CSS selectors or `null` if there are none
- */
-aria.implicitNodes = function(role) {
-	'use strict';
-
-	var implicit = null,
-		roles = aria.lookupTable.role[role];
-
-	if (roles && roles.implicit) {
-		implicit = axe.utils.clone(roles.implicit);
-	}
-	return implicit;
-};
-
-/**
- * Get the implicit role for a given node
- * @method implicitRole
- * @memberof axe.commons.aria
- * @instance
- * @param {HTMLElement} node The node to test
- * @return {Mixed} Either the role or `null` if there is none
- */
-aria.implicitRole = function(node) {
-	'use strict';
-
-	/*
-	 * Filter function to reduce a list of roles to a valid list of roles for a nodetype
-	 */
-	var isValidImplicitRole = function(set, role) {
-		var validForNodeType = function(implicitNodeTypeSelector) {
-			return axe.utils.matchesSelector(node, implicitNodeTypeSelector);
-		};
-
-		if (role.implicit && role.implicit.some(validForNodeType)) {
-			set.push(role.name);
-		}
-
-		return set;
-	};
-
-	/*
-	 * Score a set of roles and aria-attributes by its optimal score
-	 * E.g. [{score: 2, name: button}, {score: 1, name: main}]
-	 */
-	var sortRolesByOptimalAriaContext = function(roles, ariaAttributes) {
-		var getScore = function(role) {
-			var allowedAriaAttributes = aria.allowedAttr(role);
-			return allowedAriaAttributes.reduce(function(score, attribute) {
-				return score + (ariaAttributes.indexOf(attribute) > -1 ? 1 : 0);
-			}, 0);
-		};
-
-		var scored = roles.map(function(role) {
-			return { score: getScore(role), name: role };
-		});
-
-		var sorted = scored.sort(function(scoredRoleA, scoredRoleB) {
-			return scoredRoleB.score - scoredRoleA.score;
-		});
-
-		return sorted.map(function(sortedRole) {
-			return sortedRole.name;
-		});
-	};
-
-	/*
-	 * Create a list of { name / implicit } role mappings to filter on
-	 */
-	var roles = Object.keys(aria.lookupTable.role).map(function(role) {
-		var lookup = aria.lookupTable.role[role];
-		return { name: role, implicit: lookup && lookup.implicit };
-	});
-
-	/* Build a list of valid implicit roles for this node */
-	var availableImplicitRoles = roles.reduce(isValidImplicitRole, []);
-
-	if (!availableImplicitRoles.length) {
-		return null;
-	}
-
-	var nodeAttributes = axe.utils.getNodeAttributes(node);
-	var ariaAttributes = [];
-
-	/* Get all aria-attributes defined for this node */
-	/* Should be a helper function somewhere */
-	for (var i = 0, j = nodeAttributes.length; i < j; i++) {
-		var attr = nodeAttributes[i];
-		if (attr.name.match(/^aria-/)) {
-			ariaAttributes.push(attr.name);
-		}
-	}
-
-	/* Sort roles by highest score, return the first */
-	return sortRolesByOptimalAriaContext(
-		availableImplicitRoles,
-		ariaAttributes
-	).shift();
-};

data/node_modules/axe-core/lib/commons/aria/validate-attr-value.js

@@ -1,62 +0,0 @@
-/* global aria, dom */
-
-/**
- * Validate the value of an ARIA attribute
- * @method validateAttrValue
- * @memberof axe.commons.aria
- * @instance
- * @param  {HTMLElement} node The element to check
- * @param  {String} attr The name of the attribute
- * @return {Boolean}
- */
-aria.validateAttrValue = function validateAttrValue(node, attr) {
-	'use strict';
-	var matches,
-		list,
-		value = node.getAttribute(attr),
-		attrInfo = aria.lookupTable.attributes[attr];
-
-	var doc = dom.getRootNode(node);
-
-	if (!attrInfo) {
-		return true;
-	}
-	if (attrInfo.allowEmpty && (!value || value.trim() === '')) {
-		return true;
-	}
-
-	switch (attrInfo.type) {
-		case 'boolean':
-		case 'nmtoken':
-			return (
-				typeof value === 'string' &&
-				attrInfo.values.includes(value.toLowerCase())
-			);
-
-		case 'nmtokens':
-			list = axe.utils.tokenList(value);
-			// Check if any value isn't in the list of values
-			return list.reduce(function(result, token) {
-				return result && attrInfo.values.includes(token);
-				// Initial state, fail if the list is empty
-			}, list.length !== 0);
-
-		case 'idref':
-			return !!(value && doc.getElementById(value));
-
-		case 'idrefs':
-			list = axe.utils.tokenList(value);
-			return list.some(token => doc.getElementById(token));
-
-		case 'string':
-			// Not allowed empty except with allowEmpty: true
-			return value.trim() !== '';
-
-		case 'decimal':
-			matches = value.match(/^[-+]?([0-9]*)\.?([0-9]*)$/);
-			return !!(matches && (matches[1] || matches[2]));
-
-		case 'int':
-			return /^[-+]?[0-9]+$/.test(value);
-	}
-};

data/node_modules/axe-core/lib/commons/color/center-point-of-rect.js

@@ -1,30 +0,0 @@
-/* global color */
-
-/**
- * Get coordinates for an element's client rects or bounding client rect
- *
- * @method centerPointOfRect
- * @memberof axe.commons.color
- * @param {DOMRect} rect
- * @returns {Object | undefined}
- */
-color.centerPointOfRect = function centerPointOfRect(rect) {
-	if (rect.left > window.innerWidth) {
-		return undefined;
-	}
-
-	if (rect.top > window.innerHeight) {
-		return undefined;
-	}
-
-	const x = Math.min(
-		Math.ceil(rect.left + rect.width / 2),
-		window.innerWidth - 1
-	);
-	const y = Math.min(
-		Math.ceil(rect.top + rect.height / 2),
-		window.innerHeight - 1
-	);
-
-	return { x, y };
-};

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

@@ -1,178 +0,0 @@
-/* global color */
-
-/**
- * @class Color
- * @memberof axe.commons.color
- * @param {number} red
- * @param {number} green
- * @param {number} blue
- * @param {number} alpha
- */
-color.Color = function(red, green, blue, alpha) {
-	/** @type {number} */
-	this.red = red;
-
-	/** @type {number} */
-	this.green = green;
-
-	/** @type {number} */
-	this.blue = blue;
-
-	/** @type {number} */
-	this.alpha = alpha;
-
-	/**
-	 * Provide the hex string value for the color
-	 * @method toHexString
-	 * @memberof axe.commons.color.Color
-	 * @instance
-	 * @return {string}
-	 */
-	this.toHexString = function() {
-		var redString = Math.round(this.red).toString(16);
-		var greenString = Math.round(this.green).toString(16);
-		var blueString = Math.round(this.blue).toString(16);
-		return (
-			'#' +
-			(this.red > 15.5 ? redString : '0' + redString) +
-			(this.green > 15.5 ? greenString : '0' + greenString) +
-			(this.blue > 15.5 ? blueString : '0' + blueString)
-		);
-	};
-
-	var rgbRegex = /^rgb\((\d+), (\d+), (\d+)\)$/;
-	var rgbaRegex = /^rgba\((\d+), (\d+), (\d+), (\d*(\.\d+)?)\)/;
-
-	/**
-	 * Set the color value based on a CSS RGB/RGBA string
-	 * @method parseRgbString
-	 * @memberof axe.commons.color.Color
-	 * @instance
-	 * @param  {string}  rgb  The string value
-	 */
-	this.parseRgbString = function(colorString) {
-		// IE can pass transparent as value instead of rgba
-		if (colorString === 'transparent') {
-			this.red = 0;
-			this.green = 0;
-			this.blue = 0;
-			this.alpha = 0;
-			return;
-		}
-		var match = colorString.match(rgbRegex);
-
-		if (match) {
-			this.red = parseInt(match[1], 10);
-			this.green = parseInt(match[2], 10);
-			this.blue = parseInt(match[3], 10);
-			this.alpha = 1;
-			return;
-		}
-
-		match = colorString.match(rgbaRegex);
-		if (match) {
-			this.red = parseInt(match[1], 10);
-			this.green = parseInt(match[2], 10);
-			this.blue = parseInt(match[3], 10);
-
-			// alpha values can be between 0 and 1, with browsers having
-			// different floating point precision. for example,
-			// 'rgba(0,0,0,0.5)' results in 'rgba(0,0,0,0.498039)' in Safari
-			// when getting the computed style background-color property. to
-			// fix this, we'll round all alpha values to 2 decimal points.
-			this.alpha = Math.round(parseFloat(match[4]) * 100) / 100;
-			return;
-		}
-	};
-
-	/**
-	 * Get the relative luminance value
-	 * using algorithm from http://www.w3.org/WAI/GL/wiki/Relative_luminance
-	 * @method getRelativeLuminance
-	 * @memberof axe.commons.color.Color
-	 * @instance
-	 * @return {number} The luminance value, ranges from 0 to 1
-	 */
-	this.getRelativeLuminance = function() {
-		var rSRGB = this.red / 255;
-		var gSRGB = this.green / 255;
-		var bSRGB = this.blue / 255;
-
-		var r =
-			rSRGB <= 0.03928 ? rSRGB / 12.92 : Math.pow((rSRGB + 0.055) / 1.055, 2.4);
-		var g =
-			gSRGB <= 0.03928 ? gSRGB / 12.92 : Math.pow((gSRGB + 0.055) / 1.055, 2.4);
-		var b =
-			bSRGB <= 0.03928 ? bSRGB / 12.92 : Math.pow((bSRGB + 0.055) / 1.055, 2.4);
-
-		return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-	};
-};
-
-/**
- * Combine the two given color according to alpha blending.
- * @method flattenColors
- * @memberof axe.commons.color.Color
- * @instance
- * @param {Color} fgColor Foreground color
- * @param {Color} bgColor Background color
- * @return {Color} Blended color
- */
-color.flattenColors = function(fgColor, bgColor) {
-	var alpha = fgColor.alpha;
-	var r = (1 - alpha) * bgColor.red + alpha * fgColor.red;
-	var g = (1 - alpha) * bgColor.green + alpha * fgColor.green;
-	var b = (1 - alpha) * bgColor.blue + alpha * fgColor.blue;
-	var a = fgColor.alpha + bgColor.alpha * (1 - fgColor.alpha);
-
-	return new color.Color(r, g, b, a);
-};
-
-/**
- * Get the contrast of two colors
- * @method getContrast
- * @memberof axe.commons.color.Color
- * @instance
- * @param  {Color}  bgcolor  Background color
- * @param  {Color}  fgcolor  Foreground color
- * @return {number} The contrast ratio
- */
-color.getContrast = function(bgColor, fgColor) {
-	if (!fgColor || !bgColor) {
-		return null;
-	}
-
-	if (fgColor.alpha < 1) {
-		fgColor = color.flattenColors(fgColor, bgColor);
-	}
-
-	var bL = bgColor.getRelativeLuminance();
-	var fL = fgColor.getRelativeLuminance();
-
-	return (Math.max(fL, bL) + 0.05) / (Math.min(fL, bL) + 0.05);
-};
-
-/**
- * Check whether certain text properties meet WCAG contrast rules
- * @method hasValidContrastRatio
- * @memberof axe.commons.color.Color
- * @instance
- * @param  {Color}  bgcolor  Background color
- * @param  {Color}  fgcolor  Foreground color
- * @param  {number}  fontSize  Font size of text, in pixels
- * @param  {boolean}  isBold  Whether the text is bold
- * @return {{isValid: boolean, contrastRatio: number, expectedContrastRatio: number}}
- */
-color.hasValidContrastRatio = function(bg, fg, fontSize, isBold) {
-	var contrast = color.getContrast(bg, fg);
-	var isSmallFont =
-		(isBold && Math.ceil(fontSize * 72) / 96 < 14) ||
-		(!isBold && Math.ceil(fontSize * 72) / 96 < 18);
-	var expectedContrastRatio = isSmallFont ? 4.5 : 3;
-
-	return {
-		isValid: contrast > expectedContrastRatio,
-		contrastRatio: contrast,
-		expectedContrastRatio: expectedContrastRatio
-	};
-};