govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/core/utils/node-sorter.js

@@ -0,0 +1,21 @@
+/**
+ * Array#sort callback to sort nodes by DOM order
+ * @private
+ * @param  {Node} nodeA
+ * @param  {Node} nodeB
+ * @return {Integer}   @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Sort
+ */
+axe.utils.nodeSorter = function nodeSorter(nodeA, nodeB) {
+	/*eslint no-bitwise: 0 */
+	nodeA = nodeA.actualNode || nodeA;
+	nodeB = nodeB.actualNode || nodeB;
+	if (nodeA === nodeB) {
+		return 0;
+	}
+
+	if (nodeA.compareDocumentPosition(nodeB) & 4) {
+		return -1; // a before b
+	} else {
+		return 1; // b before a
+	}
+};

data/node_modules/axe-core/lib/core/utils/performance-timer.js

@@ -0,0 +1,121 @@
+/*global utils, axe */
+
+/**
+ * Performance measuring utility shimming the User Timing API
+ *
+ * https://www.html5rocks.com/en/tutorials/webperformance/usertiming/
+ * http://caniuse.com/#search=User%20Timing
+ *
+ */
+utils.performanceTimer = (function() {
+	'use strict';
+
+	/**
+	 * Get a time/date object using performance.now() if supported
+	 * @return {DOMTimeStamp}
+	 */
+	function now() {
+		if (window.performance && window.performance) {
+			return window.performance.now();
+		}
+	}
+	var originalTime = null;
+	var lastRecordedTime = now();
+
+	/**
+	 * @typedef {utils.performanceTimer} Public API Methods
+	 */
+	return {
+		/**
+		 * @member {Function} start Kicks off performance timing for overall aXe audit
+		 */
+		start: function() {
+			this.mark('mark_axe_start');
+		},
+		/**
+		 * @member {Function} end Concludes performance timing, compares start/end marks
+		 */
+		end: function() {
+			this.mark('mark_axe_end');
+			this.measure('axe', 'mark_axe_start', 'mark_axe_end');
+
+			this.logMeasures('axe');
+		},
+		/**
+		 * @member {Function} auditStart Starts an audit for a page or frame
+		 */
+		auditStart: function() {
+			this.mark('mark_audit_start');
+		},
+		/**
+		 * @member {Function} auditEnd Ends an audit for a page or frame, logs measurement of start/end marks
+		 */
+		auditEnd: function() {
+			this.mark('mark_audit_end');
+			this.measure('audit_start_to_end', 'mark_audit_start', 'mark_audit_end');
+			// log audit/rule measures
+			this.logMeasures();
+		},
+		/**
+		 * @member {Function} mark Shims creating a new named time stamp, called a mark
+		 * @param {String} markName String name to record how long it took to get there.
+		 * A mark that already exists will be overwritten.
+		 *
+		 */
+		mark: function(markName) {
+			if (window.performance && window.performance.mark !== undefined) {
+				window.performance.mark(markName);
+			}
+		},
+		/**
+		 * @member {Function} measure Shims creating a measure to compare two marks, which can be logged
+		 * @param {String} measureName String name to log what is being compared.
+		 * Measures that already exist will be overwritten with a new time stamp.
+		 * @param {String} startMark String name of mark to start measuring
+		 * @param {String} endMark String name of mark to end measuring
+		 */
+		measure: function(measureName, startMark, endMark) {
+			if (window.performance && window.performance.measure !== undefined) {
+				window.performance.measure(measureName, startMark, endMark);
+			}
+		},
+		/**
+		 * @member {Function} logMeasures Iterates through measures and logs any that exist
+		 */
+		logMeasures: function(measureName) {
+			function log(req) {
+				axe.log('Measure ' + req.name + ' took ' + req.duration + 'ms');
+			}
+			if (
+				window.performance &&
+				window.performance.getEntriesByType !== undefined
+			) {
+				var measures = window.performance.getEntriesByType('measure');
+				for (var i = 0; i < measures.length; ++i) {
+					var req = measures[i];
+					if (req.name === measureName) {
+						log(req);
+						return;
+					}
+					log(req);
+				}
+			}
+		},
+		/**
+		 * @member {Function} timeElapsed Records time since last audit
+		 * @return {DOMTimeStamp}
+		 */
+		timeElapsed: function() {
+			return now() - lastRecordedTime;
+		},
+		/**
+		 * @member {Function} reset Resets the time for a new audit
+		 */
+		reset: function() {
+			if (!originalTime) {
+				originalTime = now();
+			}
+			lastRecordedTime = now();
+		}
+	};
+})();

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

@@ -0,0 +1,299 @@
+/* eslint-disable */
+/*
+ These pollyfills came directly from the ES Specification it's self
+ Contained within:
+	- Object.assign
+	- Array.prototype.find
+*/
+if (typeof Object.assign !== 'function') {
+	(function() {
+		Object.assign = function(target) {
+			'use strict';
+			if (target === undefined || target === null) {
+				throw new TypeError('Cannot convert undefined or null to object');
+			}
+
+			var output = Object(target);
+			for (var index = 1; index < arguments.length; index++) {
+				var source = arguments[index];
+				if (source !== undefined && source !== null) {
+					for (var nextKey in source) {
+						if (source.hasOwnProperty(nextKey)) {
+							output[nextKey] = source[nextKey];
+						}
+					}
+				}
+			}
+			return output;
+		};
+	})();
+}
+
+if (!Array.prototype.find) {
+	Object.defineProperty(Array.prototype, 'find', {
+		value: function(predicate) {
+			if (this === null) {
+				throw new TypeError('Array.prototype.find called on null or undefined');
+			}
+			if (typeof predicate !== 'function') {
+				throw new TypeError('predicate must be a function');
+			}
+			var list = Object(this);
+			var length = list.length >>> 0;
+			var thisArg = arguments[1];
+			var value;
+
+			for (var i = 0; i < length; i++) {
+				value = list[i];
+				if (predicate.call(thisArg, value, i, list)) {
+					return value;
+				}
+			}
+			return undefined;
+		}
+	});
+}
+
+axe.utils.pollyfillElementsFromPoint = function() {
+	if (document.elementsFromPoint) return document.elementsFromPoint;
+	if (document.msElementsFromPoint) return document.msElementsFromPoint;
+
+	var usePointer = (function() {
+		var element = document.createElement('x');
+		element.style.cssText = 'pointer-events:auto';
+		return element.style.pointerEvents === 'auto';
+	})();
+
+	var cssProp = usePointer ? 'pointer-events' : 'visibility';
+	var cssDisableVal = usePointer ? 'none' : 'hidden';
+
+	var style = document.createElement('style');
+	style.innerHTML = usePointer
+		? '* { pointer-events: all }'
+		: '* { visibility: visible }';
+
+	return function(x, y) {
+		var current, i, d;
+		var elements = [];
+		var previousPointerEvents = [];
+
+		// startup
+		document.head.appendChild(style);
+
+		while (
+			(current = document.elementFromPoint(x, y)) &&
+			elements.indexOf(current) === -1
+		) {
+			// push the element and its current style
+			elements.push(current);
+
+			previousPointerEvents.push({
+				value: current.style.getPropertyValue(cssProp),
+				priority: current.style.getPropertyPriority(cssProp)
+			});
+
+			// add "pointer-events: none", to get to the underlying element
+			current.style.setProperty(cssProp, cssDisableVal, 'important');
+		}
+
+		// Due to negative index, documentElement could actually not be the last,
+		// so we'll simply move it to the end
+		if (elements.indexOf(document.documentElement) < elements.length - 1) {
+			elements.splice(elements.indexOf(document.documentElement), 1);
+			elements.push(document.documentElement);
+		}
+
+		// restore the previous pointer-events values
+		for (
+			i = previousPointerEvents.length;
+			!!(d = previousPointerEvents[--i]);
+
+		) {
+			elements[i].style.setProperty(
+				cssProp,
+				d.value ? d.value : '',
+				d.priority
+			);
+		}
+
+		// teardown;
+		document.head.removeChild(style);
+
+		return elements;
+	};
+};
+
+if (typeof window.addEventListener === 'function') {
+	document.elementsFromPoint = axe.utils.pollyfillElementsFromPoint();
+}
+
+if (!Array.prototype.includes) {
+	Object.defineProperty(Array.prototype, 'includes', {
+		value: function(searchElement) {
+			'use strict';
+			var O = Object(this);
+			var len = parseInt(O.length, 10) || 0;
+			if (len === 0) {
+				return false;
+			}
+			var n = parseInt(arguments[1], 10) || 0;
+			var k;
+			if (n >= 0) {
+				k = n;
+			} else {
+				k = len + n;
+				if (k < 0) {
+					k = 0;
+				}
+			}
+			var currentElement;
+			while (k < len) {
+				currentElement = O[k];
+				if (
+					searchElement === currentElement ||
+					(searchElement !== searchElement && currentElement !== currentElement)
+				) {
+					// NaN !== NaN
+					return true;
+				}
+				k++;
+			}
+			return false;
+		}
+	});
+}
+
+// Production steps of ECMA-262, Edition 5, 15.4.4.17
+// Reference: http://es5.github.io/#x15.4.4.17
+if (!Array.prototype.some) {
+	Object.defineProperty(Array.prototype, 'some', {
+		value: function(fun) {
+			'use strict';
+
+			if (this == null) {
+				throw new TypeError('Array.prototype.some called on null or undefined');
+			}
+
+			if (typeof fun !== 'function') {
+				throw new TypeError();
+			}
+
+			var t = Object(this);
+			var len = t.length >>> 0;
+
+			var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
+			for (var i = 0; i < len; i++) {
+				if (i in t && fun.call(thisArg, t[i], i, t)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+	});
+}
+
+if (!Array.from) {
+	Object.defineProperty(Array, 'from', {
+		value: (function() {
+			var toStr = Object.prototype.toString;
+			var isCallable = function(fn) {
+				return (
+					typeof fn === 'function' || toStr.call(fn) === '[object Function]'
+				);
+			};
+			var toInteger = function(value) {
+				var number = Number(value);
+				if (isNaN(number)) {
+					return 0;
+				}
+				if (number === 0 || !isFinite(number)) {
+					return number;
+				}
+				return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+			};
+			var maxSafeInteger = Math.pow(2, 53) - 1;
+			var toLength = function(value) {
+				var len = toInteger(value);
+				return Math.min(Math.max(len, 0), maxSafeInteger);
+			};
+
+			// The length property of the from method is 1.
+			return function from(arrayLike /*, mapFn, thisArg */) {
+				// 1. Let C be the this value.
+				var C = this;
+
+				// 2. Let items be ToObject(arrayLike).
+				var items = Object(arrayLike);
+
+				// 3. ReturnIfAbrupt(items).
+				if (arrayLike == null) {
+					throw new TypeError(
+						'Array.from requires an array-like object - not null or undefined'
+					);
+				}
+
+				// 4. If mapfn is undefined, then let mapping be false.
+				var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
+				var T;
+				if (typeof mapFn !== 'undefined') {
+					// 5. else
+					// 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
+					if (!isCallable(mapFn)) {
+						throw new TypeError(
+							'Array.from: when provided, the second argument must be a function'
+						);
+					}
+
+					// 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+					if (arguments.length > 2) {
+						T = arguments[2];
+					}
+				}
+
+				// 10. Let lenValue be Get(items, "length").
+				// 11. Let len be ToLength(lenValue).
+				var len = toLength(items.length);
+
+				// 13. If IsConstructor(C) is true, then
+				// 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len.
+				// 14. a. Else, Let A be ArrayCreate(len).
+				var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+
+				// 16. Let k be 0.
+				var k = 0;
+				// 17. Repeat, while k < len… (also steps a - h)
+				var kValue;
+				while (k < len) {
+					kValue = items[k];
+					if (mapFn) {
+						A[k] =
+							typeof T === 'undefined'
+								? mapFn(kValue, k)
+								: mapFn.call(T, kValue, k);
+					} else {
+						A[k] = kValue;
+					}
+					k += 1;
+				}
+				// 18. Let putStatus be Put(A, "length", len, true).
+				A.length = len;
+				// 20. Return A.
+				return A;
+			};
+		})()
+	});
+}
+
+if (!String.prototype.includes) {
+	String.prototype.includes = function(search, start) {
+		if (typeof start !== 'number') {
+			start = 0;
+		}
+		if (start + search.length > this.length) {
+			return false;
+		} else {
+			return this.indexOf(search, start) !== -1;
+		}
+	};
+}

data/node_modules/axe-core/lib/core/utils/preload-cssom.js

@@ -0,0 +1,456 @@
+/**
+ * NOTE: 
+ * this `eslint` rule is disabled because of calling `getStyleSheetFactory` before it is defined (further below).
+ */
+/* eslint no-use-before-define: 0 */
+
+
+/**
+ * Given a rootNode - construct CSSOM
+ * -> get all source nodes (document & document fragments) within given root node
+ * -> recursively call `loadCssom` to resolve styles
+ *
+ * @method preloadCssom
+ * @memberof `axe.utils`
+ *
+ * @param {Object} object argument which is a composite object, with attributes timeout, treeRoot(optional), resolve & reject
+ * @property {Number} timeout timeout for any network calls made
+ * @property {Object} treeRoot the DOM tree to be inspected
+ * @returns {Object} `axe.utils.queue` with CSSOM assets
+ */
+axe.utils.preloadCssom = function preloadCssom({
+	timeout,
+	treeRoot = axe._tree[0]
+}) {
+	/**
+	 * get all `document` and `documentFragment` with in given `tree`
+	 */
+	const rootNodes = getAllRootNodesInTree(treeRoot);
+
+	const q = axe.utils.queue();
+
+	if (!rootNodes.length) {
+		return q;
+	}
+
+	const dynamicDoc = document.implementation.createHTMLDocument();
+	const convertDataToStylesheet = getStyleSheetFactory(dynamicDoc);
+
+	q.defer((resolve, reject) => {
+		getCssomForAllRootNodes(rootNodes, convertDataToStylesheet, timeout)
+			.then(assets => {
+				const cssom = processCssomAssets(assets);
+				resolve(cssom);
+			})
+			.catch(reject);
+	});
+
+	return q;
+};
+
+/**
+ * Returns am array of source nodes containing `document` and `documentFragment` in a given `tree`.
+ *
+ * @param {Object} treeRoot tree
+ * @returns {Array<Object>} array of objects, which each object containing a root and an optional `shadowId`
+ */
+function getAllRootNodesInTree(tree) {
+	let ids = [];
+
+	const rootNodes = axe.utils
+		.querySelectorAllFilter(tree, '*', node => {
+			if (ids.includes(node.shadowId)) {
+				return false;
+			}
+			ids.push(node.shadowId);
+			return true;
+		})
+		.map(node => {
+			return {
+				shadowId: node.shadowId,
+				rootNode: axe.utils.getRootNode(node.actualNode)
+			};
+		});
+
+	return axe.utils.uniqueArray(rootNodes, []);
+}
+
+/**
+ * Convert text to CSSStyleSheet
+ * Is a factory (closure) function, initialized with `document.implementation.createHTMLDocument()` which surfaces DOM API for creating `style` elements.
+ *
+ * @param {Object} param `document.implementation.createHTMLDocument()
+ * @param {Object} arg an object with properties to construct stylesheet
+ * @property {String} arg.data text content of the stylesheet
+ * @property {Boolean} arg.isExternal flag to notify if the resource was fetched from the network
+ * @property {String} arg.shadowId (Optional) shadowId if shadowDOM
+ * @property {Object} arg.root implementation document to create style elements
+ * @property {String} arg.priority a number indicating the loaded priority of CSS, to denote specificity of styles contained in the sheet.
+ */
+const getStyleSheetFactory = dynamicDoc => ({
+	data,
+	isExternal,
+	shadowId,
+	root,
+	priority,
+	isLink = false
+}) => {
+	const style = dynamicDoc.createElement('style');
+	if (isLink) {
+		// as creating a stylesheet as link will need to be awaited
+		// till `onload`, it is wise to convert link href to @import statement
+		const text = dynamicDoc.createTextNode(`@import "${data.href}"`);
+		style.appendChild(text);
+	} else {
+		style.appendChild(dynamicDoc.createTextNode(data));
+	}
+	dynamicDoc.head.appendChild(style);
+	return {
+		sheet: style.sheet,
+		isExternal,
+		shadowId,
+		root,
+		priority
+	};
+};
+
+/**
+ * Deferred function for CSSOM queue processing on all root nodes
+ *
+ * @param {Array<Object>} rootNodes array of root nodes, where node  is an enhanced `document` or `documentFragment` object returned from `getAllRootNodesInTree`
+ * @param {Function} convertDataToStylesheet fn to convert given data to Stylesheet object
+ * @returns {Object} `axe.utils.queue`
+ */
+function getCssomForAllRootNodes(rootNodes, convertDataToStylesheet, timeout) {
+	const q = axe.utils.queue();
+
+	rootNodes.forEach(({ rootNode, shadowId }, index) =>
+		q.defer((resolve, reject) =>
+			loadCssom({
+				rootNode,
+				shadowId,
+				timeout,
+				convertDataToStylesheet,
+				rootIndex: index + 1
+			})
+				.then(resolve)
+				.catch(reject)
+		)
+	);
+
+	return q;
+}
+
+/**
+ * Process results from `loadCssom` queues of all root nodes
+ * NOTE:
+ * using `axe.utils.queue` from various `loadCssom` paths, returns a nested array of arrays at various depths,
+ * hence the need to flatten arrays
+ *
+ * @param {Array<Object>} assets CSSOM assets for each root
+ * @returns {Object} CSSOM object
+ */
+function processCssomAssets(nestedAssets) {
+	const result = [];
+
+	nestedAssets.forEach(item => {
+		if (Array.isArray(item)) {
+			result.push(...processCssomAssets(item));
+		} else {
+			result.push(item);
+		}
+	});
+
+	return result;
+}
+
+/**
+ * Returns `axe.utils.queue` of CSSStyleSheet(s) for a given root node
+ *
+ * @param {Object} options configuration options
+ * @property {Object} options.rootNode document or document fragment
+ * @property {Number} options.rootIndex a number representing the index of the document or document fragment, used for priority computation
+ * @property {String} options.shadowId an id if undefined denotes that given root is a document fragment/ shadowDOM
+ * @property {Number} options.timeout abort duration for network request
+ * @property {Function} options.convertDataToStylesheet a utility function to generate a style sheet from given data (text)
+ * @return {Object} queue
+ */
+function loadCssom(options) {
+	const { rootIndex } = options;
+
+	const q = axe.utils.queue();
+
+	const sheets = getStylesheetsOfRootNode(options);
+	if (!sheets) {
+		return q;
+	}
+
+	sheets.forEach((sheet, sheetIndex) => {
+		const priority = [rootIndex, sheetIndex];
+		try {
+			const deferredQ = parseNonCrossOriginStylesheet(sheet, options, priority);
+			q.defer(deferredQ);
+		} catch (e) {
+			// cross-origin stylesheet -> make an XHR and q the response
+			const deferredQ = parseCrossOriginStylesheet(
+				sheet.href,
+				options,
+				priority
+			);
+			q.defer(deferredQ);
+		}
+	});
+
+	return q;
+}
+
+/**
+ * Parse non cross-origin stylesheets
+ *
+ * @param {Object} sheet CSSStylesheet object
+ * @param {Object} options `loadCssom` options
+ * @param {Array<Number>} priority sheet priority
+ */
+function parseNonCrossOriginStylesheet(sheet, options, priority) {
+	const q = axe.utils.queue();
+
+	/**
+	 * `sheet.cssRules` throws an error on `cross-origin` stylesheets
+	 */
+	const cssRules = sheet.cssRules;
+
+	const rules = Array.from(cssRules);
+	if (!rules) {
+		return q;
+	}
+
+	/**
+	 * reference -> https://developer.mozilla.org/en-US/docs/Web/API/CSSRule#Type_constants
+	 */
+	const cssImportRules = rules.filter(r => r.type === 3); // type === 3 -> CSSRule.IMPORT_RULE
+
+	/**
+	 * when no `@import` rules in given sheet
+	 * -> resolve the current `sheet` & exit
+	 */
+	if (!cssImportRules.length) {
+		q.defer(resolve =>
+			resolve({
+				isExternal: false,
+				priority,
+				root: options.rootNode,
+				shadowId: options.shadowId,
+				sheet
+			})
+		);
+
+		// exit
+		return q;
+	}
+
+	/**
+	 * iterate `@import` rules and fetch styles
+	 */
+	cssImportRules.forEach((importRule, cssRuleIndex) =>
+		q.defer((resolve, reject) => {
+			const importUrl = importRule.href;
+			const newPriority = [...priority, cssRuleIndex];
+			const axiosOptions = {
+				method: 'get',
+				url: importUrl,
+				timeout: options.timeout
+			};
+			axe.imports
+				.axios(axiosOptions)
+				.then(({ data }) =>
+					resolve(
+						options.convertDataToStylesheet({
+							data,
+							isExternal: true,
+							priority: newPriority,
+							root: options.rootNode,
+							shadowId: options.shadowId
+						})
+					)
+				)
+				.catch(reject);
+		})
+	);
+
+	const nonImportCSSRules = rules.filter(r => r.type !== 3);
+
+	// no further rules to process in this sheet
+	if (!nonImportCSSRules.length) {
+		return q;
+	}
+
+	// convert all `nonImportCSSRules` style rules into `text` and defer into queue
+	q.defer(resolve =>
+		resolve(
+			options.convertDataToStylesheet({
+				data: nonImportCSSRules.map(rule => rule.cssText).join(),
+				isExternal: false,
+				priority,
+				root: options.rootNode,
+				shadowId: options.shadowId
+			})
+		)
+	);
+
+	return q;
+}
+
+/**
+ * Parse cross-origin stylesheets
+ *
+ * @param {String} url url from which to fetch stylesheet
+ * @param {Object} options `loadCssom` options
+ * @param {Array<Number>} priority sheet priority
+ */
+function parseCrossOriginStylesheet(url, options, priority) {
+	const q = axe.utils.queue();
+
+	if (!url) {
+		return q;
+	}
+
+	const axiosOptions = {
+		method: 'get',
+		url,
+		timeout: options.timeout
+	};
+
+	q.defer((resolve, reject) => {
+		axe.imports
+			.axios(axiosOptions)
+			.then(({ data }) =>
+				resolve(
+					options.convertDataToStylesheet({
+						data,
+						isExternal: true,
+						priority,
+						root: options.rootNode,
+						shadowId: options.shadowId
+					})
+				)
+			)
+			.catch(reject);
+	});
+
+	return q;
+}
+
+/**
+ * Get stylesheet(s) for root
+ *
+ * @param {Object} options configuration options of `loadCssom`
+ * @returns an array of stylesheets
+ */
+function getStylesheetsOfRootNode(options) {
+	const { rootNode, shadowId } = options;
+	let sheets;
+
+	// nodeType === 11  -> DOCUMENT_FRAGMENT
+	if (rootNode.nodeType === 11 && shadowId) {
+		sheets = getStylesheetsFromDocumentFragment(options);
+	} else {
+		sheets = getStylesheetsFromDocument(rootNode);
+	}
+
+	return filterStylesheetsWithSameHref(sheets);
+}
+
+/**
+ * Get stylesheets from `documentFragment`
+ *
+ * @param {Object} options configuration options of `loadCssom`
+ * @returns {Array<Object>}
+ */
+function getStylesheetsFromDocumentFragment(options) {
+	const { rootNode, convertDataToStylesheet } = options;
+	return (
+		Array.from(rootNode.children)
+			.filter(filerStyleAndLinkAttributesInDocumentFragment)
+			// Reducer to convert `<style></style>` and `<link>` references to `CSSStyleSheet` object
+			.reduce((out, node) => {
+				const nodeName = node.nodeName.toUpperCase();
+				const data = nodeName === 'STYLE' ? node.textContent : node;
+				const isLink = nodeName === 'LINK';
+				const stylesheet = convertDataToStylesheet({
+					data,
+					isLink,
+					root: rootNode
+				});
+				out.push(stylesheet.sheet);
+				return out;
+			}, [])
+	);
+}
+
+/**
+ * Get stylesheets from `document`
+ * -> filter out stylesheet that are `media=print`
+ *
+ * @param {Object} rootNode `document`
+ * @returns {Array<Object>}
+ */
+function getStylesheetsFromDocument(rootNode) {
+	return Array.from(rootNode.styleSheets).filter(sheet =>
+		filterMediaIsPrint(sheet.media.mediaText)
+	);
+}
+
+/**
+ * Get all `<style></style>` and `<link>` attributes
+ * -> limit to only `style` or `link` attributes with `rel=stylesheet` and `media != print`
+ *
+ * @param {Object} node HTMLElement
+ * @returns {Boolean}
+ */
+function filerStyleAndLinkAttributesInDocumentFragment(node) {
+	const nodeName = node.nodeName.toUpperCase();
+	const linkHref = node.getAttribute('href');
+	const linkRel = node.getAttribute('rel');
+	const isLink =
+		nodeName === 'LINK' &&
+		linkHref &&
+		linkRel &&
+		node.rel.toUpperCase().includes('STYLESHEET');
+	const isStyle = nodeName === 'STYLE';
+	return isStyle || (isLink && filterMediaIsPrint(node.media));
+}
+
+/**
+ * Exclude `link[rel='stylesheet]` attributes where `media=print`
+ *
+ * @param {String} media media value eg: 'print'
+ * @returns {Boolean}
+ */
+function filterMediaIsPrint(media) {
+	if (!media) {
+		return true;
+	}
+	return !media.toUpperCase().includes('PRINT');
+}
+
+/**
+ * Exclude any duplicate `stylesheets`, that share the same `href`
+ *
+ * @param {Array<Object>} sheets stylesheets
+ * @returns {Array<Object>}
+ */
+function filterStylesheetsWithSameHref(sheets) {
+	let hrefs = [];
+	return sheets.filter(sheet => {
+		if (!sheet.href) {
+			// include sheets without `href`
+			return true;
+		}
+		// if `href` is present, ensure they are not duplicates
+		if (hrefs.includes(sheet.href)) {
+			return false;
+		}
+		hrefs.push(sheet.href);
+		return true;
+	});
+}