govuk_fe_assets 0.1.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9de41385cb47d0fa1164b2b54d1989de277d4e92
+  data.tar.gz: f8d16455304b07fd11b98a619cc6240117079baf
+SHA512:
+  metadata.gz: bd0550ad05a62a77678b980cc7b445670ecf53b388041e6ed923cc35137c3ea75e43e02b12fb0ed7072b73026fb730ea8eb49134292b5112507dd5c7f08b26f0
+  data.tar.gz: 83215505fbd0e2317a67c99102ca4c92ee10084136e77810e44eab03b0ab2aa61c9159160143dfd7d440403e819eab5ed674cd76c9b8e75d53c39df697c0c367

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.15.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in govuk_fe_assets.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Tijmen Brommet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# GovukFeAssets
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/govuk_fe_assets`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'govuk_fe_assets'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install govuk_fe_assets
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tijmenb/govuk_fe_assets.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/govuk_fe_assets.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "govuk_fe_assets/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "govuk_fe_assets"
+  spec.version       = GovukFeAssets::VERSION
+  spec.authors       = ["Tijmen Brommet"]
+  spec.email         = ["tijmen@gmail.com"]
+
+  spec.summary       = %q{FE asssets - do not use this gem}
+  spec.description   = %q{FE asssets - do not use this gem}
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/govuk_fe_assets.rb

@@ -0,0 +1,5 @@
+require "govuk_fe_assets/version"
+
+module GovukFeAssets
+  # Your code goes here...
+end

data/lib/govuk_fe_assets/version.rb

@@ -0,0 +1,3 @@
+module GovukFeAssets
+  VERSION = "0.1.0-alpha"
+end

data/node_modules/govuk-frontend/README.md

@@ -0,0 +1,96 @@
+# GOV.UK Frontend
+
+GOV.UK Frontend contains the code you need to start building a user interface
+for government platforms and services.
+
+See live examples of GOV.UK Frontend components, and guidance on when to use
+them in your service, in the [GOV.UK Design System](https://www.gov.uk/design-system).
+
+## Contact the team
+
+GOV.UK Frontend is maintained by a team at Government Digital Service. If you want to know more about GOV.UK Frontend, please email the [Design System
+team](mailto:govuk-design-system-support@digital.cabinet-office.gov.uk) or get in touch with them on [Slack](https://ukgovernmentdigital.slack.com/messages/govuk-design-system).
+
+## Quick start
+
+There are 2 ways to start using GOV.UK Frontend in your app.
+
+Once installed, you will be able to use the code from the examples in the
+[GOV.UK Design System](https://www.gov.uk/design-system in your service.
+
+### 1. Install with npm (recommended)
+
+We recommend [installing GOV.UK Frontend using node package manager
+(npm)](https://github.com/alphagov/govuk-frontend/blob/master/docs/installation/installing-with-npm.md).
+
+### 2. Install by using compiled files
+
+You can also [download the compiled and minified assets (CSS, JavaScript) from
+GitHub](https://github.com/alphagov/govuk-frontend/blob/master/docs/installation/installing-from-dist.md).
+
+## Importing styles
+
+You need to import the GOV.UK Frontend styles into the main Sass file in your
+project. You should place the below code before your own Sass rules (or Sass
+imports) if you want to override GOV.UK Frontend with your own styles.
+
+To import add the below to your Sass file:
+
+  ```scss
+  @import "node_modules/govuk-frontend/all";
+  ```
+
+[More details on importing styles](https://github.com/alphagov/govuk-frontend/blob/master/docs/installation/installing-with-npm.md#importing-styles)
+
+## Importing JavaScript
+
+Some of the JavaScript included in GOV.UK Frontend improves the usability and
+accessibility of the components. You should make sure that you are importing and
+initialising Javascript in your application to ensure that all users can use it successfully.
+
+You can include Javascript for all components either by copying the `all.js` from `node_modules/govuk-frontend` into your application or referencing the file directly:
+
+```html
+<script src="<path-to-govuk-frontend-all-file>/all.js"></script>
+```
+Next you need to initialise the script by adding:
+
+```html
+<script>window.GOVUKFrontend.initAll()</script>
+```
+
+[More details on importing Javascript and advanced options](https://github.com/alphagov/govuk-frontend/blob/master/docs/installation/installing-with-npm.md#importing-javascript)
+
+
+## Importing assets
+
+In order to import GOV.UK Frontend images and fonts to your project, you should configure your application to reference or copy the relevant GOV.UK Frontend assets.
+
+[More details on importing assets](https://github.com/alphagov/govuk-frontend/blob/master/docs/installation/installing-with-npm.md#import-assets)
+
+
+## Getting updates
+
+To check whether you have the latest version of GOV.UK Frontend, run:
+
+```
+npm outdated govuk-frontend
+```
+
+To update to the latest version, run:
+
+```
+npm update govuk-frontend
+```
+
+## Licence
+
+Unless stated otherwise, the codebase is released under the MIT License. This
+covers both the codebase and any sample code in the documentation. The
+documentation is &copy; Crown copyright and available under the terms of the
+Open Government 3.0 licence.
+
+## Contribution guidelines
+
+If you want to help us build GOV.UK Frontend, view our [contribution
+guidelines](https://github.com/alphagov/govuk-frontend/blob/master/CONTRIBUTING.md).

data/node_modules/govuk-frontend/all-ie8.scss

@@ -0,0 +1,6 @@
+// By setting $govuk-is-ie8 to true, we create a version of the stylesheet that
+// targets IE8 – e.g. conditionally including or excluding styles, and
+// rasterizing media queries.
+$govuk-is-ie8: true;
+
+@import "all";

data/node_modules/govuk-frontend/all.js

@@ -0,0 +1,1720 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define('GOVUKFrontend', ['exports'], factory) :
+	(factory((global.GOVUKFrontend = {})));
+}(this, (function (exports) { 'use strict';
+
+/**
+ * TODO: Ideally this would be a NodeList.prototype.forEach polyfill
+ * This seems to fail in IE8, requires more investigation.
+ * See: https://github.com/imagitama/nodelist-foreach-polyfill
+ */
+function nodeListForEach (nodes, callback) {
+  if (window.NodeList.prototype.forEach) {
+    return nodes.forEach(callback)
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    callback.call(window, nodes[i], i, nodes);
+  }
+}
+
+// Used to generate a unique string, allows multiple instances of the component without
+// Them conflicting with each other.
+// https://stackoverflow.com/a/8809472
+function generateUniqueID () {
+  var d = new Date().getTime();
+  if (typeof window.performance !== 'undefined' && typeof window.performance.now === 'function') {
+    d += window.performance.now(); // use high-precision timer if available
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16)
+  })
+}
+
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Window/detect.js
+var detect = ('Window' in this);
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Window&flags=always
+if ((typeof WorkerGlobalScope === "undefined") && (typeof importScripts !== "function")) {
+	(function (global) {
+		if (global.constructor) {
+			global.Window = global.constructor;
+		} else {
+			(global.Window = global.constructor = new Function('return function Window() {}')()).prototype = this;
+		}
+	}(this));
+}
+
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Document/detect.js
+var detect = ("Document" in this);
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Document&flags=always
+if ((typeof WorkerGlobalScope === "undefined") && (typeof importScripts !== "function")) {
+
+	if (this.HTMLDocument) { // IE8
+
+		// HTMLDocument is an extension of Document.  If the browser has HTMLDocument but not Document, the former will suffice as an alias for the latter.
+		this.Document = this.HTMLDocument;
+
+	} else {
+
+		// Create an empty function to act as the missing constructor for the document object, attach the document object as its prototype.  The function needs to be anonymous else it is hoisted and causes the feature detect to prematurely pass, preventing the assignments below being made.
+		this.Document = this.HTMLDocument = document.constructor = (new Function('return function Document() {}')());
+		this.Document.prototype = document;
+	}
+}
+
+
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Element/detect.js
+var detect = ('Element' in this && 'HTMLElement' in this);
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Element&flags=always
+(function () {
+
+	// IE8
+	if (window.Element && !window.HTMLElement) {
+		window.HTMLElement = window.Element;
+		return;
+	}
+
+	// create Element constructor
+	window.Element = window.HTMLElement = new Function('return function Element() {}')();
+
+	// generate sandboxed iframe
+	var vbody = document.appendChild(document.createElement('body'));
+	var frame = vbody.appendChild(document.createElement('iframe'));
+
+	// use sandboxed iframe to replicate Element functionality
+	var frameDocument = frame.contentWindow.document;
+	var prototype = Element.prototype = frameDocument.appendChild(frameDocument.createElement('*'));
+	var cache = {};
+
+	// polyfill Element.prototype on an element
+	var shiv = function (element, deep) {
+		var
+		childNodes = element.childNodes || [],
+		index = -1,
+		key, value, childNode;
+
+		if (element.nodeType === 1 && element.constructor !== Element) {
+			element.constructor = Element;
+
+			for (key in cache) {
+				value = cache[key];
+				element[key] = value;
+			}
+		}
+
+		while (childNode = deep && childNodes[++index]) {
+			shiv(childNode, deep);
+		}
+
+		return element;
+	};
+
+	var elements = document.getElementsByTagName('*');
+	var nativeCreateElement = document.createElement;
+	var interval;
+	var loopLimit = 100;
+
+	prototype.attachEvent('onpropertychange', function (event) {
+		var
+		propertyName = event.propertyName,
+		nonValue = !cache.hasOwnProperty(propertyName),
+		newValue = prototype[propertyName],
+		oldValue = cache[propertyName],
+		index = -1,
+		element;
+
+		while (element = elements[++index]) {
+			if (element.nodeType === 1) {
+				if (nonValue || element[propertyName] === oldValue) {
+					element[propertyName] = newValue;
+				}
+			}
+		}
+
+		cache[propertyName] = newValue;
+	});
+
+	prototype.constructor = Element;
+
+	if (!prototype.hasAttribute) {
+		// <Element>.hasAttribute
+		prototype.hasAttribute = function hasAttribute(name) {
+			return this.getAttribute(name) !== null;
+		};
+	}
+
+	// Apply Element prototype to the pre-existing DOM as soon as the body element appears.
+	function bodyCheck() {
+		if (!(loopLimit--)) clearTimeout(interval);
+		if (document.body && !document.body.prototype && /(complete|interactive)/.test(document.readyState)) {
+			shiv(document, true);
+			if (interval && document.body.prototype) clearTimeout(interval);
+			return (!!document.body.prototype);
+		}
+		return false;
+	}
+	if (!bodyCheck()) {
+		document.onreadystatechange = bodyCheck;
+		interval = setInterval(bodyCheck, 25);
+	}
+
+	// Apply to any new elements created after load
+	document.createElement = function createElement(nodeName) {
+		var element = nativeCreateElement(String(nodeName).toLowerCase());
+		return shiv(element);
+	};
+
+	// remove sandboxed iframe
+	document.removeChild(vbody);
+}());
+
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Object/defineProperty/detect.js
+var detect = (
+  // In IE8, defineProperty could only act on DOM elements, so full support
+  // for the feature requires the ability to set a property on an arbitrary object
+  'defineProperty' in Object && (function() {
+  	try {
+  		var a = {};
+  		Object.defineProperty(a, 'test', {value:42});
+  		return true;
+  	} catch(e) {
+  		return false
+  	}
+  }())
+);
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Object.defineProperty&flags=always
+(function (nativeDefineProperty) {
+
+	var supportsAccessors = Object.prototype.hasOwnProperty('__defineGetter__');
+	var ERR_ACCESSORS_NOT_SUPPORTED = 'Getters & setters cannot be defined on this javascript engine';
+	var ERR_VALUE_ACCESSORS = 'A property cannot both have accessors and be writable or have a value';
+
+	Object.defineProperty = function defineProperty(object, property, descriptor) {
+
+		// Where native support exists, assume it
+		if (nativeDefineProperty && (object === window || object === document || object === Element.prototype || object instanceof Element)) {
+			return nativeDefineProperty(object, property, descriptor);
+		}
+
+		if (object === null || !(object instanceof Object || typeof object === 'object')) {
+			throw new TypeError('Object.defineProperty called on non-object');
+		}
+
+		if (!(descriptor instanceof Object)) {
+			throw new TypeError('Property description must be an object');
+		}
+
+		var propertyString = String(property);
+		var hasValueOrWritable = 'value' in descriptor || 'writable' in descriptor;
+		var getterType = 'get' in descriptor && typeof descriptor.get;
+		var setterType = 'set' in descriptor && typeof descriptor.set;
+
+		// handle descriptor.get
+		if (getterType) {
+			if (getterType !== 'function') {
+				throw new TypeError('Getter must be a function');
+			}
+			if (!supportsAccessors) {
+				throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
+			}
+			if (hasValueOrWritable) {
+				throw new TypeError(ERR_VALUE_ACCESSORS);
+			}
+			Object.__defineGetter__.call(object, propertyString, descriptor.get);
+		} else {
+			object[propertyString] = descriptor.value;
+		}
+
+		// handle descriptor.set
+		if (setterType) {
+			if (setterType !== 'function') {
+				throw new TypeError('Setter must be a function');
+			}
+			if (!supportsAccessors) {
+				throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
+			}
+			if (hasValueOrWritable) {
+				throw new TypeError(ERR_VALUE_ACCESSORS);
+			}
+			Object.__defineSetter__.call(object, propertyString, descriptor.set);
+		}
+
+		// OK to define value unconditionally - if a getter has been specified as well, an error would be thrown above
+		if ('value' in descriptor) {
+			object[propertyString] = descriptor.value;
+		}
+
+		return object;
+	};
+}(Object.defineProperty));
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+(function(undefined) {
+
+// Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Event/detect.js
+var detect = (
+  (function(global) {
+
+  	if (!('Event' in global)) return false;
+  	if (typeof global.Event === 'function') return true;
+
+  	try {
+
+  		// In IE 9-11, the Event object exists but cannot be instantiated
+  		new Event('click');
+  		return true;
+  	} catch(e) {
+  		return false;
+  	}
+  }(this))
+);
+
+if (detect) return
+
+// Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Event&flags=always
+(function () {
+	var unlistenableWindowEvents = {
+		click: 1,
+		dblclick: 1,
+		keyup: 1,
+		keypress: 1,
+		keydown: 1,
+		mousedown: 1,
+		mouseup: 1,
+		mousemove: 1,
+		mouseover: 1,
+		mouseenter: 1,
+		mouseleave: 1,
+		mouseout: 1,
+		storage: 1,
+		storagecommit: 1,
+		textinput: 1
+	};
+
+	// This polyfill depends on availability of `document` so will not run in a worker
+	// However, we asssume there are no browsers with worker support that lack proper
+	// support for `Event` within the worker
+	if (typeof document === 'undefined' || typeof window === 'undefined') return;
+
+	function indexOf(array, element) {
+		var
+		index = -1,
+		length = array.length;
+
+		while (++index < length) {
+			if (index in array && array[index] === element) {
+				return index;
+			}
+		}
+
+		return -1;
+	}
+
+	var existingProto = (window.Event && window.Event.prototype) || null;
+	window.Event = Window.prototype.Event = function Event(type, eventInitDict) {
+		if (!type) {
+			throw new Error('Not enough arguments');
+		}
+
+		var event;
+		// Shortcut if browser supports createEvent
+		if ('createEvent' in document) {
+			event = document.createEvent('Event');
+			var bubbles = eventInitDict && eventInitDict.bubbles !== undefined ? eventInitDict.bubbles : false;
+			var cancelable = eventInitDict && eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
+
+			event.initEvent(type, bubbles, cancelable);
+
+			return event;
+		}
+
+		event = document.createEventObject();
+
+		event.type = type;
+		event.bubbles = eventInitDict && eventInitDict.bubbles !== undefined ? eventInitDict.bubbles : false;
+		event.cancelable = eventInitDict && eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
+
+		return event;
+	};
+	if (existingProto) {
+		Object.defineProperty(window.Event, 'prototype', {
+			configurable: false,
+			enumerable: false,
+			writable: true,
+			value: existingProto
+		});
+	}
+
+	if (!('createEvent' in document)) {
+		window.addEventListener = Window.prototype.addEventListener = Document.prototype.addEventListener = Element.prototype.addEventListener = function addEventListener() {
+			var
+			element = this,
+			type = arguments[0],
+			listener = arguments[1];
+
+			if (element === window && type in unlistenableWindowEvents) {
+				throw new Error('In IE8 the event: ' + type + ' is not available on the window object. Please see https://github.com/Financial-Times/polyfill-service/issues/317 for more information.');
+			}
+
+			if (!element._events) {
+				element._events = {};
+			}
+
+			if (!element._events[type]) {
+				element._events[type] = function (event) {
+					var
+					list = element._events[event.type].list,
+					events = list.slice(),
+					index = -1,
+					length = events.length,
+					eventElement;
+
+					event.preventDefault = function preventDefault() {
+						if (event.cancelable !== false) {
+							event.returnValue = false;
+						}
+					};
+
+					event.stopPropagation = function stopPropagation() {
+						event.cancelBubble = true;
+					};
+
+					event.stopImmediatePropagation = function stopImmediatePropagation() {
+						event.cancelBubble = true;
+						event.cancelImmediate = true;
+					};
+
+					event.currentTarget = element;
+					event.relatedTarget = event.fromElement || null;
+					event.target = event.target || event.srcElement || element;
+					event.timeStamp = new Date().getTime();
+
+					if (event.clientX) {
+						event.pageX = event.clientX + document.documentElement.scrollLeft;
+						event.pageY = event.clientY + document.documentElement.scrollTop;
+					}
+
+					while (++index < length && !event.cancelImmediate) {
+						if (index in events) {
+							eventElement = events[index];
+
+							if (indexOf(list, eventElement) !== -1 && typeof eventElement === 'function') {
+								eventElement.call(element, event);
+							}
+						}
+					}
+				};
+
+				element._events[type].list = [];
+
+				if (element.attachEvent) {
+					element.attachEvent('on' + type, element._events[type]);
+				}
+			}
+
+			element._events[type].list.push(listener);
+		};
+
+		window.removeEventListener = Window.prototype.removeEventListener = Document.prototype.removeEventListener = Element.prototype.removeEventListener = function removeEventListener() {
+			var
+			element = this,
+			type = arguments[0],
+			listener = arguments[1],
+			index;
+
+			if (element._events && element._events[type] && element._events[type].list) {
+				index = indexOf(element._events[type].list, listener);
+
+				if (index !== -1) {
+					element._events[type].list.splice(index, 1);
+
+					if (!element._events[type].list.length) {
+						if (element.detachEvent) {
+							element.detachEvent('on' + type, element._events[type]);
+						}
+						delete element._events[type];
+					}
+				}
+			}
+		};
+
+		window.dispatchEvent = Window.prototype.dispatchEvent = Document.prototype.dispatchEvent = Element.prototype.dispatchEvent = function dispatchEvent(event) {
+			if (!arguments.length) {
+				throw new Error('Not enough arguments');
+			}
+
+			if (!event || typeof event.type !== 'string') {
+				throw new Error('DOM Events Exception 0');
+			}
+
+			var element = this, type = event.type;
+
+			try {
+				if (!event.bubbles) {
+					event.cancelBubble = true;
+
+					var cancelBubbleEvent = function (event) {
+						event.cancelBubble = true;
+
+						(element || window).detachEvent('on' + type, cancelBubbleEvent);
+					};
+
+					this.attachEvent('on' + type, cancelBubbleEvent);
+				}
+
+				this.fireEvent('on' + type, event);
+			} catch (error) {
+				event.target = element;
+
+				do {
+					event.currentTarget = element;
+
+					if ('_events' in element && typeof element._events[type] === 'function') {
+						element._events[type].call(element, event);
+					}
+
+					if (typeof element['on' + type] === 'function') {
+						element['on' + type].call(element, event);
+					}
+
+					element = element.nodeType === 9 ? element.parentWindow : element.parentNode;
+				} while (element && !event.cancelBubble);
+			}
+
+			return true;
+		};
+
+		// Add the DOMContentLoaded Event
+		document.attachEvent('onreadystatechange', function() {
+			if (document.readyState === 'complete') {
+				document.dispatchEvent(new Event('DOMContentLoaded', {
+					bubbles: true
+				}));
+			}
+		});
+	}
+}());
+
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+/**
+ * JavaScript 'shim' to trigger the click event of element(s) when the space key is pressed.
+ *
+ * Created since some Assistive Technologies (for example some Screenreaders)
+ * will tell a user to press space on a 'button', so this functionality needs to be shimmed
+ * See https://github.com/alphagov/govuk_elements/pull/272#issuecomment-233028270
+ *
+ * Usage instructions:
+ * the 'shim' will be automatically initialised
+ */
+
+var KEY_SPACE = 32;
+
+function Button ($module) {
+  this.$module = $module;
+}
+
+/**
+* Add event handler for KeyDown
+* if the event target element has a role='button' and the event is key space pressed
+* then it prevents the default event and triggers a click event
+* @param {object} event event
+*/
+Button.prototype.handleKeyDown = function (event) {
+  // get the target element
+  var target = event.target;
+  // if the element has a role='button' and the pressed key is a space, we'll simulate a click
+  if (target.getAttribute('role') === 'button' && event.keyCode === KEY_SPACE) {
+    event.preventDefault();
+    // trigger the target's click event
+    target.click();
+  }
+};
+
+/**
+* Initialise an event listener for keydown at document level
+* this will help listening for later inserted elements with a role="button"
+*/
+Button.prototype.init = function () {
+  this.$module.addEventListener('keydown', this.handleKeyDown);
+};
+
+(function(undefined) {
+  // Detection from https://github.com/Financial-Times/polyfill-service/blob/master/packages/polyfill-library/polyfills/Function/prototype/bind/detect.js
+  var detect = 'bind' in Function.prototype;
+
+  if (detect) return
+
+  // Polyfill from https://cdn.polyfill.io/v2/polyfill.js?features=Function.prototype.bind&flags=always
+  Object.defineProperty(Function.prototype, 'bind', {
+      value: function bind(that) { // .length is 1
+          // add necessary es5-shim utilities
+          var $Array = Array;
+          var $Object = Object;
+          var ObjectPrototype = $Object.prototype;
+          var ArrayPrototype = $Array.prototype;
+          var Empty = function Empty() {};
+          var to_string = ObjectPrototype.toString;
+          var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
+          var isCallable; /* inlined from https://npmjs.com/is-callable */ var fnToStr = Function.prototype.toString, tryFunctionObject = function tryFunctionObject(value) { try { fnToStr.call(value); return true; } catch (e) { return false; } }, fnClass = '[object Function]', genClass = '[object GeneratorFunction]'; isCallable = function isCallable(value) { if (typeof value !== 'function') { return false; } if (hasToStringTag) { return tryFunctionObject(value); } var strClass = to_string.call(value); return strClass === fnClass || strClass === genClass; };
+          var array_slice = ArrayPrototype.slice;
+          var array_concat = ArrayPrototype.concat;
+          var array_push = ArrayPrototype.push;
+          var max = Math.max;
+          // /add necessary es5-shim utilities
+
+          // 1. Let Target be the this value.
+          var target = this;
+          // 2. If IsCallable(Target) is false, throw a TypeError exception.
+          if (!isCallable(target)) {
+              throw new TypeError('Function.prototype.bind called on incompatible ' + target);
+          }
+          // 3. Let A be a new (possibly empty) internal list of all of the
+          //   argument values provided after thisArg (arg1, arg2 etc), in order.
+          // XXX slicedArgs will stand in for "A" if used
+          var args = array_slice.call(arguments, 1); // for normal call
+          // 4. Let F be a new native ECMAScript object.
+          // 11. Set the [[Prototype]] internal property of F to the standard
+          //   built-in Function prototype object as specified in 15.3.3.1.
+          // 12. Set the [[Call]] internal property of F as described in
+          //   15.3.4.5.1.
+          // 13. Set the [[Construct]] internal property of F as described in
+          //   15.3.4.5.2.
+          // 14. Set the [[HasInstance]] internal property of F as described in
+          //   15.3.4.5.3.
+          var bound;
+          var binder = function () {
+
+              if (this instanceof bound) {
+                  // 15.3.4.5.2 [[Construct]]
+                  // When the [[Construct]] internal method of a function object,
+                  // F that was created using the bind function is called with a
+                  // list of arguments ExtraArgs, the following steps are taken:
+                  // 1. Let target be the value of F's [[TargetFunction]]
+                  //   internal property.
+                  // 2. If target has no [[Construct]] internal method, a
+                  //   TypeError exception is thrown.
+                  // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
+                  //   property.
+                  // 4. Let args be a new list containing the same values as the
+                  //   list boundArgs in the same order followed by the same
+                  //   values as the list ExtraArgs in the same order.
+                  // 5. Return the result of calling the [[Construct]] internal
+                  //   method of target providing args as the arguments.
+
+                  var result = target.apply(
+                      this,
+                      array_concat.call(args, array_slice.call(arguments))
+                  );
+                  if ($Object(result) === result) {
+                      return result;
+                  }
+                  return this;
+
+              } else {
+                  // 15.3.4.5.1 [[Call]]
+                  // When the [[Call]] internal method of a function object, F,
+                  // which was created using the bind function is called with a
+                  // this value and a list of arguments ExtraArgs, the following
+                  // steps are taken:
+                  // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
+                  //   property.
+                  // 2. Let boundThis be the value of F's [[BoundThis]] internal
+                  //   property.
+                  // 3. Let target be the value of F's [[TargetFunction]] internal
+                  //   property.
+                  // 4. Let args be a new list containing the same values as the
+                  //   list boundArgs in the same order followed by the same
+                  //   values as the list ExtraArgs in the same order.
+                  // 5. Return the result of calling the [[Call]] internal method
+                  //   of target providing boundThis as the this value and
+                  //   providing args as the arguments.
+
+                  // equiv: target.call(this, ...boundArgs, ...args)
+                  return target.apply(
+                      that,
+                      array_concat.call(args, array_slice.call(arguments))
+                  );
+
+              }
+
+          };
+
+          // 15. If the [[Class]] internal property of Target is "Function", then
+          //     a. Let L be the length property of Target minus the length of A.
+          //     b. Set the length own property of F to either 0 or L, whichever is
+          //       larger.
+          // 16. Else set the length own property of F to 0.
+
+          var boundLength = max(0, target.length - args.length);
+
+          // 17. Set the attributes of the length own property of F to the values
+          //   specified in 15.3.5.1.
+          var boundArgs = [];
+          for (var i = 0; i < boundLength; i++) {
+              array_push.call(boundArgs, '$' + i);
+          }
+
+          // XXX Build a dynamic function with desired amount of arguments is the only
+          // way to set the length property of a function.
+          // In environments where Content Security Policies enabled (Chrome extensions,
+          // for ex.) all use of eval or Function costructor throws an exception.
+          // However in all of these environments Function.prototype.bind exists
+          // and so this code will never be executed.
+          bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
+
+          if (target.prototype) {
+              Empty.prototype = target.prototype;
+              bound.prototype = new Empty();
+              // Clean up dangling references.
+              Empty.prototype = null;
+          }
+
+          // TODO
+          // 18. Set the [[Extensible]] internal property of F to true.
+
+          // TODO
+          // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
+          // 20. Call the [[DefineOwnProperty]] internal method of F with
+          //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
+          //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
+          //   false.
+          // 21. Call the [[DefineOwnProperty]] internal method of F with
+          //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
+          //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
+          //   and false.
+
+          // TODO
+          // NOTE Function objects created using Function.prototype.bind do not
+          // have a prototype property or the [[Code]], [[FormalParameters]], and
+          // [[Scope]] internal properties.
+          // XXX can't delete prototype in pure-js.
+
+          // 22. Return F.
+          return bound;
+      }
+  });
+})
+.call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+/**
+ * JavaScript 'polyfill' for HTML5's <details> and <summary> elements
+ * and 'shim' to add accessiblity enhancements for all browsers
+ *
+ * http://caniuse.com/#feat=details
+ *
+ * Usage instructions:
+ * the 'polyfill' will be automatically initialised
+ */
+
+var KEY_ENTER = 13;
+var KEY_SPACE$1 = 32;
+
+// Create a flag to know if the browser supports navtive details
+var NATIVE_DETAILS = typeof document.createElement('details').open === 'boolean';
+
+function Details ($module) {
+  this.$module = $module;
+}
+
+/**
+* Handle cross-modal click events
+* @param {object} node element
+* @param {function} callback function
+*/
+Details.prototype.handleInputs = function (node, callback) {
+  node.addEventListener('keypress', function (event) {
+    var target = event.target;
+    // When the key gets pressed - check if it is enter or space
+    if (event.keyCode === KEY_ENTER || event.keyCode === KEY_SPACE$1) {
+      if (target.nodeName.toLowerCase() === 'summary') {
+        // Prevent space from scrolling the page
+        // and enter from submitting a form
+        event.preventDefault();
+        // Click to let the click event do all the necessary action
+        if (target.click) {
+          target.click();
+        } else {
+          // except Safari 5.1 and under don't support .click() here
+          callback(event);
+        }
+      }
+    }
+  });
+
+  // Prevent keyup to prevent clicking twice in Firefox when using space key
+  node.addEventListener('keyup', function (event) {
+    var target = event.target;
+    if (event.keyCode === KEY_SPACE$1) {
+      if (target.nodeName.toLowerCase() === 'summary') {
+        event.preventDefault();
+      }
+    }
+  });
+
+  node.addEventListener('click', callback);
+};
+
+Details.prototype.init = function () {
+  var $module = this.$module;
+
+  if (!$module) {
+    return
+  }
+
+  // Save shortcuts to the inner summary and content elements
+  var $summary = this.$summary = $module.getElementsByTagName('summary').item(0);
+  var $content = this.$content = $module.getElementsByTagName('div').item(0);
+
+  // If <details> doesn't have a <summary> and a <div> representing the content
+  // it means the required HTML structure is not met so the script will stop
+  if (!$summary || !$content) {
+    return
+  }
+
+  // If the content doesn't have an ID, assign it one now
+  // which we'll need for the summary's aria-controls assignment
+  if (!$content.id) {
+    $content.id = 'details-content-' + generateUniqueID();
+  }
+
+  // Add ARIA role="group" to details
+  $module.setAttribute('role', 'group');
+
+  // Add role=button to summary
+  $summary.setAttribute('role', 'button');
+
+  // Add aria-controls
+  $summary.setAttribute('aria-controls', $content.id);
+
+  // Set tabIndex so the summary is keyboard accessible for non-native elements
+  // http://www.saliences.com/browserBugs/tabIndex.html
+  if (!NATIVE_DETAILS) {
+    $summary.tabIndex = 0;
+  }
+
+  // Detect initial open state
+  var openAttr = $module.getAttribute('open') !== null;
+  if (openAttr === true) {
+    $summary.setAttribute('aria-expanded', 'true');
+    $content.setAttribute('aria-hidden', 'false');
+  } else {
+    $summary.setAttribute('aria-expanded', 'false');
+    $content.setAttribute('aria-hidden', 'true');
+    if (!NATIVE_DETAILS) {
+      $content.style.display = 'none';
+    }
+  }
+
+  // Bind an event to handle summary elements
+  this.handleInputs($module, this.setAttributes.bind(this));
+};
+
+/**
+* Define a statechange function that updates aria-expanded and style.display
+* @param {object} summary element
+*/
+Details.prototype.setAttributes = function () {
+  var $module = this.$module;
+  var $summary = this.$summary;
+  var $content = this.$content;
+
+  var expanded = $summary.getAttribute('aria-expanded') === 'true';
+  var hidden = $content.getAttribute('aria-hidden') === 'true';
+
+  $summary.setAttribute('aria-expanded', (expanded ? 'false' : 'true'));
+  $content.setAttribute('aria-hidden', (hidden ? 'false' : 'true'));
+
+  if (!NATIVE_DETAILS) {
+    $content.style.display = (expanded ? 'none' : '');
+
+    var hasOpenAttr = $module.getAttribute('open') !== null;
+    if (!hasOpenAttr) {
+      $module.setAttribute('open', 'open');
+    } else {
+      $module.removeAttribute('open');
+    }
+  }
+  return true
+};
+
+/**
+* Remove the click event from the node element
+* @param {object} node element
+*/
+Details.prototype.destroy = function (node) {
+  node.removeEventListener('keypress');
+  node.removeEventListener('keyup');
+  node.removeEventListener('click');
+};
+
+function Checkboxes ($module) {
+  this.$module = $module;
+  this.$inputs = $module.querySelectorAll('input[type="checkbox"]');
+}
+
+Checkboxes.prototype.init = function () {
+  var $module = this.$module;
+  var $inputs = this.$inputs;
+
+  /**
+  * Loop over all items with [data-controls]
+  * Check if they have a matching conditional reveal
+  * If they do, assign attributes.
+  **/
+  nodeListForEach($inputs, function ($input) {
+    var controls = $input.getAttribute('data-aria-controls');
+
+    // Check if input controls anything
+    // Check if content exists, before setting attributes.
+    if (!controls || !$module.querySelector('#' + controls)) {
+      return
+    }
+
+    // If we have content that is controlled, set attributes.
+    $input.setAttribute('aria-controls', controls);
+    $input.removeAttribute('data-aria-controls');
+    this.setAttributes($input);
+  }.bind(this));
+
+  // Handle events
+  $module.addEventListener('click', this.handleClick.bind(this));
+};
+
+Checkboxes.prototype.setAttributes = function ($input) {
+  var inputIsChecked = $input.checked;
+  $input.setAttribute('aria-expanded', inputIsChecked);
+
+  var $content = document.querySelector('#' + $input.getAttribute('aria-controls'));
+  $content.setAttribute('aria-hidden', !inputIsChecked);
+};
+
+Checkboxes.prototype.handleClick = function (event) {
+  var $target = event.target;
+
+  // If a checkbox with aria-controls, handle click
+  var isCheckbox = $target.getAttribute('type') === 'checkbox';
+  var hasAriaControls = $target.getAttribute('aria-controls');
+  if (isCheckbox && hasAriaControls) {
+    this.setAttributes($target);
+  }
+};
+
+function ErrorSummary ($module) {
+  this.$module = $module;
+}
+
+ErrorSummary.prototype.init = function () {
+  var $module = this.$module;
+  if (!$module) {
+    return
+  }
+  window.addEventListener('load', function () {
+    $module.focus();
+  });
+};
+
+function Header ($module) {
+  this.$module = $module;
+}
+
+Header.prototype.init = function () {
+  // Check for module
+  var $module = this.$module;
+  if (!$module) {
+    return
+  }
+
+  // Check for button
+  var $toggleButton = $module.querySelector('.js-header-toggle');
+  if (!$toggleButton) {
+    return
+  }
+
+  // Handle $toggleButton click events
+  $toggleButton.addEventListener('click', this.handleClick.bind(this));
+};
+
+/**
+* Toggle class
+* @param {object} node element
+* @param {string} className to toggle
+*/
+Header.prototype.toggleClass = function (node, className) {
+  if (node.className.indexOf(className) > 0) {
+    node.className = node.className.replace(' ' + className, '');
+  } else {
+    node.className += ' ' + className;
+  }
+};
+
+/**
+* An event handler for click event on $toggleButton
+* @param {object} event event
+*/
+Header.prototype.handleClick = function (event) {
+  var $module = this.$module;
+  var $toggleButton = event.target || event.srcElement;
+  var $target = $module.querySelector('#' + $toggleButton.getAttribute('aria-controls'));
+
+  // If a button with aria-controls, handle click
+  if ($toggleButton && $target) {
+    this.toggleClass($target, 'govuk-header__navigation--open');
+    this.toggleClass($toggleButton, 'govuk-header__menu-button--open');
+
+    $toggleButton.setAttribute('aria-expanded', $toggleButton.getAttribute('aria-expanded') !== 'true');
+    $target.setAttribute('aria-hidden', $target.getAttribute('aria-hidden') === 'false');
+  }
+};
+
+function Radios ($module) {
+  this.$module = $module;
+  this.$inputs = $module.querySelectorAll('input[type="radio"]');
+}
+
+Radios.prototype.init = function () {
+  var $module = this.$module;
+  var $inputs = this.$inputs;
+
+  /**
+  * Loop over all items with [data-controls]
+  * Check if they have a matching conditional reveal
+  * If they do, assign attributes.
+  **/
+  nodeListForEach($inputs, function ($input) {
+    var controls = $input.getAttribute('data-aria-controls');
+
+    // Check if input controls anything
+    // Check if content exists, before setting attributes.
+    if (!controls || !$module.querySelector('#' + controls)) {
+      return
+    }
+
+    // If we have content that is controlled, set attributes.
+    $input.setAttribute('aria-controls', controls);
+    $input.removeAttribute('data-aria-controls');
+    this.setAttributes($input);
+  }.bind(this));
+
+  // Handle events
+  $module.addEventListener('click', this.handleClick.bind(this));
+};
+
+Radios.prototype.setAttributes = function ($input) {
+  var inputIsChecked = $input.checked;
+  $input.setAttribute('aria-expanded', inputIsChecked);
+
+  var $content = document.querySelector('#' + $input.getAttribute('aria-controls'));
+  $content.setAttribute('aria-hidden', !inputIsChecked);
+};
+
+Radios.prototype.handleClick = function (event) {
+  nodeListForEach(this.$inputs, function ($input) {
+    // If a radio with aria-controls, handle click
+    var isRadio = $input.getAttribute('type') === 'radio';
+    var hasAriaControls = $input.getAttribute('aria-controls');
+    if (isRadio && hasAriaControls) {
+      this.setAttributes($input);
+    }
+  }.bind(this));
+};
+
+(function(undefined) {
+
+    // Detection from https://raw.githubusercontent.com/Financial-Times/polyfill-service/master/packages/polyfill-library/polyfills/DOMTokenList/detect.js
+    var detect = (
+      'DOMTokenList' in this && (function (x) {
+        return 'classList' in x ? !x.classList.toggle('x', false) && !x.className : true;
+      })(document.createElement('x'))
+    );
+
+    if (detect) return
+
+    // Polyfill from https://raw.githubusercontent.com/Financial-Times/polyfill-service/master/packages/polyfill-library/polyfills/DOMTokenList/polyfill.js
+    (function (global) {
+      var nativeImpl = "DOMTokenList" in global && global.DOMTokenList;
+
+      if (
+          !nativeImpl ||
+          (
+            !!document.createElementNS &&
+            !!document.createElementNS('http://www.w3.org/2000/svg', 'svg') &&
+            !(document.createElementNS("http://www.w3.org/2000/svg", "svg").classList instanceof DOMTokenList)
+          )
+        ) {
+        global.DOMTokenList = (function() { // eslint-disable-line no-unused-vars
+          var dpSupport = true;
+          var defineGetter = function (object, name, fn, configurable) {
+            if (Object.defineProperty)
+              Object.defineProperty(object, name, {
+                configurable: false === dpSupport ? true : !!configurable,
+                get: fn
+              });
+
+            else object.__defineGetter__(name, fn);
+          };
+
+          /** Ensure the browser allows Object.defineProperty to be used on native JavaScript objects. */
+          try {
+            defineGetter({}, "support");
+          }
+          catch (e) {
+            dpSupport = false;
+          }
+
+
+          var _DOMTokenList = function (el, prop) {
+            var that = this;
+            var tokens = [];
+            var tokenMap = {};
+            var length = 0;
+            var maxLength = 0;
+            var addIndexGetter = function (i) {
+              defineGetter(that, i, function () {
+                preop();
+                return tokens[i];
+              }, false);
+
+            };
+            var reindex = function () {
+
+              /** Define getter functions for array-like access to the tokenList's contents. */
+              if (length >= maxLength)
+                for (; maxLength < length; ++maxLength) {
+                  addIndexGetter(maxLength);
+                }
+            };
+
+            /** Helper function called at the start of each class method. Internal use only. */
+            var preop = function () {
+              var error;
+              var i;
+              var args = arguments;
+              var rSpace = /\s+/;
+
+              /** Validate the token/s passed to an instance method, if any. */
+              if (args.length)
+                for (i = 0; i < args.length; ++i)
+                  if (rSpace.test(args[i])) {
+                    error = new SyntaxError('String "' + args[i] + '" ' + "contains" + ' an invalid character');
+                    error.code = 5;
+                    error.name = "InvalidCharacterError";
+                    throw error;
+                  }
+
+
+              /** Split the new value apart by whitespace*/
+              if (typeof el[prop] === "object") {
+                tokens = ("" + el[prop].baseVal).replace(/^\s+|\s+$/g, "").split(rSpace);
+              } else {
+                tokens = ("" + el[prop]).replace(/^\s+|\s+$/g, "").split(rSpace);
+              }
+
+              /** Avoid treating blank strings as single-item token lists */
+              if ("" === tokens[0]) tokens = [];
+
+              /** Repopulate the internal token lists */
+              tokenMap = {};
+              for (i = 0; i < tokens.length; ++i)
+                tokenMap[tokens[i]] = true;
+              length = tokens.length;
+              reindex();
+            };
+
+            /** Populate our internal token list if the targeted attribute of the subject element isn't empty. */
+            preop();
+
+            /** Return the number of tokens in the underlying string. Read-only. */
+            defineGetter(that, "length", function () {
+              preop();
+              return length;
+            });
+
+            /** Override the default toString/toLocaleString methods to return a space-delimited list of tokens when typecast. */
+            that.toLocaleString =
+              that.toString = function () {
+                preop();
+                return tokens.join(" ");
+              };
+
+            that.item = function (idx) {
+              preop();
+              return tokens[idx];
+            };
+
+            that.contains = function (token) {
+              preop();
+              return !!tokenMap[token];
+            };
+
+            that.add = function () {
+              preop.apply(that, args = arguments);
+
+              for (var args, token, i = 0, l = args.length; i < l; ++i) {
+                token = args[i];
+                if (!tokenMap[token]) {
+                  tokens.push(token);
+                  tokenMap[token] = true;
+                }
+              }
+
+              /** Update the targeted attribute of the attached element if the token list's changed. */
+              if (length !== tokens.length) {
+                length = tokens.length >>> 0;
+                if (typeof el[prop] === "object") {
+                  el[prop].baseVal = tokens.join(" ");
+                } else {
+                  el[prop] = tokens.join(" ");
+                }
+                reindex();
+              }
+            };
+
+            that.remove = function () {
+              preop.apply(that, args = arguments);
+
+              /** Build a hash of token names to compare against when recollecting our token list. */
+              for (var args, ignore = {}, i = 0, t = []; i < args.length; ++i) {
+                ignore[args[i]] = true;
+                delete tokenMap[args[i]];
+              }
+
+              /** Run through our tokens list and reassign only those that aren't defined in the hash declared above. */
+              for (i = 0; i < tokens.length; ++i)
+                if (!ignore[tokens[i]]) t.push(tokens[i]);
+
+              tokens = t;
+              length = t.length >>> 0;
+
+              /** Update the targeted attribute of the attached element. */
+              if (typeof el[prop] === "object") {
+                el[prop].baseVal = tokens.join(" ");
+              } else {
+                el[prop] = tokens.join(" ");
+              }
+              reindex();
+            };
+
+            that.toggle = function (token, force) {
+              preop.apply(that, [token]);
+
+              /** Token state's being forced. */
+              if (undefined !== force) {
+                if (force) {
+                  that.add(token);
+                  return true;
+                } else {
+                  that.remove(token);
+                  return false;
+                }
+              }
+
+              /** Token already exists in tokenList. Remove it, and return FALSE. */
+              if (tokenMap[token]) {
+                that.remove(token);
+                return false;
+              }
+
+              /** Otherwise, add the token and return TRUE. */
+              that.add(token);
+              return true;
+            };
+
+            return that;
+          };
+
+          return _DOMTokenList;
+        }());
+      }
+
+      // Add second argument to native DOMTokenList.toggle() if necessary
+      (function () {
+        var e = document.createElement('span');
+        if (!('classList' in e)) return;
+        e.classList.toggle('x', false);
+        if (!e.classList.contains('x')) return;
+        e.classList.constructor.prototype.toggle = function toggle(token /*, force*/) {
+          var force = arguments[1];
+          if (force === undefined) {
+            var add = !this.contains(token);
+            this[add ? 'add' : 'remove'](token);
+            return add;
+          }
+          force = !!force;
+          this[force ? 'add' : 'remove'](token);
+          return force;
+        };
+      }());
+
+      // Add multiple arguments to native DOMTokenList.add() if necessary
+      (function () {
+        var e = document.createElement('span');
+        if (!('classList' in e)) return;
+        e.classList.add('a', 'b');
+        if (e.classList.contains('b')) return;
+        var native = e.classList.constructor.prototype.add;
+        e.classList.constructor.prototype.add = function () {
+          var args = arguments;
+          var l = arguments.length;
+          for (var i = 0; i < l; i++) {
+            native.call(this, args[i]);
+          }
+        };
+      }());
+
+      // Add multiple arguments to native DOMTokenList.remove() if necessary
+      (function () {
+        var e = document.createElement('span');
+        if (!('classList' in e)) return;
+        e.classList.add('a');
+        e.classList.add('b');
+        e.classList.remove('a', 'b');
+        if (!e.classList.contains('b')) return;
+        var native = e.classList.constructor.prototype.remove;
+        e.classList.constructor.prototype.remove = function () {
+          var args = arguments;
+          var l = arguments.length;
+          for (var i = 0; i < l; i++) {
+            native.call(this, args[i]);
+          }
+        };
+      }());
+
+    }(this));
+
+}).call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+(function(undefined) {
+
+    // Detection from https://raw.githubusercontent.com/Financial-Times/polyfill-service/8717a9e04ac7aff99b4980fbedead98036b0929a/packages/polyfill-library/polyfills/Element/prototype/classList/detect.js
+    var detect = (
+      'document' in this && "classList" in document.documentElement && 'Element' in this && 'classList' in Element.prototype && (function () {
+        var e = document.createElement('span');
+        e.classList.add('a', 'b');
+        return e.classList.contains('b');
+      }())
+    );
+
+    if (detect) return
+
+    // Polyfill from https://raw.githubusercontent.com/Financial-Times/polyfill-service/8717a9e04ac7aff99b4980fbedead98036b0929a/packages/polyfill-library/polyfills/Element/prototype/classList/polyfill.js
+    (function (global) {
+      var dpSupport = true;
+      var defineGetter = function (object, name, fn, configurable) {
+        if (Object.defineProperty)
+          Object.defineProperty(object, name, {
+            configurable: false === dpSupport ? true : !!configurable,
+            get: fn
+          });
+
+        else object.__defineGetter__(name, fn);
+      };
+      /** Ensure the browser allows Object.defineProperty to be used on native JavaScript objects. */
+      try {
+        defineGetter({}, "support");
+      }
+      catch (e) {
+        dpSupport = false;
+      }
+      /** Polyfills a property with a DOMTokenList */
+      var addProp = function (o, name, attr) {
+
+        defineGetter(o.prototype, name, function () {
+          var tokenList;
+
+          var THIS = this,
+
+          /** Prevent this from firing twice for some reason. What the hell, IE. */
+          gibberishProperty = "__defineGetter__" + "DEFINE_PROPERTY" + name;
+          if(THIS[gibberishProperty]) return tokenList;
+          THIS[gibberishProperty] = true;
+
+          /**
+           * IE8 can't define properties on native JavaScript objects, so we'll use a dumb hack instead.
+           *
+           * What this is doing is creating a dummy element ("reflection") inside a detached phantom node ("mirror")
+           * that serves as the target of Object.defineProperty instead. While we could simply use the subject HTML
+           * element instead, this would conflict with element types which use indexed properties (such as forms and
+           * select lists).
+           */
+          if (false === dpSupport) {
+
+            var visage;
+            var mirror = addProp.mirror || document.createElement("div");
+            var reflections = mirror.childNodes;
+            var l = reflections.length;
+
+            for (var i = 0; i < l; ++i)
+              if (reflections[i]._R === THIS) {
+                visage = reflections[i];
+                break;
+              }
+
+            /** Couldn't find an element's reflection inside the mirror. Materialise one. */
+            visage || (visage = mirror.appendChild(document.createElement("div")));
+
+            tokenList = DOMTokenList.call(visage, THIS, attr);
+          } else tokenList = new DOMTokenList(THIS, attr);
+
+          defineGetter(THIS, name, function () {
+            return tokenList;
+          });
+          delete THIS[gibberishProperty];
+
+          return tokenList;
+        }, true);
+      };
+
+      addProp(global.Element, "classList", "className");
+      addProp(global.HTMLElement, "classList", "className");
+      addProp(global.HTMLLinkElement, "relList", "rel");
+      addProp(global.HTMLAnchorElement, "relList", "rel");
+      addProp(global.HTMLAreaElement, "relList", "rel");
+    }(this));
+
+}).call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});
+
+function Tabs ($module) {
+  this.$module = $module;
+  this.$tabs = $module.querySelectorAll('.govuk-tabs__tab');
+
+  this.keys = { left: 37, right: 39, up: 38, down: 40 };
+  this.jsHiddenClass = 'js-hidden';
+}
+
+Tabs.prototype.init = function () {
+  if (typeof window.matchMedia === 'function') {
+    this.setupResponsiveChecks();
+  } else {
+    this.setup();
+  }
+};
+
+Tabs.prototype.setupResponsiveChecks = function () {
+  this.mql = window.matchMedia('(min-width: 40.0625em)');
+  this.mql.addListener(this.checkMode.bind(this));
+  this.checkMode();
+};
+
+Tabs.prototype.checkMode = function () {
+  if (this.mql.matches) {
+    this.setup();
+  } else {
+    this.teardown();
+  }
+};
+
+Tabs.prototype.setup = function () {
+  var $module = this.$module;
+  var $tabs = this.$tabs;
+  var $tabList = $module.querySelector('.govuk-tabs__list');
+  var $tabListItems = $module.querySelectorAll('.govuk-tabs__list-item');
+
+  if (!$tabs || !$tabList || !$tabListItems) {
+    return
+  }
+
+  $tabList.setAttribute('role', 'tablist');
+
+  nodeListForEach($tabListItems, function ($item) {
+    $item.setAttribute('role', 'presentation');
+  });
+
+  nodeListForEach($tabs, function ($tab) {
+    // Set HTML attributes
+    this.setAttributes($tab);
+
+    // Save bounded functions to use when removing event listeners during teardown
+    $tab.boundTabClick = this.onTabClick.bind(this);
+    $tab.boundTabKeydown = this.onTabKeydown.bind(this);
+
+    // Handle events
+    $tab.addEventListener('click', $tab.boundTabClick, true);
+    $tab.addEventListener('keydown', $tab.boundTabKeydown, true);
+
+    // Remove old active panels
+    this.hideTab($tab);
+  }.bind(this));
+
+  // Show either the active tab according to the URL's hash or the first tab
+  var $activeTab = this.getTab(window.location.hash) || this.$tabs[0];
+  this.showTab($activeTab);
+
+  // Handle hashchange events
+  $module.boundOnHashChange = this.onHashChange.bind(this);
+  window.addEventListener('hashchange', $module.boundOnHashChange, true);
+};
+
+Tabs.prototype.teardown = function () {
+  var $module = this.$module;
+  var $tabs = this.$tabs;
+  var $tabList = $module.querySelector('.govuk-tabs__list');
+  var $tabListItems = $module.querySelectorAll('.govuk-tabs__list-item');
+
+  if (!$tabs || !$tabList || !$tabListItems) {
+    return
+  }
+
+  $tabList.removeAttribute('role');
+
+  nodeListForEach($tabListItems, function ($item) {
+    $item.removeAttribute('role', 'presentation');
+  });
+
+  nodeListForEach($tabs, function ($tab) {
+    // Remove events
+    $tab.removeEventListener('click', $tab.boundTabClick, true);
+    $tab.removeEventListener('keydown', $tab.boundTabKeydown, true);
+
+    // Unset HTML attributes
+    this.unsetAttributes($tab);
+  }.bind(this));
+
+  // Remove hashchange event handler
+  window.removeEventListener('hashchange', $module.boundOnHashChange, true);
+};
+
+Tabs.prototype.onHashChange = function (e) {
+  var hash = window.location.hash;
+  if (!this.hasTab(hash)) {
+    return
+  }
+  // Prevent changing the hash
+  if (this.changingHash) {
+    this.changingHash = false;
+    return
+  }
+
+  // Show either the active tab according to the URL's hash or the first tab
+  var $previousTab = this.getCurrentTab();
+  var $activeTab = this.getTab(hash) || this.$tabs[0];
+
+  this.hideTab($previousTab);
+  this.showTab($activeTab);
+  $activeTab.focus();
+};
+
+Tabs.prototype.hasTab = function (hash) {
+  return this.$module.querySelector(hash)
+};
+
+Tabs.prototype.hideTab = function ($tab) {
+  this.unhighlightTab($tab);
+  this.hidePanel($tab);
+};
+
+Tabs.prototype.showTab = function ($tab) {
+  this.highlightTab($tab);
+  this.showPanel($tab);
+};
+
+Tabs.prototype.getTab = function (hash) {
+  return this.$module.querySelector('a[role="tab"][href="' + hash + '"]')
+};
+
+Tabs.prototype.setAttributes = function ($tab) {
+  // set tab attributes
+  var panelId = this.getHref($tab).slice(1);
+  $tab.setAttribute('id', 'tab_' + panelId);
+  $tab.setAttribute('role', 'tab');
+  $tab.setAttribute('aria-controls', panelId);
+  $tab.setAttribute('tabindex', '-1');
+
+  // set panel attributes
+  var $panel = this.getPanel($tab);
+  $panel.setAttribute('role', 'tabpanel');
+  $panel.setAttribute('aria-labelledby', $tab.id);
+  $panel.classList.add(this.jsHiddenClass);
+};
+
+Tabs.prototype.unsetAttributes = function ($tab) {
+  // unset tab attributes
+  $tab.removeAttribute('id');
+  $tab.removeAttribute('role');
+  $tab.removeAttribute('aria-controls');
+  $tab.removeAttribute('tabindex');
+
+  // unset panel attributes
+  var $panel = this.getPanel($tab);
+  $panel.removeAttribute('role');
+  $panel.removeAttribute('aria-labelledby');
+  $panel.classList.remove(this.jsHiddenClass);
+};
+
+Tabs.prototype.onTabClick = function (e) {
+  e.preventDefault();
+  var $newTab = e.target;
+  var $currentTab = this.getCurrentTab();
+  this.hideTab($currentTab);
+  this.showTab($newTab);
+  this.createHistoryEntry($newTab);
+};
+
+Tabs.prototype.createHistoryEntry = function ($tab) {
+  var $panel = this.getPanel($tab);
+
+  // Save and restore the id
+  // so the page doesn't jump when a user clicks a tab (which changes the hash)
+  var id = $panel.id;
+  $panel.id = '';
+  this.changingHash = true;
+  window.location.hash = this.getHref($tab).slice(1);
+  $panel.id = id;
+};
+
+Tabs.prototype.onTabKeydown = function (e) {
+  switch (e.keyCode) {
+    case this.keys.left:
+    case this.keys.up:
+      this.activatePreviousTab();
+      e.preventDefault();
+      break
+    case this.keys.right:
+    case this.keys.down:
+      this.activateNextTab();
+      e.preventDefault();
+      break
+  }
+};
+
+Tabs.prototype.activateNextTab = function () {
+  var currentTab = this.getCurrentTab();
+  var nextTabListItem = currentTab.parentNode.nextElementSibling;
+  if (nextTabListItem) {
+    var nextTab = nextTabListItem.firstElementChild;
+  }
+  if (nextTab) {
+    this.hideTab(currentTab);
+    this.showTab(nextTab);
+    nextTab.focus();
+    this.createHistoryEntry(nextTab);
+  }
+};
+
+Tabs.prototype.activatePreviousTab = function () {
+  var currentTab = this.getCurrentTab();
+  var previousTabListItem = currentTab.parentNode.previousElementSibling;
+  if (previousTabListItem) {
+    var previousTab = previousTabListItem.firstElementChild;
+  }
+  if (previousTab) {
+    this.hideTab(currentTab);
+    this.showTab(previousTab);
+    previousTab.focus();
+    this.createHistoryEntry(previousTab);
+  }
+};
+
+Tabs.prototype.getPanel = function ($tab) {
+  var $panel = this.$module.querySelector(this.getHref($tab));
+  return $panel
+};
+
+Tabs.prototype.showPanel = function ($tab) {
+  var $panel = this.getPanel($tab);
+  $panel.classList.remove(this.jsHiddenClass);
+};
+
+Tabs.prototype.hidePanel = function (tab) {
+  var $panel = this.getPanel(tab);
+  $panel.classList.add(this.jsHiddenClass);
+};
+
+Tabs.prototype.unhighlightTab = function ($tab) {
+  $tab.setAttribute('aria-selected', 'false');
+  $tab.setAttribute('tabindex', '-1');
+};
+
+Tabs.prototype.highlightTab = function ($tab) {
+  $tab.setAttribute('aria-selected', 'true');
+  $tab.setAttribute('tabindex', '0');
+};
+
+Tabs.prototype.getCurrentTab = function () {
+  return this.$module.querySelector('[role=tab][aria-selected=true]')
+};
+
+// this is because IE doesn't always return the actual value but a relative full path
+// should be a utility function most prob
+// http://labs.thesedays.com/blog/2010/01/08/getting-the-href-value-with-jquery-in-ie/
+Tabs.prototype.getHref = function ($tab) {
+  var href = $tab.getAttribute('href');
+  var hash = href.slice(href.indexOf('#'), href.length);
+  return hash
+};
+
+function initAll () {
+  new Button(document).init();
+
+  var $details = document.querySelectorAll('details');
+  nodeListForEach($details, function ($detail) {
+    new Details($detail).init();
+  });
+
+  var $checkboxes = document.querySelectorAll('[data-module="checkboxes"]');
+  nodeListForEach($checkboxes, function ($checkbox) {
+    new Checkboxes($checkbox).init();
+  });
+
+  // Find first Error Summary module to enhance.
+  var $errorSummary = document.querySelector('[data-module="error-summary"]');
+  new ErrorSummary($errorSummary).init();
+
+  // Find first header module to enhance.
+  var $toggleButton = document.querySelector('[data-module="header"]');
+  new Header($toggleButton).init();
+
+  var $radios = document.querySelectorAll('[data-module="radios"]');
+  nodeListForEach($radios, function ($radio) {
+    new Radios($radio).init();
+  });
+
+  var $tabs = document.querySelectorAll('[data-module="tabs"]');
+  nodeListForEach($tabs, function ($tabs) {
+    new Tabs($tabs).init();
+  });
+}
+
+exports.initAll = initAll;
+exports.Button = Button;
+exports.Details = Details;
+exports.Checkboxes = Checkboxes;
+exports.ErrorSummary = ErrorSummary;
+exports.Header = Header;
+exports.Radios = Radios;
+exports.Tabs = Tabs;
+
+})));