govuk_publishing_components 18.1.0 → 18.1.1

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

@@ -0,0 +1,122 @@
+/* global text */
+
+const defaultButtonValues = {
+	submit: 'Submit',
+	image: 'Submit',
+	reset: 'Reset',
+	button: '' // No default for "button"
+};
+
+text.nativeTextMethods = {
+	/**
+	 * Return the value of a DOM node
+	 * @param {VirtualNode} element
+	 * @return {String} value text
+	 */
+	valueText: ({ actualNode }) => actualNode.value || '',
+
+	/**
+	 * Return default value of a button
+	 * @param {VirtualNode} element
+	 * @return {String} default button text
+	 */
+	buttonDefaultText: ({ actualNode }) =>
+		defaultButtonValues[actualNode.type] || '',
+
+	/**
+	 * Return caption text of an HTML table element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} caption text
+	 */
+	tableCaptionText: descendantText.bind(null, 'caption'),
+
+	/**
+	 * Return figcaption text of an HTML figure element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} figcaption text
+	 */
+	figureText: descendantText.bind(null, 'figcaption'),
+
+	/**
+	 * Return legend text of an HTML fieldset element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} legend text
+	 */
+	fieldsetLegendText: descendantText.bind(null, 'legend'),
+
+	/**
+	 * Return the alt text
+	 * @param {VirtualNode} element
+	 * @return {String} alt text
+	 */
+	altText: attrText.bind(null, 'alt'),
+
+	/**
+	 * Return summary text for an HTML table element
+	 * @param {VirtualNode} element
+	 * @return {String} summary text
+	 */
+	tableSummaryText: attrText.bind(null, 'summary'),
+
+	/**
+	 * Return the title text
+	 * @param {VirtualNode} element
+	 * @return {String} title text
+	 */
+	titleText: function titleText(virtualNode, context) {
+		return text.titleText(virtualNode, context);
+	},
+
+	/**
+	 * Return accessible text of the subtree
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} Subtree text
+	 */
+	subtreeText: function subtreeText(virtualNode, context) {
+		return text.subtreeText(virtualNode, context);
+	},
+
+	/**
+	 * Return accessible text for an implicit and/or explicit HTML label element
+	 * @param {VirtualNode} element
+	 * @param {Object} context
+	 * @return {String} Label text
+	 */
+	labelText: function labelText(virtualNode, context) {
+		return text.labelText(virtualNode, context);
+	},
+
+	/**
+	 * Return a single space
+	 * @return {String} Returns ` `
+	 */
+	singleSpace: function singleSpace() {
+		return ' '
+	}
+};
+
+function attrText(attr, { actualNode }) {
+	return actualNode.getAttribute(attr) || '';
+}
+
+/**
+ * Get the accessible text of first matching node
+ * IMPORTANT: This method does not look at the composed tree
+ * @private
+ */
+function descendantText(nodeName, { actualNode }, context) {
+	nodeName = nodeName.toLowerCase();
+	// Prevent accidently getting the nested element, like:
+	// fieldset > fielset > legend (1st fieldset has no legend)
+	const nodeNames = [nodeName, actualNode.nodeName.toLowerCase()].join(',');
+	const candidate = actualNode.querySelector(nodeNames);
+
+	if (!candidate || candidate.nodeName.toLowerCase() !== nodeName) {
+		return '';
+	}
+	return text.accessibleText(candidate, context);
+}

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

@@ -0,0 +1,18 @@
+/* global text */
+
+/**
+ * Removes carriage returns, newline characters, tabs, non-breaking spaces, and trailing spaces from string
+ * @method sanitize
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {String} str String to be cleaned
+ * @return {String} Sanitized string
+ */
+text.sanitize = function(str) {
+	'use strict';
+	return str
+		.replace(/\r\n/g, '\n')
+		.replace(/\u00A0/g, ' ')
+		.replace(/[\s]{2,}/g, ' ')
+		.trim();
+};

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

@@ -0,0 +1,89 @@
+/* global text, aria */
+/**
+ * Get the accessible text for an element that can get its name from content
+ *
+ * @param {VirtualNode} element
+ * @param {Object} context
+ * @property {Bool} strict Should the name computation strictly follow AccName 1.1
+ * @return {String} Accessible text
+ */
+text.subtreeText = function subtreeText(virtualNode, context = {}) {
+	const { alreadyProcessed } = text.accessibleTextVirtual
+	context.startNode = context.startNode || virtualNode;
+	const { strict } = context;
+	if (
+		alreadyProcessed(virtualNode, context ) ||
+		!aria.namedFromContents(virtualNode, { strict })
+	) {
+		return '';
+	}
+
+	return aria.getOwnedVirtual(virtualNode).reduce((contentText, child) => {
+		return appendAccessibleText(contentText, child, context);
+	}, '');
+};
+
+// TODO: Could do with an "HTML" lookup table, similar to ARIA,
+//  where this sort of stuff can live.
+const phrasingElements = [
+	'A',
+	'EM',
+	'STRONG',
+	'SMALL',
+	'MARK',
+	'ABBR',
+	'DFN',
+	'I',
+	'B',
+	'S',
+	'U',
+	'CODE',
+	'VAR',
+	'SAMP',
+	'KBD',
+	'SUP',
+	'SUB',
+	'Q',
+	'CITE',
+	'SPAN',
+	'BDO',
+	'BDI',
+	'WBR',
+	'INS',
+	'DEL',
+	'MAP',
+	'AREA',
+	'NOSCRIPT',
+	'RUBY',
+	'BUTTON',
+	'LABEL',
+	'OUTPUT',
+	'DATALIST',
+	'KEYGEN',
+	'PROGRESS',
+	'COMMAND',
+	'CANVAS',
+	'TIME',
+	'METER',
+	'#TEXT'
+];
+
+function appendAccessibleText(contentText, virtualNode, context) {
+	const nodeName = virtualNode.actualNode.nodeName.toUpperCase();
+	let contentTextAdd = text.accessibleTextVirtual(virtualNode, context);
+	if (!contentTextAdd) {
+		return contentText
+	}
+
+	if (!phrasingElements.includes(nodeName)) {
+		// Append space, if necessary
+		if (contentTextAdd[0] !== ' ') {
+			contentTextAdd += ' ';
+		}
+		// Prepend space, if necessary
+		if (contentText && contentText[contentText.length - 1] !== ' ') {
+			contentTextAdd = ' ' + contentTextAdd;
+		}
+	}
+	return contentText + contentTextAdd;
+}

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

@@ -0,0 +1,33 @@
+/* global text, aria */
+const alwaysTitleElements = [
+	'button',
+	'iframe',
+	'a[href]',
+	{
+		nodeName: 'input',
+		properties: { type: 'button' }
+	}
+];
+
+/**
+ * Get title text
+ * @param {HTMLElement}node the node to verify
+ * @return {String}
+ */
+text.titleText = function titleText(node) {
+	node = node.actualNode || node;
+	if (node.nodeType !== 1 || !node.hasAttribute('title')) {
+		return '';
+	}
+
+	// Some elements return the title even with role=presentation
+	// This does appear in any spec, but its remarkably consistent
+	if (
+		!axe.commons.matches(node, alwaysTitleElements) &&
+		['none', 'presentation'].includes(aria.getRole(node))
+	) {
+		return '';
+	}
+
+	return node.getAttribute('title');
+};

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

@@ -0,0 +1,117 @@
+/* global text */
+
+/**
+ * Determine if a given string contains unicode characters, specified in options
+ *
+ * @method hasUnicode
+ * @memberof axe.commons.text
+ * @instance
+ * @param {String} str string to verify
+ * @param {Object} options config containing which unicode character sets to verify
+ * @property {Boolean} options.emoji verify emoji unicode
+ * @property {Boolean} options.nonBmp verify nonBmp unicode
+ * @property {Boolean} options.punctuations verify punctuations unicode
+ * @returns {Boolean}
+ */
+text.hasUnicode = function hasUnicode(str, options) {
+	const { emoji, nonBmp, punctuations } = options;
+	if (emoji) {
+		return axe.imports.emojiRegexText().test(str);
+	}
+	if (nonBmp) {
+		return getUnicodeNonBmpRegExp().test(str);
+	}
+	if (punctuations) {
+		return getPunctuationRegExp().test(str);
+	}
+	return false;
+};
+
+/**
+ * Remove specified type(s) unicode characters
+ *
+ * @method removeUnicode
+ * @memberof axe.commons.text
+ * @instance
+ * @param {String} str string to operate on
+ * @param {Object} options config containing which unicode character sets to remove
+ * @property {Boolean} options.emoji remove emoji unicode
+ * @property {Boolean} options.nonBmp remove nonBmp unicode
+ * @property {Boolean} options.punctuations remove punctuations unicode
+ * @returns {String}
+ */
+text.removeUnicode = function removeUnicode(str, options) {
+	const { emoji, nonBmp, punctuations } = options;
+
+	if (emoji) {
+		str = str.replace(axe.imports.emojiRegexText(), '');
+	}
+	if (nonBmp) {
+		str = str.replace(getUnicodeNonBmpRegExp(), '');
+	}
+	if (punctuations) {
+		str = str.replace(getPunctuationRegExp(), '');
+	}
+
+	return str;
+};
+
+/**
+ * Regex for matching unicode values out of Basic Multilingual Plane (BMP)
+ * Reference:
+ * - https://github.com/mathiasbynens/regenerate
+ * - https://unicode-table.com/
+ * - https://mathiasbynens.be/notes/javascript-unicode
+ *
+ * @returns {RegExp}
+ */
+function getUnicodeNonBmpRegExp() {
+	/**
+	 * Regex for matching astral plane unicode
+	 * - http://kourge.net/projects/regexp-unicode-block
+	 */
+	return new RegExp(
+		'[' +
+		'\u1D00-\u1D7F' + // Phonetic Extensions
+		'\u1D80-\u1DBF' + // Phonetic Extensions Supplement
+		'\u1DC0-\u1DFF' + // Combining Diacritical Marks Supplement
+		// '\u2000-\u206F' + // General punctuation - handled in -> getPunctuationRegExp
+		'\u20A0-\u20CF' + // Currency symbols
+		'\u20D0-\u20FF' + // Combining Diacritical Marks for Symbols
+		'\u2100-\u214F' + // Letter like symbols
+		'\u2150-\u218F' + // Number forms (eg: Roman numbers)
+		'\u2190-\u21FF' + // Arrows
+		'\u2200-\u22FF' + // Mathematical operators
+		'\u2300-\u23FF' + // Misc Technical
+		'\u2400-\u243F' + // Control pictures
+		'\u2440-\u245F' + // OCR
+		'\u2460-\u24FF' + // Enclosed alpha numerics
+		'\u2500-\u257F' + // Box Drawing
+		'\u2580-\u259F' + // Block Elements
+		'\u25A0-\u25FF' + // Geometric Shapes
+		'\u2600-\u26FF' + // Misc Symbols
+		'\u2700-\u27BF' + // Dingbats
+			']'
+	);
+}
+
+/**
+ * Get regular expression for matching punctuations
+ *
+ * @returns {RegExp}
+ */
+function getPunctuationRegExp() {
+	/**
+	 * Reference: http://kunststube.net/encoding/
+	 * US-ASCII
+	 * -> !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+	 *
+	 * General Punctuation block
+	 * -> \u2000-\u206F
+	 *
+	 * Supplemental Punctuation block
+	 * Reference: https://en.wikipedia.org/wiki/Supplemental_Punctuation
+	 * -> \u2E00-\u2E7F Reference
+	 */
+	return /[\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&()*+,\-.\/:;<=>?@\[\]^_`{|}~]/g;
+}

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

@@ -0,0 +1,5 @@
+/* global text */
+
+text.unsupported = {
+	accessibleNameFromFieldValue: ['combobox', 'listbox', 'progressbar']
+};

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

@@ -0,0 +1,46 @@
+/* global text, dom, axe */
+
+/**
+ * Returns the visible text of the virtual node
+ * NOTE: when calculating the text or accessible text of a node that includes shadow
+ * roots attached to it or its children, the flattened tree must be considered
+ * rather than the "light DOM"
+ * @method visibleVirtual
+ * @memberof axe.commons.text
+ * @instance
+ * @param  {VirtualNode} element
+ * @param  {Boolean} screenReader When provided, will evaluate visibility from the perspective of a screen reader
+ * @param  {Boolean} noRecursing When False, the result will contain text from the element and it's children.
+ * When True, the result will only contain text from the element
+ * @return {String}
+ */
+text.visibleVirtual = function(element, screenReader, noRecursing) {
+	const result = element.children
+		.map(child => {
+			if (child.actualNode.nodeType === 3) {
+				// filter on text nodes
+				const nodeValue = child.actualNode.nodeValue;
+				if (nodeValue && dom.isVisible(element.actualNode, screenReader)) {
+					return nodeValue;
+				}
+			} else if (!noRecursing) {
+				return text.visibleVirtual(child, screenReader);
+			}
+		})
+		.join('');
+	return text.sanitize(result);
+};
+
+/**
+ * Finds virtual node and calls visibleVirtual()
+ * IMPORTANT: This method requires the composed tree at axe._tree
+ * @param  {Element} element
+ * @param  {Boolean} screenReader When provided, will evaluate visibility from the perspective of a screen reader
+ * @param  {Boolean} noRecursing When False, the result will contain text from the element and it's children.
+ * When True, the result will only contain text from the element
+ * @return {String}
+ */
+text.visible = function(element, screenReader, noRecursing) {
+	element = axe.utils.getNodeFromTree(axe._tree[0], element);
+	return text.visibleVirtual(element, screenReader, noRecursing);
+};

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

@@ -0,0 +1,10 @@
+/* exported utils */
+/* global axe */
+/*eslint no-unused-vars: 0*/
+/**
+ * Namespace for general utilities.
+ * @namespace utils
+ * @memberof axe.commons
+ */
+
+var utils = (commons.utils = axe.utils);