govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/core/utils/scroll-state.js

@@ -0,0 +1,70 @@
+/**
+ * Return the scroll position of scrollable elements
+ */
+function getScroll(elm) {
+	const style = window.getComputedStyle(elm);
+	const visibleOverflowY = style.getPropertyValue('overflow-y') === 'visible';
+	const visibleOverflowX = style.getPropertyValue('overflow-x') === 'visible';
+
+	if (
+		// See if the element hides overflowing content
+		(!visibleOverflowY && elm.scrollHeight > elm.clientHeight) ||
+		(!visibleOverflowX && elm.scrollWidth > elm.clientWidth)
+	) {
+		return { elm, top: elm.scrollTop, left: elm.scrollLeft };
+	}
+}
+
+/**
+ * set the scroll position of an element
+ */
+function setScroll(elm, top, left) {
+	if (elm === window) {
+		return elm.scroll(top, left);
+	} else {
+		elm.scrollTop = top;
+		elm.scrollLeft = left;
+	}
+}
+
+/**
+ * Create an array scroll positions from descending elements
+ */
+function getElmScrollRecursive(root) {
+	return Array.from(root.children).reduce((scrolls, elm) => {
+		const scroll = getScroll(elm);
+		if (scroll) {
+			scrolls.push(scroll);
+		}
+		return scrolls.concat(getElmScrollRecursive(elm));
+	}, []);
+}
+
+/**
+ * Get the scroll position of all scrollable elements in a page
+ */
+axe.utils.getScrollState = function getScrollState(win = window) {
+	const root = win.document.documentElement;
+	const windowScroll = [
+		win.pageXOffset !== undefined
+			? {
+					elm: win,
+					top: win.pageYOffset,
+					left: win.pageXOffset
+			  }
+			: {
+					elm: root,
+					top: root.scrollTop,
+					left: root.scrollLeft
+			  }
+	];
+
+	return windowScroll.concat(getElmScrollRecursive(document.body));
+};
+
+/**
+ * set the scroll position of all items in the scrollState array
+ */
+axe.utils.setScrollState = function setScrollState(scrollState) {
+	scrollState.forEach(({ elm, top, left }) => setScroll(elm, top, left));
+};

data/node_modules/axe-core/lib/core/utils/select.js

@@ -0,0 +1,146 @@
+/**
+ * Get the deepest node in a given collection
+ * @private
+ * @param  {Array} collection Array of nodes to test
+ * @return {Node}             The deepest node
+ */
+function getDeepest(collection) {
+	'use strict';
+
+	return collection.sort(function(a, b) {
+		if (axe.utils.contains(a, b)) {
+			return 1;
+		}
+		return -1;
+	})[0];
+}
+
+/**
+ * Determines if a node is included or excluded in a given context
+ * @private
+ * @param  {Node}  node     The node to test
+ * @param  {Object}  context "Resolved" context object, @see resolveContext
+ * @return {Boolean}         [description]
+ */
+function isNodeInContext(node, context) {
+	'use strict';
+
+	var include =
+		context.include &&
+		getDeepest(
+			context.include.filter(function(candidate) {
+				return axe.utils.contains(candidate, node);
+			})
+		);
+	var exclude =
+		context.exclude &&
+		getDeepest(
+			context.exclude.filter(function(candidate) {
+				return axe.utils.contains(candidate, node);
+			})
+		);
+	if (
+		(!exclude && include) ||
+		(exclude && axe.utils.contains(exclude, include))
+	) {
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Pushes unique nodes that are in context to an array
+ * @private
+ * @param  {Array} result  The array to push to
+ * @param  {Array} nodes   The list of nodes to push
+ * @param  {Object} context The "resolved" context object, @see resolveContext
+ */
+function pushNode(result, nodes) {
+	'use strict';
+
+	var temp;
+
+	if (result.length === 0) {
+		return nodes;
+	}
+	if (result.length < nodes.length) {
+		// switch so the comparison is shortest
+		temp = result;
+		result = nodes;
+		nodes = temp;
+	}
+	for (var i = 0, l = nodes.length; i < l; i++) {
+		if (!result.includes(nodes[i])) {
+			result.push(nodes[i]);
+		}
+	}
+	return result;
+}
+
+/**
+ * reduces the includes list to only the outermost includes
+ * @param {Array} the array of include nodes
+ * @return {Array} the modified array of nodes
+ */
+function reduceIncludes(includes) {
+	return includes.reduce((res, el) => {
+		if (
+			!res.length ||
+			!res[res.length - 1].actualNode.contains(el.actualNode)
+		) {
+			res.push(el);
+		}
+		return res;
+	}, []);
+}
+
+/**
+ * Selects elements which match `selector` that are included and excluded via the `Context` object
+ * @param  {String} selector  CSS selector of the HTMLElements to select
+ * @param  {Context} context  The "resolved" context object, @see Context
+ * @return {Array}            Matching virtual DOM nodes sorted by DOM order
+ */
+/*eslint max-statements:["error", 20]*/
+axe.utils.select = function select(selector, context) {
+	'use strict';
+
+	var result = [],
+		candidate;
+	if (axe._selectCache) {
+		// if used outside of run, it will still work
+		for (var j = 0, l = axe._selectCache.length; j < l; j++) {
+			// First see whether the item exists in the cache
+			let item = axe._selectCache[j];
+			if (item.selector === selector) {
+				return item.result;
+			}
+		}
+	}
+	var curried = (function(context) {
+		return function(node) {
+			return isNodeInContext(node, context);
+		};
+	})(context);
+	var reducedIncludes = reduceIncludes(context.include);
+	for (var i = 0; i < reducedIncludes.length; i++) {
+		candidate = reducedIncludes[i];
+		if (
+			candidate.actualNode.nodeType === candidate.actualNode.ELEMENT_NODE &&
+			axe.utils.matchesSelector(candidate.actualNode, selector) &&
+			curried(candidate)
+		) {
+			result = pushNode(result, [candidate]);
+		}
+		result = pushNode(
+			result,
+			axe.utils.querySelectorAllFilter(candidate, selector, curried)
+		);
+	}
+	if (axe._selectCache) {
+		axe._selectCache.push({
+			selector: selector,
+			result: result
+		});
+	}
+	return result;
+};

data/node_modules/axe-core/lib/core/utils/to-array.js

@@ -0,0 +1,21 @@
+/**
+ * Converts array-like (numerical indicies and `length` property) structures to actual, real arrays
+ * @param	{Mixed} thing Array-like thing to convert
+ * @return {Array}
+ */
+axe.utils.toArray = function(thing) {
+	'use strict';
+	return Array.prototype.slice.call(thing);
+};
+
+/**
+ * Creates an array without duplicate values from 2 array inputs
+ * @param	{Array} arr1 First array
+ * @param	{Array} arr2 Second array
+ * @return {Array}
+ */
+axe.utils.uniqueArray = (arr1, arr2) => {
+	return arr1.concat(arr2).filter((elem, pos, arr) => {
+		return arr.indexOf(elem) === pos;
+	});
+};

data/node_modules/axe-core/lib/core/utils/token-list.js

@@ -0,0 +1,15 @@
+/**
+ * Converts space delimited token list to an Array
+ * @method tokenList
+ * @memberof axe.utils
+ * @param  {String} str
+ * @return {Array}
+ */
+axe.utils.tokenList = function(str) {
+	'use strict';
+
+	return str
+		.trim()
+		.replace(/\s{2,}/g, ' ')
+		.split(' ');
+};

data/node_modules/axe-core/lib/core/utils/uuid.js

@@ -0,0 +1,242 @@
+/*eslint no-bitwise: 0, eqeqeq: 0, curly: 0, strict: 0, no-eq-null: 0,
+max-statements: 0, complexity: 0, no-shadow: 0, no-undef: 0 */
+//		 uuid.js
+//
+//		 Copyright (c) 2010-2012 Robert Kieffer
+//		 MIT License - http://opensource.org/licenses/mit-license.php
+var uuid;
+(function(_global) {
+	// Unique ID creation requires a high quality random # generator.	We feature
+	// detect to determine the best RNG source, normalizing to a function that
+	// returns 128-bits of randomness, since that's what's usually required
+	var _rng;
+
+	// Allow for MSIE11 msCrypto
+	var _crypto = _global.crypto || _global.msCrypto;
+
+	if (!_rng && _crypto && _crypto.getRandomValues) {
+		// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
+		//
+		// Moderately fast, high quality
+		var _rnds8 = new Uint8Array(16);
+		_rng = function whatwgRNG() {
+			_crypto.getRandomValues(_rnds8);
+			return _rnds8;
+		};
+	}
+
+	if (!_rng) {
+		// Math.random()-based (RNG)
+		//
+		// If all else fails, use Math.random().	It's fast, but is of unspecified
+		// quality.
+		var _rnds = new Array(16);
+		_rng = function() {
+			for (var i = 0, r; i < 16; i++) {
+				if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
+				_rnds[i] = (r >>> ((i & 0x03) << 3)) & 0xff;
+			}
+
+			return _rnds;
+		};
+	}
+
+	// Buffer class to use
+	var BufferClass =
+		typeof _global.Buffer == 'function' ? _global.Buffer : Array;
+
+	// Maps for number <-> hex string conversion
+	var _byteToHex = [];
+	var _hexToByte = {};
+	for (var i = 0; i < 256; i++) {
+		_byteToHex[i] = (i + 0x100).toString(16).substr(1);
+		_hexToByte[_byteToHex[i]] = i;
+	}
+
+	// **`parse()` - Parse a UUID into it's component bytes**
+	function parse(s, buf, offset) {
+		var i = (buf && offset) || 0,
+			ii = 0;
+
+		buf = buf || [];
+		s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
+			if (ii < 16) {
+				// Don't overflow!
+				buf[i + ii++] = _hexToByte[oct];
+			}
+		});
+
+		// Zero out remaining bytes if string was short
+		while (ii < 16) {
+			buf[i + ii++] = 0;
+		}
+
+		return buf;
+	}
+
+	// **`unparse()` - Convert UUID byte array (ala parse()) into a string**
+	function unparse(buf, offset) {
+		var i = offset || 0,
+			bth = _byteToHex;
+		return (
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			'-' +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			'-' +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			'-' +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			'-' +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]] +
+			bth[buf[i++]]
+		);
+	}
+
+	// **`v1()` - Generate time-based UUID**
+	//
+	// Inspired by https://github.com/LiosK/UUID.js
+	// and http://docs.python.org/library/uuid.html
+
+	// random #'s we need to init node and clockseq
+	var _seedBytes = _rng();
+
+	// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+	var _nodeId = [
+		_seedBytes[0] | 0x01,
+		_seedBytes[1],
+		_seedBytes[2],
+		_seedBytes[3],
+		_seedBytes[4],
+		_seedBytes[5]
+	];
+
+	// Per 4.2.2, randomize (14 bit) clockseq
+	var _clockseq = ((_seedBytes[6] << 8) | _seedBytes[7]) & 0x3fff;
+
+	// Previous uuid creation time
+	var _lastMSecs = 0,
+		_lastNSecs = 0;
+
+	// See https://github.com/broofa/node-uuid for API details
+	function v1(options, buf, offset) {
+		var i = (buf && offset) || 0;
+		var b = buf || [];
+
+		options = options || {};
+
+		var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
+
+		// UUID timestamps are 100 nano-second units since the Gregorian epoch,
+		// (1582-10-15 00:00).	JSNumbers aren't precise enough for this, so
+		// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+		// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+		var msecs = options.msecs != null ? options.msecs : new Date().getTime();
+
+		// Per 4.2.1.2, use count of uuid's generated during the current clock
+		// cycle to simulate higher resolution clock
+		var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
+
+		// Time since last uuid creation (in msecs)
+		var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000;
+
+		// Per 4.2.1.2, Bump clockseq on clock regression
+		if (dt < 0 && options.clockseq == null) {
+			clockseq = (clockseq + 1) & 0x3fff;
+		}
+
+		// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+		// time interval
+		if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
+			nsecs = 0;
+		}
+
+		// Per 4.2.1.2 Throw error if too many uuids are requested
+		if (nsecs >= 10000) {
+			throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+		}
+
+		_lastMSecs = msecs;
+		_lastNSecs = nsecs;
+		_clockseq = clockseq;
+
+		// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+		msecs += 12219292800000;
+
+		// `time_low`
+		var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+		b[i++] = (tl >>> 24) & 0xff;
+		b[i++] = (tl >>> 16) & 0xff;
+		b[i++] = (tl >>> 8) & 0xff;
+		b[i++] = tl & 0xff;
+
+		// `time_mid`
+		var tmh = ((msecs / 0x100000000) * 10000) & 0xfffffff;
+		b[i++] = (tmh >>> 8) & 0xff;
+		b[i++] = tmh & 0xff;
+
+		// `time_high_and_version`
+		b[i++] = ((tmh >>> 24) & 0xf) | 0x10; // include version
+		b[i++] = (tmh >>> 16) & 0xff;
+
+		// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+		b[i++] = (clockseq >>> 8) | 0x80;
+
+		// `clock_seq_low`
+		b[i++] = clockseq & 0xff;
+
+		// `node`
+		var node = options.node || _nodeId;
+		for (var n = 0; n < 6; n++) {
+			b[i + n] = node[n];
+		}
+
+		return buf ? buf : unparse(b);
+	}
+
+	// **`v4()` - Generate random UUID**
+
+	// See https://github.com/broofa/node-uuid for API details
+	function v4(options, buf, offset) {
+		// Deprecated - 'format' argument, as supported in v1.2
+		var i = (buf && offset) || 0;
+
+		if (typeof options == 'string') {
+			buf = options == 'binary' ? new BufferClass(16) : null;
+			options = null;
+		}
+		options = options || {};
+
+		var rnds = options.random || (options.rng || _rng)();
+
+		// Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+		rnds[6] = (rnds[6] & 0x0f) | 0x40;
+		rnds[8] = (rnds[8] & 0x3f) | 0x80;
+
+		// Copy bytes to buffer, if provided
+		if (buf) {
+			for (var ii = 0; ii < 16; ii++) {
+				buf[i + ii] = rnds[ii];
+			}
+		}
+
+		return buf || unparse(rnds);
+	}
+
+	// Export public API
+	uuid = v4;
+	uuid.v1 = v1;
+	uuid.v4 = v4;
+	uuid.parse = parse;
+	uuid.unparse = unparse;
+	uuid.BufferClass = BufferClass;
+})(window);