govuk_publishing_components 30.4.1 → 30.5.2

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

@@ -1,33 +0,0 @@
-/* global dom */
-/**
- * Get the scroll offset of the document passed in
- * @method getScrollOffset
- * @memberof axe.commons.dom
- * @instance
- * @param {Document} element The element to evaluate, defaults to document
- * @return {Object} Contains the attributes `x` and `y` which contain the scroll offsets
- */
-dom.getScrollOffset = function(element) {
-	'use strict';
-
-	if (!element.nodeType && element.document) {
-		element = element.document;
-	}
-
-	// 9 === Node.DOCUMENT_NODE
-	if (element.nodeType === 9) {
-		var docElement = element.documentElement,
-			body = element.body;
-
-		return {
-			left:
-				(docElement && docElement.scrollLeft) || (body && body.scrollLeft) || 0,
-			top: (docElement && docElement.scrollTop) || (body && body.scrollTop) || 0
-		};
-	}
-
-	return {
-		left: element.scrollLeft,
-		top: element.scrollTop
-	};
-};

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

@@ -1,24 +0,0 @@
-/* global dom */
-
-/**
- * Get all elements (including given node) that are part of the tab order
- * @method getTabbableElements
- * @memberof axe.commons.dom
- * @instance
- * @param  {Object} virtualNode The virtualNode to assess
- * @return {Boolean}
- */
-dom.getTabbableElements = function getTabbableElements(virtualNode) {
-	const nodeAndDescendents = axe.utils.querySelectorAll(virtualNode, '*');
-
-	const tabbableElements = nodeAndDescendents.filter(vNode => {
-		const isFocusable = vNode.isFocusable;
-		let tabIndex = vNode.actualNode.getAttribute('tabindex');
-		tabIndex =
-			tabIndex && !isNaN(parseInt(tabIndex, 10)) ? parseInt(tabIndex) : null;
-
-		return tabIndex ? isFocusable && tabIndex >= 0 : isFocusable;
-	});
-
-	return tabbableElements;
-};

data/node_modules/axe-core/lib/commons/dom/get-viewport-size.js

@@ -1,37 +0,0 @@
-/* global dom */
-/**
- * Gets the width and height of the viewport; used to calculate the right and bottom boundaries of the viewable area.
- * @method getViewportSize
- * @memberof axe.commons.dom
- * @instance
- * @param  {Object}  win The `window` object that should be measured
- * @return {Object}  Object with the `width` and `height` of the viewport
- */
-dom.getViewportSize = function(win) {
-	'use strict';
-
-	var body,
-		doc = win.document,
-		docElement = doc.documentElement;
-
-	if (win.innerWidth) {
-		return {
-			width: win.innerWidth,
-			height: win.innerHeight
-		};
-	}
-
-	if (docElement) {
-		return {
-			width: docElement.clientWidth,
-			height: docElement.clientHeight
-		};
-	}
-
-	body = doc.body;
-
-	return {
-		width: body.clientWidth,
-		height: body.clientHeight
-	};
-};

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

@@ -1,75 +0,0 @@
-/* global dom, aria, axe */
-const hiddenTextElms = [
-	'HEAD',
-	'TITLE',
-	'TEMPLATE',
-	'SCRIPT',
-	'STYLE',
-	'IFRAME',
-	'OBJECT',
-	'VIDEO',
-	'AUDIO',
-	'NOSCRIPT'
-];
-
-function hasChildTextNodes(elm) {
-	if (!hiddenTextElms.includes(elm.actualNode.nodeName.toUpperCase())) {
-		return elm.children.some(
-			({ actualNode }) =>
-				actualNode.nodeType === 3 && actualNode.nodeValue.trim()
-		);
-	}
-}
-
-/**
- * Check that the element has visible content in the form of either text,
- * an aria-label or visual content such as image
- * @method hasContentVirtual
- * @memberof axe.commons.dom
- * @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, ignoreAria) {
-	return (
-		// It has text
-		hasChildTextNodes(elm) ||
-		// It is a graphical element
-		dom.isVisualContent(elm.actualNode) ||
-		// It has an ARIA label
-		(!ignoreAria && !!aria.labelVirtual(elm)) ||
-		// or one of it's descendants does
-		(!noRecursion &&
-			elm.children.some(
-				child => child.actualNode.nodeType === 1 && dom.hasContentVirtual(child)
-			))
-	);
-};
-
-/**
- * Find virtual node and call hasContentVirtual()
- * IMPORTANT: This method requires the composed tree at axe._tree
- * @see axe.commons.dom.hasContentVirtual
- * @method hasContent
- * @memberof axe.commons.dom
- * @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, ignoreAria) {
-	elm = axe.utils.getNodeFromTree(elm);
-	return dom.hasContentVirtual(elm, noRecursion, ignoreAria);
-};
-
-/**
- * @typedef VirtualNode
- * @type {Object}
- * @property {HTMLElement} actualNode reference to actual HTML DOM element
- * @property {Array<VirtualNode>} children array of child virtualNodes
- * @property {String} shadowId The shadowId indicates whether the node is in a shadow root
- * and if it is, which one it is inside the boundary.
- */

data/node_modules/axe-core/lib/commons/dom/idrefs.js

@@ -1,36 +0,0 @@
-/*global dom, axe */
-
-/**
- * Get elements referenced via a space-separated token attribute;
- * it will insert `null` for any Element that is not found
- * @method idrefs
- * @memberof axe.commons.dom
- * @instance
- * @param  {HTMLElement} node
- * @param  {String} attr The name of attribute
- * @return {Array|null} Array of elements (or `null` if not found)
- *
- * NOTE: When in a shadow DOM environment: ID refs (even for slotted content)
- * refer to the document in which the element is considered to be in the
- * "light DOM". Therefore, we use getElementById on the root node and not QSA
- * on the flattened tree to dereference idrefs.
- *
- */
-dom.idrefs = function(node, attr) {
-	'use strict';
-
-	var index,
-		length,
-		doc = dom.getRootNode(node),
-		result = [],
-		idrefs = node.getAttribute(attr);
-
-	if (idrefs) {
-		idrefs = axe.utils.tokenList(idrefs);
-		for (index = 0, length = idrefs.length; index < length; index++) {
-			result.push(doc.getElementById(idrefs[index]));
-		}
-	}
-
-	return result;
-};

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

@@ -1,9 +0,0 @@
-/* exported dom */
-/*eslint no-unused-vars: 0*/
-/**
- * Namespace for dom-related utilities.
- * @namespace dom
- * @memberof axe.commons
- */
-
-var dom = (commons.dom = {});

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

@@ -1,95 +0,0 @@
-/* global dom */
-
-/**
- * Determines if focusing has been disabled on an element.
- * @param {HTMLElement} el The HTMLElement
- * @return {Boolean} Whether focusing has been disabled on an element.
- */
-function focusDisabled(el) {
-	return (
-		el.disabled ||
-		(el.nodeName.toUpperCase() !== 'AREA' && dom.isHiddenWithCSS(el))
-	);
-}
-
-/**
- * Determines if an element is focusable
- * @method isFocusable
- * @memberof axe.commons.dom
- * @instance
- * @param {HTMLElement} el The HTMLElement
- * @return {Boolean} The element's focusability status
- */
-
-dom.isFocusable = function(el) {
-	'use strict';
-	if (focusDisabled(el)) {
-		return false;
-	} else if (dom.isNativelyFocusable(el)) {
-		return true;
-	}
-	// check if the tabindex is specified and a parseable number
-	var tabindex = el.getAttribute('tabindex');
-	if (tabindex && !isNaN(parseInt(tabindex, 10))) {
-		return true;
-	}
-
-	return false;
-};
-
-/**
- * Determines if an element is focusable without considering its tabindex
- * @method isNativelyFocusable
- * @memberof axe.commons.dom
- * @instance
- * @param {HTMLElement} el The HTMLElement
- * @return {Boolean} True if the element is in the focus order but wouldn't be
- * if its tabindex were removed. Else, false.
- */
-dom.isNativelyFocusable = function(el) {
-	/* eslint indent: 0*/
-	'use strict';
-
-	if (!el || focusDisabled(el)) {
-		return false;
-	}
-
-	switch (el.nodeName.toUpperCase()) {
-		case 'A':
-		case 'AREA':
-			if (el.href) {
-				return true;
-			}
-			break;
-		case 'INPUT':
-			return el.type !== 'hidden';
-		case 'TEXTAREA':
-		case 'SELECT':
-		case 'SUMMARY':
-		case 'BUTTON':
-			return true;
-		case 'DETAILS':
-			return !el.querySelector('summary');
-	}
-	return false;
-};
-
-/**
- * Determines if an element is in the focus order, but would not be if its
- * tabindex were unspecified.
- * @method insertedIntoFocusOrder
- * @memberof axe.commons.dom
- * @instance
- * @param {HTMLElement} el The HTMLElement
- * @return {Boolean} True if the element is in the focus order but wouldn't be
- * if its tabindex were removed. Else, false.
- */
-dom.insertedIntoFocusOrder = function(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,73 +0,0 @@
-/* global dom */
-
-/**
- * Determine whether an element is hidden based on css
- * @method isHiddenWithCSS
- * @memberof axe.commons.dom
- * @instance
- * @param {HTMLElement} el The HTML Element
- * @param {Boolean} descendentVisibilityValue (Optional) immediate descendant visibility value used for recursive computation
- * @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;
-	}
-
-	if (el.nodeType === 11) {
-		// 11 === Node.DOCUMENT_FRAGMENT_NODE
-		el = el.host; // swap to host node
-	}
-
-	if (['STYLE', 'SCRIPT'].includes(el.nodeName.toUpperCase())) {
-		return false;
-	}
-
-	const style = window.getComputedStyle(el, null);
-	if (!style) {
-		throw new Error('Style does not exist for the given element.');
-	}
-
-	const displayValue = style.getPropertyValue('display');
-	if (displayValue === 'none') {
-		return true;
-	}
-
-	const HIDDEN_VISIBILITY_VALUES = ['hidden', 'collapse'];
-	const visibilityValue = style.getPropertyValue('visibility');
-	if (
-		HIDDEN_VISIBILITY_VALUES.includes(visibilityValue) &&
-		!descendentVisibilityValue
-	) {
-		return true;
-	}
-
-	if (
-		HIDDEN_VISIBILITY_VALUES.includes(visibilityValue) &&
-		descendentVisibilityValue &&
-		HIDDEN_VISIBILITY_VALUES.includes(descendentVisibilityValue)
-	) {
-		return true;
-	}
-
-	const parent = dom.getComposedParent(el);
-	if (parent && !HIDDEN_VISIBILITY_VALUES.includes(visibilityValue)) {
-		return dom.isHiddenWithCSS(parent, visibilityValue);
-	}
-	return false;
-}

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

@@ -1,17 +0,0 @@
-/* global dom */
-
-/**
- * Determines if a document node is HTML 5
- * @method isHTML5
- * @memberof axe.commons.dom
- * @instance
- * @param {Node} doc
- * @return {Boolean}
- */
-dom.isHTML5 = function(doc) {
-	var node = doc.doctype;
-	if (node === null) {
-		return false;
-	}
-	return node.name === 'html' && !node.publicId && !node.systemId;
-};

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

@@ -1,94 +0,0 @@
-/* global axe, dom, window */
-function walkDomNode(node, functor) {
-	if (functor(node.actualNode) !== false) {
-		node.children.forEach(child => walkDomNode(child, functor));
-	}
-}
-
-var blockLike = ['block', 'list-item', 'table', 'flex', 'grid', 'inline-block'];
-function isBlock(elm) {
-	var display = window.getComputedStyle(elm).getPropertyValue('display');
-	return blockLike.includes(display) || display.substr(0, 6) === 'table-';
-}
-
-function getBlockParent(node) {
-	// Find the closest parent
-	let parentBlock = dom.getComposedParent(node);
-	while (parentBlock && !isBlock(parentBlock)) {
-		parentBlock = dom.getComposedParent(parentBlock);
-	}
-	return axe.utils.getNodeFromTree(parentBlock);
-}
-
-/**
- * Determines if an element is within a text block
- * @param  {Element} node [description]
- * @return {Boolean}      [description]
- */
-dom.isInTextBlock = function isInTextBlock(node) {
-	if (isBlock(node)) {
-		// Ignore if the link is a block
-		return false;
-	}
-
-	// Find all the text part of the parent block not in a link, and all the text in a link
-	const virtualParent = getBlockParent(node);
-	let parentText = '';
-	let linkText = '';
-	let inBrBlock = 0;
-
-	// We want to ignore hidden text, and if br / hr is used, only use the section of the parent
-	// that has the link we're looking at
-	walkDomNode(virtualParent, function(currNode) {
-		// We're already passed it, skip everything else
-		if (inBrBlock === 2) {
-			return false;
-		}
-
-		if (currNode.nodeType === 3) {
-			// Add the text to the parent
-			parentText += currNode.nodeValue;
-		}
-		// Ignore any node that's not an element (or text as above)
-		if (currNode.nodeType !== 1) {
-			return;
-		}
-
-		var nodeName = (currNode.nodeName || '').toUpperCase();
-		// BR and HR elements break the line
-		if (['BR', 'HR'].includes(nodeName)) {
-			if (inBrBlock === 0) {
-				parentText = '';
-				linkText = '';
-			} else {
-				inBrBlock = 2;
-			}
-
-			// Don't walk nodes with content not displayed on screen.
-		} else if (
-			currNode.style.display === 'none' ||
-			currNode.style.overflow === 'hidden' ||
-			!['', null, 'none'].includes(currNode.style.float) ||
-			!['', null, 'relative'].includes(currNode.style.position)
-		) {
-			return false;
-
-			// Don't walk links, we're only interested in what's not in them.
-		} else if (
-			(nodeName === 'A' && currNode.href) ||
-			(currNode.getAttribute('role') || '').toLowerCase() === 'link'
-		) {
-			if (currNode === node) {
-				inBrBlock = 1;
-			}
-			// Grab all the text from this element, but don't walk down it's children
-			linkText += currNode.textContent;
-			return false;
-		}
-	});
-
-	parentText = axe.commons.text.sanitize(parentText);
-	linkText = axe.commons.text.sanitize(linkText);
-
-	return parentText.length > linkText.length;
-};

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

@@ -1,98 +0,0 @@
-/* global dom, axe */
-
-/**
- * Determines if there is a modal currently open.
- * @method isModalOpen
- * @memberof axe.commons.dom
- * @instance
- * @return {Boolean|undefined} True if we know (or our best guess) that a modal is open, undefined if we can't tell (doesn't mean there isn't one open)
- */
-dom.isModalOpen = function isModalOpen(options) {
-	options = options || {};
-	let modalPercent = options.modalPercent || 0.75;
-
-	// there is no "definitive" way to code a modal so detecting when one is open
-	// is a bit of a guess. a modal won't always be accessible, so we can't rely
-	// on the `role` attribute, and relying on a class name as a convention is
-	// unreliable. we also cannot rely on the body/html not scrolling.
-	//
-	// because of this, we will look for two different types of modals:
-	// "definitely a modal" and "could be a modal."
-	//
-	// "definitely a modal" is any visible element that is coded to be a modal
-	// by using one of the following criteria:
-	//
-	// - has the attribute `role=dialog`
-	// - has the attribute `aria-modal=true`
-	// - is the dialog element
-	//
-	// "could be a modal" is a visible element that takes up more than 75% of
-	// the screen (though typically full width/height) and is the top-most element
-	// in the viewport. since we aren't sure if it is or is not a modal this is
-	// just our best guess of being one based on convention.
-
-	if (axe._cache.get('isModalOpen')) {
-		return axe._cache.get('isModalOpen');
-	}
-
-	const definiteModals = axe.utils.querySelectorAllFilter(
-		axe._tree[0],
-		'dialog, [role=dialog], [aria-modal=true]',
-		vNode => dom.isVisible(vNode.actualNode)
-	);
-
-	if (definiteModals.length) {
-		axe._cache.set('isModalOpen', true);
-		return true;
-	}
-
-	// to find a "could be a modal" we will take the element stack from each of
-	// four corners and one from the middle of the viewport (total of 5). if each
-	// stack contains an element whose width/height is >= 75% of the screen, we
-	// found a "could be a modal"
-	const viewport = dom.getViewportSize(window);
-	const percentWidth = viewport.width * modalPercent;
-	const percentHeight = viewport.height * modalPercent;
-	const x = (viewport.width - percentWidth) / 2;
-	const y = (viewport.height - percentHeight) / 2;
-
-	const points = [
-		// top-left corner
-		{ x, y },
-		// top-right corner
-		{ x: viewport.width - x, y },
-		// center
-		{ x: viewport.width / 2, y: viewport.height / 2 },
-		// bottom-left corner
-		{ x, y: viewport.height - y },
-		// bottom-right corner
-		{ x: viewport.width - x, y: viewport.height - y }
-	];
-
-	const stacks = points.map(point => {
-		return Array.from(document.elementsFromPoint(point.x, point.y));
-	});
-
-	for (let i = 0; i < stacks.length; i++) {
-		// a modal isn't guaranteed to be the top most element so we'll have to
-		// find the first element in the stack that meets the modal criteria
-		// and make sure it's in the other stacks
-		const modalElement = stacks[i].find(elm => {
-			const style = window.getComputedStyle(elm);
-			return (
-				parseInt(style.width, 10) >= percentWidth &&
-				parseInt(style.height, 10) >= percentHeight &&
-				style.getPropertyValue('pointer-events') !== 'none' &&
-				(style.position === 'absolute' || style.position === 'fixed')
-			);
-		});
-
-		if (modalElement && stacks.every(stack => stack.includes(modalElement))) {
-			axe._cache.set('isModalOpen', true);
-			return true;
-		}
-	}
-
-	axe._cache.set('isModalOpen', undefined);
-	return undefined;
-};

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

@@ -1,13 +0,0 @@
-/* global dom */
-/**
- * Determines if element is an instance of Node
- * @method isNode
- * @memberof axe.commons.dom
- * @instance
- * @param  {Element} element
- * @return {Boolean}
- */
-dom.isNode = function(element) {
-	'use strict';
-	return element instanceof Node;
-};

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

@@ -1,62 +0,0 @@
-/* global dom */
-
-function noParentScrolled(element, offset) {
-	element = dom.getComposedParent(element);
-	while (element && element.nodeName.toLowerCase() !== 'html') {
-		if (element.scrollTop) {
-			offset += element.scrollTop;
-			if (offset >= 0) {
-				return false;
-			}
-		}
-		element = dom.getComposedParent(element);
-	}
-	return true;
-}
-
-/**
- * Determines if element is off screen
- * @method isOffscreen
- * @memberof axe.commons.dom
- * @instance
- * @param  {Element} element
- * @return {Boolean}
- */
-dom.isOffscreen = function(element) {
-	let leftBoundary;
-	const docElement = document.documentElement;
-	const styl = window.getComputedStyle(element);
-	const dir = window
-		.getComputedStyle(document.body || docElement)
-		.getPropertyValue('direction');
-	const coords = dom.getElementCoordinates(element);
-
-	// bottom edge beyond
-	if (
-		coords.bottom < 0 &&
-		(noParentScrolled(element, coords.bottom) || styl.position === 'absolute')
-	) {
-		return true;
-	}
-
-	if (coords.left === 0 && coords.right === 0) {
-		//This is an edge case, an empty (zero-width) element that isn't positioned 'off screen'.
-		return false;
-	}
-
-	if (dir === 'ltr') {
-		if (coords.right <= 0) {
-			return true;
-		}
-	} else {
-		leftBoundary = Math.max(
-			docElement.scrollWidth,
-			dom.getViewportSize(window).width
-		);
-		if (coords.left >= leftBoundary) {
-			return true;
-		}
-	}
-
-	return false;
-};