govuk_publishing_components 18.1.0 → 18.1.1

data/node_modules/axe-core/lib/core/imports/index.js

@@ -0,0 +1,26 @@
+/* global axe */
+
+/**
+ * Note:
+ * This file is run via browserify to pull in the required dependencies.
+ * See - './build/imports-generator'
+ */
+
+/**
+ * Polyfill `Promise`
+ * Reference: https://www.npmjs.com/package/es6-promise
+ */
+require('es6-promise').polyfill();
+
+/**
+ * Namespace `axe.imports` which holds required external dependencies
+ *
+ * @namespace imports
+ * @memberof axe
+ */
+axe.imports = {
+	axios: require('axios'),
+	CssSelectorParser: require('css-selector-parser').CssSelectorParser,
+	doT: require('dot'),
+	emojiRegexText: require('emoji-regex')
+};

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

@@ -0,0 +1,45 @@
+/*exported axe, commons */
+/*global axeFunction, module, define */
+// exported namespace for aXe
+/*eslint no-use-before-define: 0, no-unused-vars: 0*/
+var axe = axe || {};
+axe.version = '<%= pkg.version %>';
+
+if (typeof define === 'function' && define.amd) {
+	// Explicitly naming the module to avoid mismatched anonymous define() modules when injected in a page
+	define('axe-core', [], function() {
+		'use strict';
+		return axe;
+	});
+}
+if (
+	typeof module === 'object' &&
+	module.exports &&
+	typeof axeFunction.toString === 'function'
+) {
+	axe.source =
+		'(' +
+		axeFunction.toString() +
+		')(typeof window === "object" ? window : this);';
+	module.exports = axe;
+}
+if (typeof window.getComputedStyle === 'function') {
+	window.axe = axe;
+}
+// local namespace for common functions
+var commons;
+
+function SupportError(error) {
+	this.name = 'SupportError';
+	this.cause = error.cause;
+	this.message = `\`${
+		error.cause
+	}\` - feature unsupported in your environment.`;
+	if (error.ruleId) {
+		this.ruleId = error.ruleId;
+		this.message += ` Skipping ${this.ruleId} rule.`;
+	}
+	this.stack = new Error().stack;
+}
+SupportError.prototype = Object.create(Error.prototype);
+SupportError.prototype.constructor = SupportError;

data/node_modules/axe-core/lib/core/log.js

@@ -0,0 +1,12 @@
+/*eslint no-console: 0 */
+
+/**
+ * Logs a message to the developer console (if it exists and is active).
+ */
+axe.log = function() {
+	'use strict';
+	if (typeof console === 'object' && console.log) {
+		// IE does not support console.log.apply
+		Function.prototype.apply.call(console.log, console, arguments);
+	}
+};

data/node_modules/axe-core/lib/core/public/cleanup-plugins.js

@@ -0,0 +1,53 @@
+function cleanupPlugins(resolve, reject) {
+	'use strict';
+	resolve = resolve || function() {};
+	reject = reject || axe.log;
+
+	if (!axe._audit) {
+		throw new Error('No audit configured');
+	}
+
+	var q = axe.utils.queue();
+	// If a plugin fails it's cleanup, we still want the others to run
+	var cleanupErrors = [];
+
+	Object.keys(axe.plugins).forEach(function(key) {
+		q.defer(function(res) {
+			var rej = function(err) {
+				cleanupErrors.push(err);
+				res();
+			};
+			try {
+				axe.plugins[key].cleanup(res, rej);
+			} catch (err) {
+				rej(err);
+			}
+		});
+	});
+
+	var flattenedTree = axe.utils.getFlattenedTree(document.body);
+
+	axe.utils
+		.querySelectorAll(flattenedTree, 'iframe, frame')
+		.forEach(function(node) {
+			q.defer(function(res, rej) {
+				return axe.utils.sendCommandToFrame(
+					node.actualNode,
+					{
+						command: 'cleanup-plugin'
+					},
+					res,
+					rej
+				);
+			});
+		});
+
+	q.then(function(results) {
+		if (cleanupErrors.length === 0) {
+			resolve(results);
+		} else {
+			reject(cleanupErrors);
+		}
+	}).catch(reject);
+}
+axe.cleanup = cleanupPlugins;

data/node_modules/axe-core/lib/core/public/configure.js

@@ -0,0 +1,57 @@
+/* global reporters */
+function configureChecksRulesAndBranding(spec) {
+	/*eslint max-statements: ["error",21]*/
+	'use strict';
+	var audit;
+
+	audit = axe._audit;
+	if (!audit) {
+		throw new Error('No audit configured');
+	}
+
+	if (
+		spec.reporter &&
+		(typeof spec.reporter === 'function' || reporters[spec.reporter])
+	) {
+		audit.reporter = spec.reporter;
+	}
+
+	if (spec.checks) {
+		spec.checks.forEach(function(check) {
+			audit.addCheck(check);
+		});
+	}
+
+	const modifiedRules = [];
+	if (spec.rules) {
+		spec.rules.forEach(function(rule) {
+			modifiedRules.push(rule.id);
+			audit.addRule(rule);
+		});
+	}
+
+	if (spec.disableOtherRules) {
+		audit.rules.forEach(rule => {
+			if (modifiedRules.includes(rule.id) === false) {
+				rule.enabled = false;
+			}
+		});
+	}
+
+	if (typeof spec.branding !== 'undefined') {
+		audit.setBranding(spec.branding);
+	} else {
+		audit._constructHelpUrls();
+	}
+
+	if (spec.tagExclude) {
+		audit.tagExclude = spec.tagExclude;
+	}
+
+	// Support runtime localization
+	if (spec.locale) {
+		audit.applyLocale(spec.locale);
+	}
+}
+
+axe.configure = configureChecksRulesAndBranding;

data/node_modules/axe-core/lib/core/public/get-rules.js

@@ -0,0 +1,29 @@
+/**
+ * Searches and returns rules that contain a tag in the list of tags.
+ * @param  {Array}   tags  Optional array of tags
+ * @return {Array}  Array of rules
+ */
+axe.getRules = function(tags) {
+	'use strict';
+
+	tags = tags || [];
+	var matchingRules = !tags.length
+		? axe._audit.rules
+		: axe._audit.rules.filter(function(item) {
+				return !!tags.filter(function(tag) {
+					return item.tags.indexOf(tag) !== -1;
+				}).length;
+		  });
+
+	var ruleData = axe._audit.data.rules || {};
+	return matchingRules.map(function(matchingRule) {
+		var rd = ruleData[matchingRule.id] || {};
+		return {
+			ruleId: matchingRule.id,
+			description: rd.description,
+			help: rd.help,
+			helpUrl: rd.helpUrl,
+			tags: matchingRule.tags
+		};
+	});
+};

data/node_modules/axe-core/lib/core/public/load.js

@@ -0,0 +1,66 @@
+/*global Audit, runRules, cleanupPlugins */
+/*eslint indent: 0*/
+function runCommand(data, keepalive, callback) {
+	'use strict';
+	var resolve = callback;
+	var reject = function(err) {
+		if (err instanceof Error === false) {
+			err = new Error(err);
+		}
+		callback(err);
+	};
+
+	var context = (data && data.context) || {};
+	if (context.hasOwnProperty('include') && !context.include.length) {
+		context.include = [document];
+	}
+	var options = (data && data.options) || {};
+
+	switch (data.command) {
+		case 'rules':
+			return runRules(
+				context,
+				options,
+				function(results, cleanup) {
+					resolve(results);
+					// Cleanup AFTER resolve so that selectors can be generated
+					cleanup();
+				},
+				reject
+			);
+		case 'cleanup-plugin':
+			return cleanupPlugins(resolve, reject);
+		default:
+			// go through the registered commands
+			if (
+				axe._audit &&
+				axe._audit.commands &&
+				axe._audit.commands[data.command]
+			) {
+				return axe._audit.commands[data.command](data, callback);
+			}
+	}
+}
+
+/**
+ * Sets up Rules, Messages and default options for Checks, must be invoked before attempting analysis
+ * @param  {Object} audit The "audit specification" object
+ * @private
+ */
+axe._load = function(audit) {
+	'use strict';
+
+	axe.utils.respondable.subscribe('axe.ping', function(
+		data,
+		keepalive,
+		respond
+	) {
+		respond({
+			axe: true
+		});
+	});
+
+	axe.utils.respondable.subscribe('axe.start', runCommand);
+
+	axe._audit = new Audit(audit);
+};

data/node_modules/axe-core/lib/core/public/plugins.js

@@ -0,0 +1,47 @@
+/*eslint no-use-before-define:0 */
+var axe = axe || {};
+axe.plugins = {};
+
+function Plugin(spec) {
+	'use strict';
+	this._run = spec.run;
+	this._collect = spec.collect;
+	this._registry = {};
+	spec.commands.forEach(function(command) {
+		axe._audit.registerCommand(command);
+	});
+}
+
+Plugin.prototype.run = function() {
+	'use strict';
+	return this._run.apply(this, arguments);
+};
+
+Plugin.prototype.collect = function() {
+	'use strict';
+	return this._collect.apply(this, arguments);
+};
+
+Plugin.prototype.cleanup = function(done) {
+	'use strict';
+	var q = axe.utils.queue();
+	var that = this;
+	Object.keys(this._registry).forEach(function(key) {
+		q.defer(function(done) {
+			that._registry[key].cleanup(done);
+		});
+	});
+	q.then(function() {
+		done();
+	});
+};
+
+Plugin.prototype.add = function(impl) {
+	'use strict';
+	this._registry[impl.id] = impl;
+};
+
+axe.registerPlugin = function(plugin) {
+	'use strict';
+	axe.plugins[plugin.id] = new Plugin(plugin);
+};

data/node_modules/axe-core/lib/core/public/reporter.js

@@ -0,0 +1,24 @@
+var reporters = {};
+var defaultReporter;
+
+axe.getReporter = function(reporter) {
+	'use strict';
+	if (typeof reporter === 'string' && reporters[reporter]) {
+		return reporters[reporter];
+	}
+
+	if (typeof reporter === 'function') {
+		return reporter;
+	}
+
+	return defaultReporter;
+};
+
+axe.addReporter = function registerReporter(name, cb, isDefault) {
+	'use strict';
+
+	reporters[name] = cb;
+	if (isDefault) {
+		defaultReporter = cb;
+	}
+};

data/node_modules/axe-core/lib/core/public/reset.js

@@ -0,0 +1,12 @@
+/*global axe */
+function resetConfiguration() {
+	'use strict';
+	var audit = axe._audit;
+
+	if (!audit) {
+		throw new Error('No audit configured');
+	}
+	audit.resetRulesAndChecks();
+}
+
+axe.reset = resetConfiguration;

data/node_modules/axe-core/lib/core/public/run-rules.js

@@ -0,0 +1,94 @@
+/*global Context */
+/*exported runRules */
+
+// Clean up after resolve / reject
+function cleanup() {
+	axe._tree = undefined;
+	axe._selectorData = undefined;
+}
+
+/**
+ * Starts analysis on the current document and its subframes
+ * @private
+ * @param  {Object}   context  The `Context` specification object @see Context
+ * @param  {Array}    options  Optional RuleOptions
+ * @param  {Function} resolve  Called when done running rules, receives ([results : Object], cleanup : Function)
+ * @param  {Function} reject   Called when execution failed, receives (err : Error)
+ */
+function runRules(context, options, resolve, reject) {
+	'use strict';
+	try {
+		context = new Context(context);
+		axe._tree = context.flatTree;
+		axe._selectorData = axe.utils.getSelectorData(context.flatTree);
+	} catch (e) {
+		cleanup();
+		return reject(e);
+	}
+
+	var q = axe.utils.queue();
+	var audit = axe._audit;
+
+	if (options.performanceTimer) {
+		axe.utils.performanceTimer.auditStart();
+	}
+
+	if (context.frames.length && options.iframes !== false) {
+		q.defer(function(res, rej) {
+			axe.utils.collectResultsFromFrames(
+				context,
+				options,
+				'rules',
+				null,
+				res,
+				rej
+			);
+		});
+	}
+	let scrollState;
+	q.defer(function(res, rej) {
+		if (options.restoreScroll) {
+			scrollState = axe.utils.getScrollState();
+		}
+		audit.run(context, options, res, rej);
+	});
+	q.then(function(data) {
+		try {
+			if (scrollState) {
+				axe.utils.setScrollState(scrollState);
+			}
+			if (options.performanceTimer) {
+				axe.utils.performanceTimer.auditEnd();
+			}
+
+			// Add wrapper object so that we may use the same "merge" function for results from inside and outside frames
+			var results = axe.utils.mergeResults(
+				data.map(function(results) {
+					return { results };
+				})
+			);
+
+			// after should only run once, so ensure we are in the top level window
+			if (context.initiator) {
+				results = audit.after(results, options);
+
+				results.forEach(axe.utils.publishMetaData);
+				results = results.map(axe.utils.finalizeRuleResult);
+			}
+			try {
+				resolve(results, cleanup);
+			} catch (e) {
+				cleanup();
+				axe.log(e);
+			}
+		} catch (e) {
+			cleanup();
+			reject(e);
+		}
+	}).catch(e => {
+		cleanup();
+		reject(e);
+	});
+}
+
+axe._runRules = runRules;