govuk_publishing_components 30.4.1 → 30.5.0

data/node_modules/axe-core/lib/commons/text/is-human-interpretable.js

@@ -1,51 +0,0 @@
-/* global text */
-
-/**
- * Determines if a given text is human friendly and interpretable
- *
- * @method isHumanInterpretable
- * @memberof axe.commons.text
- * @instance
- * @param  {String} str text to be validated
- * @returns {Number} Between 0 and 1, (0 -> not interpretable, 1 -> interpretable)
- */
-text.isHumanInterpretable = function(str) {
-	/**
-	 * Steps:
-	 * 1) Check for single character edge cases
-	 * 		a) handle if character is alphanumeric & within the given icon mapping
-	 * 					eg: x (close), i (info)
-	 *
-	 * 3) handle unicode from astral  (non bilingual multi plane) unicode, emoji & punctuations
-	 * 					eg: Windings font
-	 * 					eg: '💪'
-	 * 					eg: I saw a shooting 💫
-	 * 					eg: ? (help), > (next arrow), < (back arrow), need help ?
-	 */
-
-	if (!str.length) {
-		return 0;
-	}
-
-	// Step 1
-	const alphaNumericIconMap = [
-		'x', // close
-		'i' // info
-	];
-	// Step 1a
-	if (alphaNumericIconMap.includes(str)) {
-		return 0;
-	}
-
-	// Step 2
-	const noUnicodeStr = text.removeUnicode(str, {
-		emoji: true,
-		nonBmp: true,
-		punctuations: true
-	});
-	if (!text.sanitize(noUnicodeStr)) {
-		return 0;
-	}
-
-	return 1;
-};

data/node_modules/axe-core/lib/commons/text/is-icon-ligature.js

@@ -1,210 +0,0 @@
-/* global text */
-
-/**
- * Determines if a given text node is an icon ligature
- *
- * @method isIconLigature
- * @memberof axe.commons.text
- * @instance
- * @param {VirtualNode} textVNode The virtual text node
- * @param {Number} occuranceThreshold Number of times the font is encountered before auto-assigning the font as a ligature or not
- * @param {Number} differenceThreshold Percent of differences in pixel data or pixel width needed to determine if a font is a ligature font
- * @return {Boolean}
- */
-text.isIconLigature = function(
-	textVNode,
-	differenceThreshold = 0.15,
-	occuranceThreshold = 3
-) {
-	/**
-	 * Determine if the visible text is a ligature by comparing the
-	 * first letters image data to the entire strings image data.
-	 * If the two images are significantly different (typical set to 5%
-	 * statistical significance, but we'll be using a slightly higher value
-	 * of 15% to help keep the size of the canvas down) then we know the text
-	 * has been replaced by a ligature.
-	 *
-	 * Example:
-	 * If a text node was the string "File", looking at just the first
-	 * letter "F" would produce the following image:
-	 *
-	 * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-	 * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-	 * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-	 *
-	 * But if the entire string "File" produced an image which had at least
-	 * a 15% difference in pixels, we would know that the string was replaced
-	 * by a ligature:
-	 *
-	 * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-	 * │ │█│█│█│█│█│█│█│█│█│█│ │ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │ │ │ │ │ │ │ │█│█│ │ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │█│█│█│█│█│█│ │█│ │█│ │ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │ │ │ │ │ │ │ │█│█│█│█│ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │█│█│█│█│█│█│ │ │ │ │█│ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │█│█│█│█│█│█│█│█│█│ │█│ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-	 * │ │█│█│█│█│█│█│█│█│█│█│█│█│█│ │
-	 * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-	 */
-	const nodeValue = textVNode.actualNode.nodeValue.trim();
-
-	// text with unicode or non-bmp letters cannot be ligature icons
-	if (
-		!text.sanitize(nodeValue) ||
-		text.hasUnicode(nodeValue, { emoji: true, nonBmp: true })
-	) {
-		return false;
-	}
-
-	if (!axe._cache.get('canvasContext')) {
-		axe._cache.set(
-			'canvasContext',
-			document.createElement('canvas').getContext('2d')
-		);
-	}
-	const canvasContext = axe._cache.get('canvasContext');
-	const canvas = canvasContext.canvas;
-
-	// keep track of each font encountered and the number of times it shows up
-	// as a ligature.
-	if (!axe._cache.get('fonts')) {
-		axe._cache.set('fonts', {});
-	}
-	const fonts = axe._cache.get('fonts');
-
-	const style = window.getComputedStyle(textVNode.parent.actualNode);
-	const fontFamily = style.getPropertyValue('font-family');
-
-	if (!fonts[fontFamily]) {
-		fonts[fontFamily] = {
-			occurances: 0,
-			numLigatures: 0
-		};
-	}
-	const font = fonts[fontFamily];
-
-	// improve the performance by only comparing the image data of a font
-	// a certain number of times
-	if (font.occurances >= occuranceThreshold) {
-		// if the font has always been a ligature assume it's a ligature font
-		if (font.numLigatures / font.occurances === 1) {
-			return true;
-		}
-		// inversely, if it's never been a ligature assume it's not a ligature font
-		else if (font.numLigatures === 0) {
-			return false;
-		}
-
-		// we could theoretically get into an odd middle ground scenario in which
-		// the font family is being used as normal text sometimes and as icons
-		// other times. in these cases we would need to always check the text
-		// to know if it's an icon or not
-	}
-	font.occurances++;
-
-	// 30px was chosen to account for common ligatures in normal fonts
-	// such as fi, ff, ffi. If a ligature would add a single column of
-	// pixels to a 30x30 grid, it would not meet the statistical significance
-	// threshold of 15% (30x30 = 900; 30/900 = 3.333%). this also allows for
-	// more than 1 column differences (60/900 = 6.666%) and things like
-	// extending the top of the f in the fi ligature.
-	let fontSize = 30;
-	let fontStyle = `${fontSize}px ${fontFamily}`;
-
-	// set the size of the canvas to the width of the first letter
-	canvasContext.font = fontStyle;
-	const firstChar = nodeValue.charAt(0);
-	let width = canvasContext.measureText(firstChar).width;
-
-	// ensure font meets the 30px width requirement (30px font-size doesn't
-	// necessarily mean its 30px wide when drawn)
-	if (width < 30) {
-		const diff = 30 / width;
-		width *= diff;
-		fontSize *= diff;
-		fontStyle = `${fontSize}px ${fontFamily}`;
-	}
-	canvas.width = width;
-	canvas.height = fontSize;
-
-	// changing the dimensions of a canvas resets all properties (include font)
-	// and clears it
-	canvasContext.font = fontStyle;
-	canvasContext.textAlign = 'left';
-	canvasContext.textBaseline = 'top';
-	canvasContext.fillText(firstChar, 0, 0);
-	const compareData = new Uint32Array(
-		canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-	);
-
-	// if the font doesn't even have character data for a single char then
-	// it has to be an icon ligature (e.g. Material Icon)
-	if (!compareData.some(pixel => pixel)) {
-		font.numLigatures++;
-		return true;
-	}
-
-	canvasContext.clearRect(0, 0, width, fontSize);
-	canvasContext.fillText(nodeValue, 0, 0);
-	const compareWith = new Uint32Array(
-		canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-	);
-
-	// calculate the number of differences between the first letter and the
-	// entire string, ignoring color differences
-	const differences = compareData.reduce((diff, pixel, i) => {
-		if (pixel === 0 && compareWith[i] === 0) {
-			return diff;
-		}
-		if (pixel !== 0 && compareWith[i] !== 0) {
-			return diff;
-		}
-		return ++diff;
-	}, 0);
-
-	// calculate the difference between the width of each character and the
-	// combined with of all characters
-	const expectedWidth = nodeValue.split('').reduce((width, char) => {
-		return width + canvasContext.measureText(char).width;
-	}, 0);
-	const actualWidth = canvasContext.measureText(nodeValue).width;
-
-	const pixelDifference = differences / compareData.length;
-	const sizeDifference = 1 - actualWidth / expectedWidth;
-
-	if (
-		pixelDifference >= differenceThreshold &&
-		sizeDifference >= differenceThreshold
-	) {
-		font.numLigatures++;
-		return true;
-	}
-
-	return false;
-};

data/node_modules/axe-core/lib/commons/text/is-valid-autocomplete.js

@@ -1,117 +0,0 @@
-/* global text */
-const autocomplete = {
-	stateTerms: ['on', 'off'],
-	standaloneTerms: [
-		'name',
-		'honorific-prefix',
-		'given-name',
-		'additional-name',
-		'family-name',
-		'honorific-suffix',
-		'nickname',
-		'username',
-		'new-password',
-		'current-password',
-		'organization-title',
-		'organization',
-		'street-address',
-		'address-line1',
-		'address-line2',
-		'address-line3',
-		'address-level4',
-		'address-level3',
-		'address-level2',
-		'address-level1',
-		'country',
-		'country-name',
-		'postal-code',
-		'cc-name',
-		'cc-given-name',
-		'cc-additional-name',
-		'cc-family-name',
-		'cc-number',
-		'cc-exp',
-		'cc-exp-month',
-		'cc-exp-year',
-		'cc-csc',
-		'cc-type',
-		'transaction-currency',
-		'transaction-amount',
-		'language',
-		'bday',
-		'bday-day',
-		'bday-month',
-		'bday-year',
-		'sex',
-		'url',
-		'photo'
-	],
-	qualifiers: ['home', 'work', 'mobile', 'fax', 'pager'],
-	qualifiedTerms: [
-		'tel',
-		'tel-country-code',
-		'tel-national',
-		'tel-area-code',
-		'tel-local',
-		'tel-local-prefix',
-		'tel-local-suffix',
-		'tel-extension',
-		'email',
-		'impp'
-	],
-	locations: ['billing', 'shipping']
-};
-text.autocomplete = autocomplete;
-
-text.isValidAutocomplete = function isValidAutocomplete(
-	autocomplete,
-	{
-		looseTyped = false,
-		stateTerms = [],
-		locations = [],
-		qualifiers = [],
-		standaloneTerms = [],
-		qualifiedTerms = []
-	} = {}
-) {
-	autocomplete = autocomplete.toLowerCase().trim();
-	stateTerms = stateTerms.concat(text.autocomplete.stateTerms);
-	if (stateTerms.includes(autocomplete) || autocomplete === '') {
-		return true;
-	}
-
-	qualifiers = qualifiers.concat(text.autocomplete.qualifiers);
-	locations = locations.concat(text.autocomplete.locations);
-	standaloneTerms = standaloneTerms.concat(text.autocomplete.standaloneTerms);
-	qualifiedTerms = qualifiedTerms.concat(text.autocomplete.qualifiedTerms);
-
-	const autocompleteTerms = autocomplete.split(/\s+/g);
-	if (!looseTyped) {
-		if (
-			autocompleteTerms[0].length > 8 &&
-			autocompleteTerms[0].substr(0, 8) === 'section-'
-		) {
-			autocompleteTerms.shift();
-		}
-
-		if (locations.includes(autocompleteTerms[0])) {
-			autocompleteTerms.shift();
-		}
-
-		if (qualifiers.includes(autocompleteTerms[0])) {
-			autocompleteTerms.shift();
-			// only quantifiers allowed at this point
-			standaloneTerms = [];
-		}
-
-		if (autocompleteTerms.length !== 1) {
-			return false;
-		}
-	}
-
-	const purposeTerm = autocompleteTerms[autocompleteTerms.length - 1];
-	return (
-		standaloneTerms.includes(purposeTerm) ||
-		qualifiedTerms.includes(purposeTerm)
-	);
-};

data/node_modules/axe-core/lib/commons/text/label-text.js

@@ -1,58 +0,0 @@
-/* global dom, text */
-
-/**
- * Return accessible text for an implicit and/or explicit HTML label element
- * @param {VirtualNode} element
- * @param {Object} context
- * @property {Bool} inControlContext
- * @property {Bool} inLabelledByContext
- * @return {String} Label text
- */
-text.labelText = function labelText(virtualNode, context = {}) {
-	const { alreadyProcessed } = text.accessibleTextVirtual;
-	if (
-		context.inControlContext ||
-		context.inLabelledByContext ||
-		alreadyProcessed(virtualNode, context)
-	) {
-		return '';
-	}
-	if (!context.startNode) {
-		context.startNode = virtualNode;
-	}
-
-	const labelContext = { inControlContext: true, ...context };
-	const explicitLabels = getExplicitLabels(virtualNode);
-	const implicitLabel = dom.findUpVirtual(virtualNode, 'label');
-
-	let labels;
-	if (implicitLabel) {
-		labels = [...explicitLabels, implicitLabel];
-		labels.sort(axe.utils.nodeSorter);
-	} else {
-		labels = explicitLabels;
-	}
-
-	return labels
-		.map(label => text.accessibleText(label, labelContext))
-		.filter(text => text !== '')
-		.join(' ');
-};
-
-/**
- * Find a non-ARIA label for an element
- * @private
- * @param {VirtualNode} element The VirtualNode instance whose label we are seeking
- * @return {HTMLElement} The label element, or null if none is found
- */
-function getExplicitLabels({ actualNode }) {
-	if (!actualNode.id) {
-		return [];
-	}
-	return dom.findElmsInContext({
-		elm: 'label',
-		attr: 'for',
-		value: actualNode.id,
-		context: actualNode
-	});
-}

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

@@ -1,53 +0,0 @@
-/* global text, dom, axe, aria */
-
-/**
- * Gets the visible text of a label for a given input
- * @see http://www.w3.org/WAI/PF/aria/roles#namecalculation
- * @method labelVirtual
- * @memberof axe.commons.text
- * @instance
- * @param  {VirtualNode} node The virtual node mapping to the input to test
- * @return {Mixed} String of visible text, or `null` if no label is found
- */
-text.labelVirtual = function(node) {
-	var ref, candidate, doc;
-
-	candidate = aria.labelVirtual(node);
-	if (candidate) {
-		return candidate;
-	}
-
-	// explicit label
-	if (node.actualNode.id) {
-		const id = axe.utils.escapeSelector(node.actualNode.getAttribute('id'));
-		doc = axe.commons.dom.getRootNode(node.actualNode);
-		ref = doc.querySelector('label[for="' + id + '"]');
-		candidate = ref && text.visible(ref, true);
-		if (candidate) {
-			return candidate;
-		}
-	}
-
-	ref = dom.findUpVirtual(node, 'label');
-	candidate = ref && text.visible(ref, true);
-	if (candidate) {
-		return candidate;
-	}
-
-	return null;
-};
-
-/**
- * Finds virtual node and calls labelVirtual()
- * IMPORTANT: This method requires the composed tree at axe._tree
- * @see axe.commons.text.virtualLabel
- * @method label
- * @memberof axe.commons.text
- * @instance
- * @param  {Element} node The virtual node mapping to the input to test
- * @return {Mixed} String of visible text, or `null` if no label is found
- */
-text.label = function(node) {
-	node = axe.utils.getNodeFromTree(node);
-	return text.labelVirtual(node);
-};

data/node_modules/axe-core/lib/commons/text/native-element-types.js

@@ -1,100 +0,0 @@
-/* global text */
-text.nativeElementType = [
-	{
-		// 5.1 input type="text", input type="password", input type="search", input type="tel", input type="url" and textarea Element
-		matches: [
-			{
-				nodeName: 'textarea'
-			},
-			{
-				nodeName: 'input',
-				properties: {
-					type: ['text', 'password', 'search', 'tel', 'email', 'url']
-				}
-			}
-		],
-		namingMethods: 'labelText'
-	},
-	{
-		// 5.2 input type="button", input type="submit" and input type="reset"
-		matches: {
-			nodeName: 'input',
-			properties: {
-				type: ['button', 'submit', 'reset']
-			}
-		},
-		namingMethods: ['valueText', 'titleText', 'buttonDefaultText']
-	},
-	{
-		// 5.3 input type="image"
-		matches: {
-			nodeName: 'input',
-			properties: {
-				type: 'image'
-			}
-		},
-		namingMethods: [
-			'altText',
-			'valueText',
-			'labelText',
-			'titleText',
-			'buttonDefaultText'
-		]
-	},
-	{
-		// 5.4 button Element
-		matches: 'button',
-		namingMethods: 'subtreeText'
-	},
-	{
-		// 5.5 fieldset and legend Elements
-		matches: 'fieldset',
-		namingMethods: 'fieldsetLegendText'
-	},
-	{
-		// 5.6 output Element
-		matches: 'OUTPUT',
-		namingMethods: 'subtreeText'
-	},
-	{
-		// 5.7 Other Form Elements
-		matches: [
-			{
-				nodeName: 'select'
-			},
-			{
-				nodeName: 'input',
-				properties: {
-					// Regex: Everything other than these
-					type: /^(?!text|password|search|tel|email|url|button|submit|reset)/
-				}
-			}
-		],
-		namingMethods: 'labelText'
-	},
-	{
-		// 5.8 summary Element
-		matches: 'summary',
-		namingMethods: 'subtreeText'
-	},
-	{
-		// 5.9 figure and figcaption Elements
-		matches: 'figure',
-		namingMethods: ['figureText', 'titleText']
-	},
-	{
-		// 5.10 img Element
-		matches: 'img',
-		namingMethods: 'altText'
-	},
-	{
-		// 5.11 table Element
-		matches: 'table',
-		namingMethods: ['tableCaptionText', 'tableSummaryText']
-	},
-	{
-		matches: ['hr', 'br'],
-		namingMethods: ['titleText', 'singleSpace']
-	}
-	// All else defaults to just title
-];

data/node_modules/axe-core/lib/commons/text/native-text-alternative.js

@@ -1,50 +0,0 @@
-/* global text, aria */
-
-/**
- * Get the accessible text using native HTML methods only
- * @param {VirtualNode} element
- * @param {Object} context
- * @property {Bool} debug Enable logging for formControlValue
- * @return {String} Accessible text
- */
-text.nativeTextAlternative = function nativeTextAlternative(
-	virtualNode,
-	context = {}
-) {
-	const { actualNode } = virtualNode;
-	if (
-		actualNode.nodeType !== 1 ||
-		['presentation', 'none'].includes(aria.getRole(actualNode))
-	) {
-		return '';
-	}
-
-	const textMethods = findTextMethods(virtualNode);
-	// Find the first step that returns a non-empty string
-	let accName = textMethods.reduce((accName, step) => {
-		return accName || step(virtualNode, context);
-	}, '');
-
-	if (context.debug) {
-		axe.log(accName || '{empty-value}', actualNode, context);
-	}
-	return accName;
-};
-
-/**
- * Get accessible text functions for a specific native HTML element
- * @private
- * @param {VirtualNode} element
- * @return {Function[]} Array of native accessible name computation methods
- */
-function findTextMethods(virtualNode) {
-	const { nativeElementType, nativeTextMethods } = text;
-	const nativeType = nativeElementType.find(({ matches }) => {
-		return axe.commons.matches(virtualNode, matches);
-	});
-
-	// Use concat because namingMethods can be a string or an array of strings
-	const methods = nativeType ? [].concat(nativeType.namingMethods) : [];
-
-	return methods.map(methodName => nativeTextMethods[methodName]);
-}