refactor / remove lodash dependency

2 files changed, 0 insertions, 2262 deletions

diff --git a/lib/vendor/lodash.core.min.js b/lib/vendor/lodash.core.min.js
deleted file mode 100644
index 062e55d49..000000000
--- a/lib/vendor/lodash.core.min.js
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * @license
- * lodash 4.0.0 (Custom Build) lodash.com/license | Underscore.js 1.8.3 underscorejs.org/LICENSE
- * Build: `lodash core -o ./dist/lodash.core.js`
- */
-;(function(){function n(n,t){for(var r=-1,e=t.length,u=n.length;++r<e;)n[u+r]=t[r];return n}function t(n,t,r){for(var e=-1,u=n.length;++e<u;){var o=n[e],i=t(o);if(null!=i&&(c===ln?i===i:r(i,c)))var c=i,f=o}return f}function r(n,t,r){var e;return r(n,function(n,r,u){return t(n,r,u)?(e=n,false):void 0}),e}function e(n,t,r,e,u){return u(n,function(n,u,o){r=e?(e=false,n):t(r,n,u,o)}),r}function u(n,t){return w(t,function(t){return n[t]})}function o(n){return n&&n.Object===Object?n:null}function i(n){return vn[n];
-}function c(n){var t=false;if(null!=n&&typeof n.toString!="function")try{t=!!(n+"")}catch(r){}return t}function f(n,t){return n=typeof n=="number"||hn.test(n)?+n:-1,n>-1&&0==n%1&&(null==t?9007199254740991:t)>n}function a(n){if(Z(n)&&!Vn(n)){if(n instanceof l)return n;if(En.call(n,"__wrapped__")){var t=new l(n.__wrapped__,n.__chain__);return t.__actions__=k(n.__actions__),t}}return new l(n)}function l(n,t){this.__wrapped__=n,this.__actions__=[],this.__chain__=!!t}function p(n,t,r,e){return n===ln||H(n,xn[r])&&!En.call(e,r)?t:n;
-}function s(n,t,r){if(typeof n!="function")throw new TypeError("Expected a function");return setTimeout(function(){n.apply(ln,r)},t)}function h(n,t){var r=true;return $n(n,function(n,e,u){return r=!!t(n,e,u)}),r}function v(n,t){var r=[];return $n(n,function(n,e,u){t(n,e,u)&&r.push(n)}),r}function y(t,r,e,u){u||(u=[]);for(var o=-1,i=t.length;++o<i;){var c=t[o];Z(c)&&Q(c)&&(e||Vn(c)||L(c))?r?y(c,r,e,u):n(u,c):e||(u[u.length]=c)}return u}function _(n,t){return n&&qn(n,t,un)}function g(n,t){return v(t,function(t){
-return W(n[t])})}function b(n,t,r,e,u){return n===t?true:null==n||null==t||!Y(n)&&!Z(t)?n!==n&&t!==t:j(n,t,b,r,e,u)}function j(n,t,r,e,u,o){var i=Vn(n),f=Vn(t),a="[object Array]",l="[object Array]";i||(a=kn.call(n),"[object Arguments]"==a&&(a="[object Object]")),f||(l=kn.call(t),"[object Arguments]"==l&&(l="[object Object]"));var p="[object Object]"==a&&!c(n),f="[object Object]"==l&&!c(t);return!(l=a==l)||i||p?2&u||(a=p&&En.call(n,"__wrapped__"),f=f&&En.call(t,"__wrapped__"),!a&&!f)?l?(o||(o=[]),(a=C(o,function(t){
-return t[0]===n}))&&a[1]?a[1]==t:(o.push([n,t]),t=(i?R:$)(n,t,r,e,u,o),o.pop(),t)):false:r(a?n.value():n,f?t.value():t,e,u,o):I(n,t,a)}function d(n){var t=typeof n;return"function"==t?n:null==n?fn:("object"==t?O:E)(n)}function m(n){n=null==n?n:Object(n);var t,r=[];for(t in n)r.push(t);return r}function w(n,t){var r=-1,e=Q(n)?Array(n.length):[];return $n(n,function(n,u,o){e[++r]=t(n,u,o)}),e}function O(n){var t=un(n),r=t.length;return function(e){if(null==e)return!r;for(e=Object(e);r--;){var u=t[r];if(!(u in e&&b(n[u],e[u],ln,true)))return false;
-}return true}}function x(n,t){return n=Object(n),J(t,function(t,r){return r in n&&(t[r]=n[r]),t},{})}function E(n){return function(t){return null==t?ln:t[n]}}function A(n,t,r){var e=-1,u=n.length;for(0>t&&(t=-t>u?0:u+t),r=r>u?u:r,0>r&&(r+=u),u=t>r?0:r-t>>>0,t>>>=0,r=Array(u);++e<u;)r[e]=n[e+t];return r}function k(n){return A(n,0,n.length)}function N(n,t){var r;return $n(n,function(n,e,u){return r=t(n,e,u),!r}),!!r}function S(t,r){return J(r,function(t,r){return r.func.apply(r.thisArg,n([t],r.args))},t);
-}function T(n,t,r,e){r||(r={});for(var u=-1,o=t.length;++u<o;){var i=t[u],c=e?e(r[i],n[i],i,r,n):n[i],f=r,a=f[i];(!H(a,c)||H(a,xn[i])&&!En.call(f,i)||c===ln&&!(i in f))&&(f[i]=c)}return r}function F(n){return V(function(t,r){var e=-1,u=r.length,o=u>1?r[u-1]:ln,o=typeof o=="function"?(u--,o):ln;for(t=Object(t);++e<u;){var i=r[e];i&&n(t,i,o)}return t})}function B(n){return function(){var t=arguments,r=In(n.prototype),t=n.apply(r,t);return Y(t)?t:r}}function D(n,t,r){function e(){for(var o=-1,i=arguments.length,c=-1,f=r.length,a=Array(f+i),l=this&&this!==wn&&this instanceof e?u:n;++c<f;)a[c]=r[c];
-for(;i--;)a[c++]=arguments[++o];return l.apply(t,a)}if(typeof n!="function")throw new TypeError("Expected a function");var u=B(n);return e}function R(n,t,r,e,u,o){var i=-1,c=1&u,f=n.length,a=t.length;if(f!=a&&!(2&u&&a>f))return false;for(a=true;++i<f;){var l=n[i],p=t[i];if(void 0!==ln){a=false;break}if(c){if(!N(t,function(n){return l===n||r(l,n,e,u,o)})){a=false;break}}else if(l!==p&&!r(l,p,e,u,o)){a=false;break}}return a}function I(n,t,r){switch(r){case"[object Boolean]":case"[object Date]":return+n==+t;case"[object Error]":
-return n.name==t.name&&n.message==t.message;case"[object Number]":return n!=+n?t!=+t:n==+t;case"[object RegExp]":case"[object String]":return n==t+""}return false}function $(n,t,r,e,u,o){var i=2&u,c=1&u,f=un(n),a=f.length,l=un(t);if(a!=l.length&&!i)return false;for(var p=a;p--;){var s=f[p];if(!(i?s in t:En.call(t,s))||!c&&s!=l[p])return false}for(c=true;++p<a;){var s=f[p],l=n[s],h=t[s];if(void 0!==ln||l!==h&&!r(l,h,e,u,o)){c=false;break}i||(i="constructor"==s)}return c&&!i&&(r=n.constructor,e=t.constructor,r!=e&&"constructor"in n&&"constructor"in t&&!(typeof r=="function"&&r instanceof r&&typeof e=="function"&&e instanceof e)&&(c=false)),
-c}function q(n){var t=n?n.length:ln;if(X(t)&&(Vn(n)||tn(n)||L(n))){n=String;for(var r=-1,e=Array(t);++r<t;)e[r]=n(r);t=e}else t=null;return t}function M(n){var t=n&&n.constructor;return n===(typeof t=="function"&&t.prototype||xn)}function z(n){return n?n[0]:ln}function C(n,t){return r(n,d(t),$n)}function G(n,t){return $n(n,typeof t=="function"?t:fn)}function J(n,t,r){return e(n,d(t),r,3>arguments.length,$n)}function P(n){return null==n?0:(n=Q(n)?n:un(n),n.length)}function U(n,t){var r;if(typeof t!="function")throw new TypeError("Expected a function");
-return n=Hn(n),function(){return 0<--n&&(r=t.apply(this,arguments)),1>=n&&(t=ln),r}}function V(n){var t;if(typeof n!="function")throw new TypeError("Expected a function");return t=Rn(t===ln?n.length-1:Hn(t),0),function(){for(var r=arguments,e=-1,u=Rn(r.length-t,0),o=Array(u);++e<u;)o[e]=r[t+e];for(u=Array(t+1),e=-1;++e<t;)u[e]=r[e];return u[t]=o,n.apply(this,u)}}function H(n,t){return n===t||n!==n&&t!==t}function K(n,t){return n>t}function L(n){return Z(n)&&Q(n)&&En.call(n,"callee")&&(!Fn.call(n,"callee")||"[object Arguments]"==kn.call(n));
-}function Q(n){return null!=n&&!(typeof n=="function"&&W(n))&&X(Mn(n))}function W(n){return n=Y(n)?kn.call(n):"","[object Function]"==n||"[object GeneratorFunction]"==n}function X(n){return typeof n=="number"&&n>-1&&0==n%1&&9007199254740991>=n}function Y(n){var t=typeof n;return!!n&&("object"==t||"function"==t)}function Z(n){return!!n&&typeof n=="object"}function nn(n){return typeof n=="number"||Z(n)&&"[object Number]"==kn.call(n)}function tn(n){return typeof n=="string"||!Vn(n)&&Z(n)&&"[object String]"==kn.call(n);
-}function rn(n,t){return t>n}function en(n){return typeof n=="string"?n:null==n?"":n+""}function un(n){var t=M(n);if(!t&&!Q(n))return Dn(Object(n));var r,e=q(n),u=!!e,e=e||[],o=e.length;for(r in n)!En.call(n,r)||u&&("length"==r||f(r,o))||t&&"constructor"==r||e.push(r);return e}function on(n){for(var t=-1,r=M(n),e=m(n),u=e.length,o=q(n),i=!!o,o=o||[],c=o.length;++t<u;){var a=e[t];i&&("length"==a||f(a,c))||"constructor"==a&&(r||!En.call(n,a))||o.push(a)}return o}function cn(n){return n?u(n,un(n)):[];
-}function fn(n){return n}function an(t,r,e){var u=un(r),o=g(r,u);null!=e||Y(r)&&(o.length||!u.length)||(e=r,r=t,t=this,o=g(r,un(r)));var i=Y(e)&&"chain"in e?e.chain:true,c=W(t);return $n(o,function(e){var u=r[e];t[e]=u,c&&(t.prototype[e]=function(){var r=this.__chain__;if(i||r){var e=t(this.__wrapped__);return(e.__actions__=k(this.__actions__)).push({func:u,args:arguments,thisArg:t}),e.__chain__=r,e}return u.apply(t,n([this.value()],arguments))})}),t}var ln,pn=/[&<>"'`]/g,sn=RegExp(pn.source),hn=/^(?:0|[1-9]\d*)$/,vn={
-"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","`":"&#96;"},yn={"function":true,object:true},_n=yn[typeof exports]&&exports&&!exports.nodeType?exports:null,gn=yn[typeof module]&&module&&!module.nodeType?module:null,bn=o(yn[typeof self]&&self),jn=o(yn[typeof window]&&window),dn=gn&&gn.exports===_n?_n:null,mn=o(yn[typeof this]&&this),wn=o(_n&&gn&&typeof global=="object"&&global)||jn!==(mn&&mn.window)&&jn||bn||mn||Function("return this")(),On=Array.prototype,xn=Object.prototype,En=xn.hasOwnProperty,An=0,kn=xn.toString,Nn=wn._,Sn=wn.f,Tn=Sn?Sn.g:ln,Fn=xn.propertyIsEnumerable,Bn=wn.isFinite,Dn=Object.keys,Rn=Math.max,In=function(){
-function n(){}return function(t){if(Y(t)){n.prototype=t;var r=new n;n.prototype=ln}return r||{}}}(),$n=function(n,t){return function(r,e){if(null==r)return r;if(!Q(r))return n(r,e);for(var u=r.length,o=t?u:-1,i=Object(r);(t?o--:++o<u)&&false!==e(i[o],o,i););return r}}(_),qn=function(n){return function(t,r,e){var u=-1,o=Object(t);e=e(t);for(var i=e.length;i--;){var c=e[n?i:++u];if(false===r(o[c],c,o))break}return t}}();Tn&&!Fn.call({valueOf:1},"valueOf")&&(m=function(n){n=Tn(n);for(var t,r=[];!(t=n.next()).done;)r.push(t.value);
-return r});var Mn=E("length"),zn=V(function(t,r){y(r);var e=Vn(t)?t:[Object(t)];return n(k(e),cn)}),Cn=V(function(n,t,r){var e=typeof t=="function";return w(n,function(n){var u=e?t:n[t];return null==u?u:u.apply(n,r)})}),Gn=Date.now,Jn=V(function(n,t,r){return D(n,t,r)}),Pn=V(function(n,t){return s(n,1,t)}),Un=V(function(n,t,r){return s(n,Kn(t)||0,r)}),Vn=Array.isArray,Hn=Number,Kn=Number,Ln=F(function(n,t){T(t,un(t),n)}),Qn=F(function(n,t){T(t,on(t),n)}),Wn=F(function(n,t,r){T(t,on(t),n,r)}),Xn=V(function(n){
-return n.push(ln,p),Wn.apply(ln,n)}),Yn=V(function(n,t){return null==n?{}:x(n,y(t))}),Zn=d;l.prototype=In(a.prototype),l.prototype.constructor=l,a.assignIn=Qn,a.before=U,a.bind=Jn,a.chain=function(n){return n=a(n),n.__chain__=true,n},a.compact=function(n){return v(n,Boolean)},a.concat=zn,a.create=function(n,t){var r=In(n);return t?Ln(r,t):r},a.defaults=Xn,a.defer=Pn,a.delay=Un,a.filter=function(n,t){return v(n,d(t))},a.flatten=function(n){return n&&n.length?y(n):[]},a.flattenDeep=function(n){return n&&n.length?y(n,true):[];
-},a.invokeMap=Cn,a.iteratee=Zn,a.keys=un,a.map=function(n,t){return w(n,d(t))},a.mixin=an,a.negate=function(n){if(typeof n!="function")throw new TypeError("Expected a function");return function(){return!n.apply(this,arguments)}},a.once=function(n){return U(2,n)},a.pick=Yn,a.slice=function(n,t,r){return n&&n.length?A(n,t,r):[]},a.sortBy=function(n,t){var r=0;return t=d(t),w(w(n,function(n,e,u){return{c:n,b:r++,a:t(n,e,u)}}).sort(function(n,t){var r;n:{r=n.a;var e=t.a;if(r!==e){var u=null===r,o=r===ln,i=r===r,c=null===e,f=e===ln,a=e===e;
-if(r>e&&!c||!i||u&&!f&&a||o&&a){r=1;break n}if(e>r&&!u||!a||c&&!o&&i||f&&i){r=-1;break n}}r=0}return r||n.b-t.b}),E("c"))},a.tap=function(n,t){return t(n),n},a.thru=function(n,t){return t(n)},a.toArray=function(n){return Q(n)?n.length?k(n):[]:cn(n)},a.values=cn,a.each=G,a.extend=Qn,an(a,a),a.clone=function(n){return Y(n)?Vn(n)?k(n):T(n,un(n)):n},a.escape=function(n){return(n=en(n))&&sn.test(n)?n.replace(pn,i):n},a.every=function(n,t,r){return t=r?ln:t,h(n,d(t))},a.find=C,a.forEach=G,a.has=function(n,t){
-return null!=n&&En.call(n,t)},a.head=z,a.identity=fn,a.indexOf=function(n,t,r){var e=n?n.length:0;r=typeof r=="number"?0>r?Rn(e+r,0):r:0,r=(r||0)-1;for(var u=t===t;++r<e;){var o=n[r];if(u?o===t:o!==o)return r}return-1},a.isArguments=L,a.isArray=Vn,a.isBoolean=function(n){return true===n||false===n||Z(n)&&"[object Boolean]"==kn.call(n)},a.isDate=function(n){return Z(n)&&"[object Date]"==kn.call(n)},a.isEmpty=function(n){return!Z(n)||W(n.splice)?!P(n):!un(n).length},a.isEqual=function(n,t){return b(n,t)},
-a.isFinite=function(n){return typeof n=="number"&&Bn(n)},a.isFunction=W,a.isNaN=function(n){return nn(n)&&n!=+n},a.isNull=function(n){return null===n},a.isNumber=nn,a.isObject=Y,a.isRegExp=function(n){return Y(n)&&"[object RegExp]"==kn.call(n)},a.isString=tn,a.isUndefined=function(n){return n===ln},a.last=function(n){var t=n?n.length:0;return t?n[t-1]:ln},a.max=function(n){return n&&n.length?t(n,fn,K):ln},a.min=function(n){return n&&n.length?t(n,fn,rn):ln},a.noConflict=function(){return wn._=Nn,this;
-},a.noop=function(){},a.now=Gn,a.reduce=J,a.result=function(n,t,r){return t=null==n?ln:n[t],t===ln&&(t=r),W(t)?t.call(n):t},a.size=P,a.some=function(n,t,r){return t=r?ln:t,N(n,d(t))},a.uniqueId=function(n){var t=++An;return en(n)+t},a.first=z,an(a,function(){var n={};return _(a,function(t,r){En.call(a.prototype,r)||(n[r]=t)}),n}(),{chain:false}),a.VERSION="4.0.0",$n("pop join replace reverse split push shift sort splice unshift".split(" "),function(n){var t=(/^(?:replace|split)$/.test(n)?String.prototype:On)[n],r=/^(?:push|sort|unshift)$/.test(n)?"tap":"thru",e=/^(?:pop|join|replace|shift)$/.test(n);
-a.prototype[n]=function(){var n=arguments;return e&&!this.__chain__?t.apply(this.value(),n):this[r](function(r){return t.apply(r,n)})}}),a.prototype.toJSON=a.prototype.valueOf=a.prototype.value=function(){return S(this.__wrapped__,this.__actions__)},(jn||bn||{})._=a,typeof define=="function"&&typeof define.amd=="object"&&define.amd? define(function(){return a}):_n&&gn?(dn&&((gn.exports=a)._=a),_n._=a):wn._=a}).call(this);
\ No newline at end of file
diff --git a/lib/vendor/mithril.js b/lib/vendor/mithril.js
deleted file mode 100644
index 55bef997f..000000000
--- a/lib/vendor/mithril.js
+++ /dev/null
@@ -1,2233 +0,0 @@
-;(function (global, factory) { // eslint-disable-line

-	"use strict"

-	/* eslint-disable no-undef */

-	var m = factory(global)

-	if (typeof module === "object" && module != null && module.exports) {

-		module.exports = m

-	} else if (typeof define === "function" && define.amd) {

-		define(function () { return m })

-	} else {

-		global.m = m

-	}

-	/* eslint-enable no-undef */

-})(typeof window !== "undefined" ? window : this, function (global, undefined) { // eslint-disable-line

-	"use strict"

-

-	m.version = function () {

-		return "v0.2.5"

-	}

-

-	var hasOwn = {}.hasOwnProperty

-	var type = {}.toString

-

-	function isFunction(object) {

-		return typeof object === "function"

-	}

-

-	function isObject(object) {

-		return type.call(object) === "[object Object]"

-	}

-

-	function isString(object) {

-		return type.call(object) === "[object String]"

-	}

-

-	var isArray = Array.isArray || function (object) {

-		return type.call(object) === "[object Array]"

-	}

-

-	function noop() {}

-

-	var voidElements = {

-		AREA: 1,

-		BASE: 1,

-		BR: 1,

-		COL: 1,

-		COMMAND: 1,

-		EMBED: 1,

-		HR: 1,

-		IMG: 1,

-		INPUT: 1,

-		KEYGEN: 1,

-		LINK: 1,

-		META: 1,

-		PARAM: 1,

-		SOURCE: 1,

-		TRACK: 1,

-		WBR: 1

-	}

-

-	// caching commonly used variables

-	var $document, $location, $requestAnimationFrame, $cancelAnimationFrame

-

-	// self invoking function needed because of the way mocks work

-	function initialize(mock) {

-		$document = mock.document

-		$location = mock.location

-		$cancelAnimationFrame = mock.cancelAnimationFrame || mock.clearTimeout

-		$requestAnimationFrame = mock.requestAnimationFrame || mock.setTimeout

-	}

-

-	// testing API

-	m.deps = function (mock) {

-		initialize(global = mock || window)

-		return global

-	}

-

-	m.deps(global)

-

-	/**

-	 * @typedef {String} Tag

-	 * A string that looks like -> div.classname#id[param=one][param2=two]

-	 * Which describes a DOM node

-	 */

-

-	function parseTagAttrs(cell, tag) {

-		var classes = []

-		var parser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[.+?\])/g

-		var match

-

-		while ((match = parser.exec(tag))) {

-			if (match[1] === "" && match[2]) {

-				cell.tag = match[2]

-			} else if (match[1] === "#") {

-				cell.attrs.id = match[2]

-			} else if (match[1] === ".") {

-				classes.push(match[2])

-			} else if (match[3][0] === "[") {

-				var pair = /\[(.+?)(?:=("|'|)(.*?)\2)?\]/.exec(match[3])

-				cell.attrs[pair[1]] = pair[3] || ""

-			}

-		}

-

-		return classes

-	}

-

-	function getVirtualChildren(args, hasAttrs) {

-		var children = hasAttrs ? args.slice(1) : args

-

-		if (children.length === 1 && isArray(children[0])) {

-			return children[0]

-		} else {

-			return children

-		}

-	}

-

-	function assignAttrs(target, attrs, classes) {

-		var classAttr = "class" in attrs ? "class" : "className"

-

-		for (var attrName in attrs) {

-			if (hasOwn.call(attrs, attrName)) {

-				if (attrName === classAttr &&

-						attrs[attrName] != null &&

-						attrs[attrName] !== "") {

-					classes.push(attrs[attrName])

-					// create key in correct iteration order

-					target[attrName] = ""

-				} else {

-					target[attrName] = attrs[attrName]

-				}

-			}

-		}

-

-		if (classes.length) target[classAttr] = classes.join(" ")

-	}

-

-	/**

-	 *

-	 * @param {Tag} The DOM node tag

-	 * @param {Object=[]} optional key-value pairs to be mapped to DOM attrs

-	 * @param {...mNode=[]} Zero or more Mithril child nodes. Can be an array,

-	 *                      or splat (optional)

-	 */

-	function m(tag, pairs) {

-		var args = []

-

-		for (var i = 1, length = arguments.length; i < length; i++) {

-			args[i - 1] = arguments[i]

-		}

-

-		if (isObject(tag)) return parameterize(tag, args)

-

-		if (!isString(tag)) {

-			throw new Error("selector in m(selector, attrs, children) should " +

-				"be a string")

-		}

-

-		var hasAttrs = pairs != null && isObject(pairs) &&

-			!("tag" in pairs || "view" in pairs || "subtree" in pairs)

-

-		var attrs = hasAttrs ? pairs : {}

-		var cell = {

-			tag: "div",

-			attrs: {},

-			children: getVirtualChildren(args, hasAttrs)

-		}

-

-		assignAttrs(cell.attrs, attrs, parseTagAttrs(cell, tag))

-		return cell

-	}

-

-	function forEach(list, f) {

-		for (var i = 0; i < list.length && !f(list[i], i++);) {

-			// function called in condition

-		}

-	}

-

-	function forKeys(list, f) {

-		forEach(list, function (attrs, i) {

-			return (attrs = attrs && attrs.attrs) &&

-				attrs.key != null &&

-				f(attrs, i)

-		})

-	}

-	// This function was causing deopts in Chrome.

-	function dataToString(data) {

-		// data.toString() might throw or return null if data is the return

-		// value of Console.log in some versions of Firefox (behavior depends on

-		// version)

-		try {

-			if (data != null && data.toString() != null) return data

-		} catch (e) {

-			// silently ignore errors

-		}

-		return ""

-	}

-

-	// This function was causing deopts in Chrome.

-	function injectTextNode(parentElement, first, index, data) {

-		try {

-			insertNode(parentElement, first, index)

-			first.nodeValue = data

-		} catch (e) {

-			// IE erroneously throws error when appending an empty text node

-			// after a null

-		}

-	}

-

-	function flatten(list) {

-		// recursively flatten array

-		for (var i = 0; i < list.length; i++) {

-			if (isArray(list[i])) {

-				list = list.concat.apply([], list)

-				// check current index again and flatten until there are no more

-				// nested arrays at that index

-				i--

-			}

-		}

-		return list

-	}

-

-	function insertNode(parentElement, node, index) {

-		parentElement.insertBefore(node,

-			parentElement.childNodes[index] || null)

-	}

-

-	var DELETION = 1

-	var INSERTION = 2

-	var MOVE = 3

-

-	function handleKeysDiffer(data, existing, cached, parentElement) {

-		forKeys(data, function (key, i) {

-			existing[key = key.key] = existing[key] ? {

-				action: MOVE,

-				index: i,

-				from: existing[key].index,

-				element: cached.nodes[existing[key].index] ||

-					$document.createElement("div")

-			} : {action: INSERTION, index: i}

-		})

-

-		var actions = []

-		for (var prop in existing) {

-			if (hasOwn.call(existing, prop)) {

-				actions.push(existing[prop])

-			}

-		}

-

-		var changes = actions.sort(sortChanges)

-		var newCached = new Array(cached.length)

-

-		newCached.nodes = cached.nodes.slice()

-

-		forEach(changes, function (change) {

-			var index = change.index

-			if (change.action === DELETION) {

-				clear(cached[index].nodes, cached[index])

-				newCached.splice(index, 1)

-			}

-			if (change.action === INSERTION) {

-				var dummy = $document.createElement("div")

-				dummy.key = data[index].attrs.key

-				insertNode(parentElement, dummy, index)

-				newCached.splice(index, 0, {

-					attrs: {key: data[index].attrs.key},

-					nodes: [dummy]

-				})

-				newCached.nodes[index] = dummy

-			}

-

-			if (change.action === MOVE) {

-				var changeElement = change.element

-				var maybeChanged = parentElement.childNodes[index]

-				if (maybeChanged !== changeElement && changeElement !== null) {

-					parentElement.insertBefore(changeElement,

-						maybeChanged || null)

-				}

-				newCached[index] = cached[change.from]

-				newCached.nodes[index] = changeElement

-			}

-		})

-

-		return newCached

-	}

-

-	function diffKeys(data, cached, existing, parentElement) {

-		var keysDiffer = data.length !== cached.length

-

-		if (!keysDiffer) {

-			forKeys(data, function (attrs, i) {

-				var cachedCell = cached[i]

-				return keysDiffer = cachedCell &&

-					cachedCell.attrs &&

-					cachedCell.attrs.key !== attrs.key

-			})

-		}

-

-		if (keysDiffer) {

-			return handleKeysDiffer(data, existing, cached, parentElement)

-		} else {

-			return cached

-		}

-	}

-

-	function diffArray(data, cached, nodes) {

-		// diff the array itself

-

-		// update the list of DOM nodes by collecting the nodes from each item

-		forEach(data, function (_, i) {

-			if (cached[i] != null) nodes.push.apply(nodes, cached[i].nodes)

-		})

-		// remove items from the end of the array if the new array is shorter

-		// than the old one. if errors ever happen here, the issue is most

-		// likely a bug in the construction of the `cached` data structure

-		// somewhere earlier in the program

-		forEach(cached.nodes, function (node, i) {

-			if (node.parentNode != null && nodes.indexOf(node) < 0) {

-				clear([node], [cached[i]])

-			}

-		})

-

-		if (data.length < cached.length) cached.length = data.length

-		cached.nodes = nodes

-	}

-

-	function buildArrayKeys(data) {

-		var guid = 0

-		forKeys(data, function () {

-			forEach(data, function (attrs) {

-				if ((attrs = attrs && attrs.attrs) && attrs.key == null) {

-					attrs.key = "__mithril__" + guid++

-				}

-			})

-			return 1

-		})

-	}

-

-	function isDifferentEnough(data, cached, dataAttrKeys) {

-		if (data.tag !== cached.tag) return true

-

-		if (dataAttrKeys.sort().join() !==

-				Object.keys(cached.attrs).sort().join()) {

-			return true

-		}

-

-		if (data.attrs.id !== cached.attrs.id) {

-			return true

-		}

-

-		if (data.attrs.key !== cached.attrs.key) {

-			return true

-		}

-

-		if (m.redraw.strategy() === "all") {

-			return !cached.configContext || cached.configContext.retain !== true

-		}

-

-		if (m.redraw.strategy() === "diff") {

-			return cached.configContext && cached.configContext.retain === false

-		}

-

-		return false

-	}

-

-	function maybeRecreateObject(data, cached, dataAttrKeys) {

-		// if an element is different enough from the one in cache, recreate it

-		if (isDifferentEnough(data, cached, dataAttrKeys)) {

-			if (cached.nodes.length) clear(cached.nodes)

-

-			if (cached.configContext &&

-					isFunction(cached.configContext.onunload)) {

-				cached.configContext.onunload()

-			}

-

-			if (cached.controllers) {

-				forEach(cached.controllers, function (controller) {

-					if (controller.onunload) {

-						controller.onunload({preventDefault: noop})

-					}

-				})

-			}

-		}

-	}

-

-	function getObjectNamespace(data, namespace) {

-		if (data.attrs.xmlns) return data.attrs.xmlns

-		if (data.tag === "svg") return "http://www.w3.org/2000/svg"

-		if (data.tag === "math") return "http://www.w3.org/1998/Math/MathML"

-		return namespace

-	}

-

-	var pendingRequests = 0

-	m.startComputation = function () { pendingRequests++ }

-	m.endComputation = function () {

-		if (pendingRequests > 1) {

-			pendingRequests--

-		} else {

-			pendingRequests = 0

-			m.redraw()

-		}

-	}

-

-	function unloadCachedControllers(cached, views, controllers) {

-		if (controllers.length) {

-			cached.views = views

-			cached.controllers = controllers

-			forEach(controllers, function (controller) {

-				if (controller.onunload && controller.onunload.$old) {

-					controller.onunload = controller.onunload.$old

-				}

-

-				if (pendingRequests && controller.onunload) {

-					var onunload = controller.onunload

-					controller.onunload = noop

-					controller.onunload.$old = onunload

-				}

-			})

-		}

-	}

-

-	function scheduleConfigsToBeCalled(configs, data, node, isNew, cached) {

-		// schedule configs to be called. They are called after `build` finishes

-		// running

-		if (isFunction(data.attrs.config)) {

-			var context = cached.configContext = cached.configContext || {}

-

-			// bind

-			configs.push(function () {

-				return data.attrs.config.call(data, node, !isNew, context,

-					cached)

-			})

-		}

-	}

-

-	function buildUpdatedNode(

-		cached,

-		data,

-		editable,

-		hasKeys,

-		namespace,

-		views,

-		configs,

-		controllers

-	) {

-		var node = cached.nodes[0]

-

-		if (hasKeys) {

-			setAttributes(node, data.tag, data.attrs, cached.attrs, namespace)

-		}

-

-		cached.children = build(

-			node,

-			data.tag,

-			undefined,

-			undefined,

-			data.children,

-			cached.children,

-			false,

-			0,

-			data.attrs.contenteditable ? node : editable,

-			namespace,

-			configs

-		)

-

-		cached.nodes.intact = true

-

-		if (controllers.length) {

-			cached.views = views

-			cached.controllers = controllers

-		}

-

-		return node

-	}

-

-	function handleNonexistentNodes(data, parentElement, index) {

-		var nodes

-		if (data.$trusted) {

-			nodes = injectHTML(parentElement, index, data)

-		} else {

-			nodes = [$document.createTextNode(data)]

-			if (!(parentElement.nodeName in voidElements)) {

-				insertNode(parentElement, nodes[0], index)

-			}

-		}

-

-		var cached

-

-		if (typeof data === "string" ||

-				typeof data === "number" ||

-				typeof data === "boolean") {

-			cached = new data.constructor(data)

-		} else {

-			cached = data

-		}

-

-		cached.nodes = nodes

-		return cached

-	}

-

-	function reattachNodes(

-		data,

-		cached,

-		parentElement,

-		editable,

-		index,

-		parentTag

-	) {

-		var nodes = cached.nodes

-		if (!editable || editable !== $document.activeElement) {

-			if (data.$trusted) {

-				clear(nodes, cached)

-				nodes = injectHTML(parentElement, index, data)

-			} else if (parentTag === "textarea") {

-				// <textarea> uses `value` instead of `nodeValue`.

-				parentElement.value = data

-			} else if (editable) {

-				// contenteditable nodes use `innerHTML` instead of `nodeValue`.

-				editable.innerHTML = data

-			} else {

-				// was a trusted string

-				if (nodes[0].nodeType === 1 || nodes.length > 1 ||

-						(nodes[0].nodeValue.trim &&

-							!nodes[0].nodeValue.trim())) {

-					clear(cached.nodes, cached)

-					nodes = [$document.createTextNode(data)]

-				}

-

-				injectTextNode(parentElement, nodes[0], index, data)

-			}

-		}

-		cached = new data.constructor(data)

-		cached.nodes = nodes

-		return cached

-	}

-

-	function handleTextNode(

-		cached,

-		data,

-		index,

-		parentElement,

-		shouldReattach,

-		editable,

-		parentTag

-	) {

-		if (!cached.nodes.length) {

-			return handleNonexistentNodes(data, parentElement, index)

-		} else if (cached.valueOf() !== data.valueOf() || shouldReattach) {

-			return reattachNodes(data, cached, parentElement, editable, index,

-				parentTag)

-		} else {

-			return (cached.nodes.intact = true, cached)

-		}

-	}

-

-	function getSubArrayCount(item) {

-		if (item.$trusted) {

-			// fix offset of next element if item was a trusted string w/ more

-			// than one html element

-			// the first clause in the regexp matches elements

-			// the second clause (after the pipe) matches text nodes

-			var match = item.match(/<[^\/]|\>\s*[^<]/g)

-			if (match != null) return match.length

-		} else if (isArray(item)) {

-			return item.length

-		}

-		return 1

-	}

-

-	function buildArray(

-		data,

-		cached,

-		parentElement,

-		index,

-		parentTag,

-		shouldReattach,

-		editable,

-		namespace,

-		configs

-	) {

-		data = flatten(data)

-		var nodes = []

-		var intact = cached.length === data.length

-		var subArrayCount = 0

-

-		// keys algorithm: sort elements without recreating them if keys are

-		// present

-		//

-		// 1) create a map of all existing keys, and mark all for deletion

-		// 2) add new keys to map and mark them for addition

-		// 3) if key exists in new list, change action from deletion to a move

-		// 4) for each key, handle its corresponding action as marked in

-		//    previous steps

-

-		var existing = {}

-		var shouldMaintainIdentities = false

-

-		forKeys(cached, function (attrs, i) {

-			shouldMaintainIdentities = true

-			existing[cached[i].attrs.key] = {action: DELETION, index: i}

-		})

-

-		buildArrayKeys(data)

-		if (shouldMaintainIdentities) {

-			cached = diffKeys(data, cached, existing, parentElement)

-		}

-		// end key algorithm

-

-		var cacheCount = 0

-		// faster explicitly written

-		for (var i = 0, len = data.length; i < len; i++) {

-			// diff each item in the array

-			var item = build(

-				parentElement,

-				parentTag,

-				cached,

-				index,

-				data[i],

-				cached[cacheCount],

-				shouldReattach,

-				index + subArrayCount || subArrayCount,

-				editable,

-				namespace,

-				configs)

-

-			if (item !== undefined) {

-				intact = intact && item.nodes.intact

-				subArrayCount += getSubArrayCount(item)

-				cached[cacheCount++] = item

-			}

-		}

-

-		if (!intact) diffArray(data, cached, nodes)

-		return cached

-	}

-

-	function makeCache(data, cached, index, parentIndex, parentCache) {

-		if (cached != null) {

-			if (type.call(cached) === type.call(data)) return cached

-

-			if (parentCache && parentCache.nodes) {

-				var offset = index - parentIndex

-				var end = offset + (isArray(data) ? data : cached.nodes).length

-				clear(

-					parentCache.nodes.slice(offset, end),

-					parentCache.slice(offset, end))

-			} else if (cached.nodes) {

-				clear(cached.nodes, cached)

-			}

-		}

-

-		cached = new data.constructor()

-		// if constructor creates a virtual dom element, use a blank object as

-		// the base cached node instead of copying the virtual el (#277)

-		if (cached.tag) cached = {}

-		cached.nodes = []

-		return cached

-	}

-

-	function constructNode(data, namespace) {

-		if (data.attrs.is) {

-			if (namespace == null) {

-				return $document.createElement(data.tag, data.attrs.is)

-			} else {

-				return $document.createElementNS(namespace, data.tag,

-					data.attrs.is)

-			}

-		} else if (namespace == null) {

-			return $document.createElement(data.tag)

-		} else {

-			return $document.createElementNS(namespace, data.tag)

-		}

-	}

-

-	function constructAttrs(data, node, namespace, hasKeys) {

-		if (hasKeys) {

-			return setAttributes(node, data.tag, data.attrs, {}, namespace)

-		} else {

-			return data.attrs

-		}

-	}

-

-	function constructChildren(

-		data,

-		node,

-		cached,

-		editable,

-		namespace,

-		configs

-	) {

-		if (data.children != null && data.children.length > 0) {

-			return build(

-				node,

-				data.tag,

-				undefined,

-				undefined,

-				data.children,

-				cached.children,

-				true,

-				0,

-				data.attrs.contenteditable ? node : editable,

-				namespace,

-				configs)

-		} else {

-			return data.children

-		}

-	}

-

-	function reconstructCached(

-		data,

-		attrs,

-		children,

-		node,

-		namespace,

-		views,

-		controllers

-	) {

-		var cached = {

-			tag: data.tag,

-			attrs: attrs,

-			children: children,

-			nodes: [node]

-		}

-

-		unloadCachedControllers(cached, views, controllers)

-

-		if (cached.children && !cached.children.nodes) {

-			cached.children.nodes = []

-		}

-

-		// edge case: setting value on <select> doesn't work before children

-		// exist, so set it again after children have been created

-		if (data.tag === "select" && "value" in data.attrs) {

-			setAttributes(node, data.tag, {value: data.attrs.value}, {},

-				namespace)

-		}

-

-		return cached

-	}

-

-	function getController(views, view, cachedControllers, controller) {

-		var controllerIndex

-

-		if (m.redraw.strategy() === "diff" && views) {

-			controllerIndex = views.indexOf(view)

-		} else {

-			controllerIndex = -1

-		}

-

-		if (controllerIndex > -1) {

-			return cachedControllers[controllerIndex]

-		} else if (isFunction(controller)) {

-			return new controller()

-		} else {

-			return {}

-		}

-	}

-

-	var unloaders = []

-

-	function updateLists(views, controllers, view, controller) {

-		if (controller.onunload != null &&

-				unloaders.map(function (u) { return u.handler })

-					.indexOf(controller.onunload) < 0) {

-			unloaders.push({

-				controller: controller,

-				handler: controller.onunload

-			})

-		}

-

-		views.push(view)

-		controllers.push(controller)

-	}

-

-	var forcing = false

-	function checkView(

-		data,

-		view,

-		cached,

-		cachedControllers,

-		controllers,

-		views

-	) {

-		var controller = getController(

-			cached.views,

-			view,

-			cachedControllers,

-			data.controller)

-

-		var key = data && data.attrs && data.attrs.key

-

-		if (pendingRequests === 0 ||

-				forcing ||

-				cachedControllers &&

-					cachedControllers.indexOf(controller) > -1) {

-			data = data.view(controller)

-		} else {

-			data = {tag: "placeholder"}

-		}

-

-		if (data.subtree === "retain") return data

-		data.attrs = data.attrs || {}

-		data.attrs.key = key

-		updateLists(views, controllers, view, controller)

-		return data

-	}

-

-	function markViews(data, cached, views, controllers) {

-		var cachedControllers = cached && cached.controllers

-

-		while (data.view != null) {

-			data = checkView(

-				data,

-				data.view.$original || data.view,

-				cached,

-				cachedControllers,

-				controllers,

-				views)

-		}

-

-		return data

-	}

-

-	function buildObject( // eslint-disable-line max-statements

-		data,

-		cached,

-		editable,

-		parentElement,

-		index,

-		shouldReattach,

-		namespace,

-		configs

-	) {

-		var views = []

-		var controllers = []

-

-		data = markViews(data, cached, views, controllers)

-

-		if (data.subtree === "retain") return cached

-

-		if (!data.tag && controllers.length) {

-			throw new Error("Component template must return a virtual " +

-				"element, not an array, string, etc.")

-		}

-

-		data.attrs = data.attrs || {}

-		cached.attrs = cached.attrs || {}

-

-		var dataAttrKeys = Object.keys(data.attrs)

-		var hasKeys = dataAttrKeys.length > ("key" in data.attrs ? 1 : 0)

-

-		maybeRecreateObject(data, cached, dataAttrKeys)

-

-		if (!isString(data.tag)) return

-

-		var isNew = cached.nodes.length === 0

-

-		namespace = getObjectNamespace(data, namespace)

-

-		var node

-		if (isNew) {

-			node = constructNode(data, namespace)

-			// set attributes first, then create children

-			var attrs = constructAttrs(data, node, namespace, hasKeys)

-

-			// add the node to its parent before attaching children to it

-			insertNode(parentElement, node, index)

-

-			var children = constructChildren(data, node, cached, editable,

-				namespace, configs)

-

-			cached = reconstructCached(

-				data,

-				attrs,

-				children,

-				node,

-				namespace,

-				views,

-				controllers)

-		} else {

-			node = buildUpdatedNode(

-				cached,

-				data,

-				editable,

-				hasKeys,

-				namespace,

-				views,

-				configs,

-				controllers)

-		}

-

-		if (!isNew && shouldReattach === true && node != null) {

-			insertNode(parentElement, node, index)

-		}

-

-		// The configs are called after `build` finishes running

-		scheduleConfigsToBeCalled(configs, data, node, isNew, cached)

-

-		return cached

-	}

-

-	function build(

-		parentElement,

-		parentTag,

-		parentCache,

-		parentIndex,

-		data,

-		cached,

-		shouldReattach,

-		index,

-		editable,

-		namespace,

-		configs

-	) {

-		/*

-		 * `build` is a recursive function that manages creation/diffing/removal

-		 * of DOM elements based on comparison between `data` and `cached` the

-		 * diff algorithm can be summarized as this:

-		 *

-		 * 1 - compare `data` and `cached`

-		 * 2 - if they are different, copy `data` to `cached` and update the DOM

-		 *     based on what the difference is

-		 * 3 - recursively apply this algorithm for every array and for the

-		 *     children of every virtual element

-		 *

-		 * The `cached` data structure is essentially the same as the previous

-		 * redraw's `data` data structure, with a few additions:

-		 * - `cached` always has a property called `nodes`, which is a list of

-		 *    DOM elements that correspond to the data represented by the

-		 *    respective virtual element

-		 * - in order to support attaching `nodes` as a property of `cached`,

-		 *    `cached` is *always* a non-primitive object, i.e. if the data was

-		 *    a string, then cached is a String instance. If data was `null` or

-		 *    `undefined`, cached is `new String("")`

-		 * - `cached also has a `configContext` property, which is the state

-		 *    storage object exposed by config(element, isInitialized, context)

-		 * - when `cached` is an Object, it represents a virtual element; when

-		 *    it's an Array, it represents a list of elements; when it's a

-		 *    String, Number or Boolean, it represents a text node

-		 *

-		 * `parentElement` is a DOM element used for W3C DOM API calls

-		 * `parentTag` is only used for handling a corner case for textarea

-		 * values

-		 * `parentCache` is used to remove nodes in some multi-node cases

-		 * `parentIndex` and `index` are used to figure out the offset of nodes.

-		 * They're artifacts from before arrays started being flattened and are

-		 * likely refactorable

-		 * `data` and `cached` are, respectively, the new and old nodes being

-		 * diffed

-		 * `shouldReattach` is a flag indicating whether a parent node was

-		 * recreated (if so, and if this node is reused, then this node must

-		 * reattach itself to the new parent)

-		 * `editable` is a flag that indicates whether an ancestor is

-		 * contenteditable

-		 * `namespace` indicates the closest HTML namespace as it cascades down

-		 * from an ancestor

-		 * `configs` is a list of config functions to run after the topmost

-		 * `build` call finishes running

-		 *

-		 * there's logic that relies on the assumption that null and undefined

-		 * data are equivalent to empty strings

-		 * - this prevents lifecycle surprises from procedural helpers that mix

-		 *   implicit and explicit return statements (e.g.

-		 *   function foo() {if (cond) return m("div")}

-		 * - it simplifies diffing code

-		 */

-		data = dataToString(data)

-		if (data.subtree === "retain") return cached

-		cached = makeCache(data, cached, index, parentIndex, parentCache)

-

-		if (isArray(data)) {

-			return buildArray(

-				data,

-				cached,

-				parentElement,

-				index,

-				parentTag,

-				shouldReattach,

-				editable,

-				namespace,

-				configs)

-		} else if (data != null && isObject(data)) {

-			return buildObject(

-				data,

-				cached,

-				editable,

-				parentElement,

-				index,

-				shouldReattach,

-				namespace,

-				configs)

-		} else if (!isFunction(data)) {

-			return handleTextNode(

-				cached,

-				data,

-				index,

-				parentElement,

-				shouldReattach,

-				editable,

-				parentTag)

-		} else {

-			return cached

-		}

-	}

-

-	function sortChanges(a, b) {

-		return a.action - b.action || a.index - b.index

-	}

-

-	function copyStyleAttrs(node, dataAttr, cachedAttr) {

-		for (var rule in dataAttr) {

-			if (hasOwn.call(dataAttr, rule)) {

-				if (cachedAttr == null || cachedAttr[rule] !== dataAttr[rule]) {

-					node.style[rule] = dataAttr[rule]

-				}

-			}

-		}

-

-		for (rule in cachedAttr) {

-			if (hasOwn.call(cachedAttr, rule)) {

-				if (!hasOwn.call(dataAttr, rule)) node.style[rule] = ""

-			}

-		}

-	}

-

-	var shouldUseSetAttribute = {

-		list: 1,

-		style: 1,

-		form: 1,

-		type: 1,

-		width: 1,

-		height: 1

-	}

-

-	function setSingleAttr(

-		node,

-		attrName,

-		dataAttr,

-		cachedAttr,

-		tag,

-		namespace

-	) {

-		if (attrName === "config" || attrName === "key") {

-			// `config` isn't a real attribute, so ignore it

-			return true

-		} else if (isFunction(dataAttr) && attrName.slice(0, 2) === "on") {

-			// hook event handlers to the auto-redrawing system

-			node[attrName] = autoredraw(dataAttr, node)

-		} else if (attrName === "style" && dataAttr != null &&

-				isObject(dataAttr)) {

-			// handle `style: {...}`

-			copyStyleAttrs(node, dataAttr, cachedAttr)

-		} else if (namespace != null) {

-			// handle SVG

-			if (attrName === "href") {

-				node.setAttributeNS("http://www.w3.org/1999/xlink",

-					"href", dataAttr)

-			} else {

-				node.setAttribute(

-					attrName === "className" ? "class" : attrName,

-					dataAttr)

-			}

-		} else if (attrName in node && !shouldUseSetAttribute[attrName]) {

-			// handle cases that are properties (but ignore cases where we

-			// should use setAttribute instead)

-			//

-			// - list and form are typically used as strings, but are DOM

-			//   element references in js

-			//

-			// - when using CSS selectors (e.g. `m("[style='']")`), style is

-			//   used as a string, but it's an object in js

-			//

-			// #348 don't set the value if not needed - otherwise, cursor

-			// placement breaks in Chrome

-			try {

-				if (tag !== "input" || node[attrName] !== dataAttr) {

-					node[attrName] = dataAttr

-				}

-			} catch (e) {

-				node.setAttribute(attrName, dataAttr)

-			}

-		}

-		else node.setAttribute(attrName, dataAttr)

-	}

-

-	function trySetAttr(

-		node,

-		attrName,

-		dataAttr,

-		cachedAttr,

-		cachedAttrs,

-		tag,

-		namespace

-	) {

-		if (!(attrName in cachedAttrs) || (cachedAttr !== dataAttr) || ($document.activeElement === node)) {

-			cachedAttrs[attrName] = dataAttr

-			try {

-				return setSingleAttr(

-					node,

-					attrName,

-					dataAttr,

-					cachedAttr,

-					tag,

-					namespace)

-			} catch (e) {

-				// swallow IE's invalid argument errors to mimic HTML's

-				// fallback-to-doing-nothing-on-invalid-attributes behavior

-				if (e.message.indexOf("Invalid argument") < 0) throw e

-			}

-		} else if (attrName === "value" && tag === "input" &&

-				node.value !== dataAttr) {

-			// #348 dataAttr may not be a string, so use loose comparison

-			node.value = dataAttr

-		}

-	}

-

-	function setAttributes(node, tag, dataAttrs, cachedAttrs, namespace) {

-		for (var attrName in dataAttrs) {

-			if (hasOwn.call(dataAttrs, attrName)) {

-				if (trySetAttr(

-						node,

-						attrName,

-						dataAttrs[attrName],

-						cachedAttrs[attrName],

-						cachedAttrs,

-						tag,

-						namespace)) {

-					continue

-				}

-			}

-		}

-		return cachedAttrs

-	}

-

-	function clear(nodes, cached) {

-		for (var i = nodes.length - 1; i > -1; i--) {

-			if (nodes[i] && nodes[i].parentNode) {

-				try {

-					nodes[i].parentNode.removeChild(nodes[i])

-				} catch (e) {

-					/* eslint-disable max-len */

-					// ignore if this fails due to order of events (see

-					// http://stackoverflow.com/questions/21926083/failed-to-execute-removechild-on-node)

-					/* eslint-enable max-len */

-				}

-				cached = [].concat(cached)

-				if (cached[i]) unload(cached[i])

-			}

-		}

-		// release memory if nodes is an array. This check should fail if nodes

-		// is a NodeList (see loop above)

-		if (nodes.length) {

-			nodes.length = 0

-		}

-	}

-

-	function unload(cached) {

-		if (cached.configContext && isFunction(cached.configContext.onunload)) {

-			cached.configContext.onunload()

-			cached.configContext.onunload = null

-		}

-		if (cached.controllers) {

-			forEach(cached.controllers, function (controller) {

-				if (isFunction(controller.onunload)) {

-					controller.onunload({preventDefault: noop})

-				}

-			})

-		}

-		if (cached.children) {

-			if (isArray(cached.children)) forEach(cached.children, unload)

-			else if (cached.children.tag) unload(cached.children)

-		}

-	}

-

-	function appendTextFragment(parentElement, data) {

-		try {

-			parentElement.appendChild(

-				$document.createRange().createContextualFragment(data))

-		} catch (e) {

-			parentElement.insertAdjacentHTML("beforeend", data)

-			replaceScriptNodes(parentElement)

-		}

-	}

-

-	// Replace script tags inside given DOM element with executable ones.

-	// Will also check children recursively and replace any found script

-	// tags in same manner.

-	function replaceScriptNodes(node) {

-		if (node.tagName === "SCRIPT") {

-			node.parentNode.replaceChild(buildExecutableNode(node), node)

-		} else {

-			var children = node.childNodes

-			if (children && children.length) {

-				for (var i = 0; i < children.length; i++) {

-					replaceScriptNodes(children[i])

-				}

-			}

-		}

-

-		return node

-	}

-

-	// Replace script element with one whose contents are executable.

-	function buildExecutableNode(node){

-		var scriptEl = document.createElement("script")

-		var attrs = node.attributes

-

-		for (var i = 0; i < attrs.length; i++) {

-			scriptEl.setAttribute(attrs[i].name, attrs[i].value)

-		}

-

-		scriptEl.text = node.innerHTML

-		return scriptEl

-	}

-

-	function injectHTML(parentElement, index, data) {

-		var nextSibling = parentElement.childNodes[index]

-		if (nextSibling) {

-			var isElement = nextSibling.nodeType !== 1

-			var placeholder = $document.createElement("span")

-			if (isElement) {

-				parentElement.insertBefore(placeholder, nextSibling || null)

-				placeholder.insertAdjacentHTML("beforebegin", data)

-				parentElement.removeChild(placeholder)

-			} else {

-				nextSibling.insertAdjacentHTML("beforebegin", data)

-			}

-		} else {

-			appendTextFragment(parentElement, data)

-		}

-

-		var nodes = []

-

-		while (parentElement.childNodes[index] !== nextSibling) {

-			nodes.push(parentElement.childNodes[index])

-			index++

-		}

-

-		return nodes

-	}

-

-	function autoredraw(callback, object) {

-		return function (e) {

-			e = e || event

-			m.redraw.strategy("diff")

-			m.startComputation()

-			try {

-				return callback.call(object, e)

-			} finally {

-				endFirstComputation()

-			}

-		}

-	}

-

-	var html

-	var documentNode = {

-		appendChild: function (node) {

-			if (html === undefined) html = $document.createElement("html")

-			if ($document.documentElement &&

-					$document.documentElement !== node) {

-				$document.replaceChild(node, $document.documentElement)

-			} else {

-				$document.appendChild(node)

-			}

-

-			this.childNodes = $document.childNodes

-		},

-

-		insertBefore: function (node) {

-			this.appendChild(node)

-		},

-

-		childNodes: []

-	}

-

-	var nodeCache = []

-	var cellCache = {}

-

-	m.render = function (root, cell, forceRecreation) {

-		if (!root) {

-			throw new Error("Ensure the DOM element being passed to " +

-				"m.route/m.mount/m.render is not undefined.")

-		}

-		var configs = []

-		var id = getCellCacheKey(root)

-		var isDocumentRoot = root === $document

-		var node

-

-		if (isDocumentRoot || root === $document.documentElement) {

-			node = documentNode

-		} else {

-			node = root

-		}

-

-		if (isDocumentRoot && cell.tag !== "html") {

-			cell = {tag: "html", attrs: {}, children: cell}

-		}

-

-		if (cellCache[id] === undefined) clear(node.childNodes)

-		if (forceRecreation === true) reset(root)

-

-		cellCache[id] = build(

-			node,

-			null,

-			undefined,

-			undefined,

-			cell,

-			cellCache[id],

-			false,

-			0,

-			null,

-			undefined,

-			configs)

-

-		forEach(configs, function (config) { config() })

-	}

-

-	function getCellCacheKey(element) {

-		var index = nodeCache.indexOf(element)

-		return index < 0 ? nodeCache.push(element) - 1 : index

-	}

-

-	m.trust = function (value) {

-		value = new String(value) // eslint-disable-line no-new-wrappers

-		value.$trusted = true

-		return value

-	}

-

-	function gettersetter(store) {

-		function prop() {

-			if (arguments.length) store = arguments[0]

-			return store

-		}

-

-		prop.toJSON = function () {

-			return store

-		}

-

-		return prop

-	}

-

-	m.prop = function (store) {

-		if ((store != null && (isObject(store) || isFunction(store)) || ((typeof Promise !== "undefined") && (store instanceof Promise))) &&

-				isFunction(store.then)) {

-			return propify(store)

-		}

-

-		return gettersetter(store)

-	}

-

-	var roots = []

-	var components = []

-	var controllers = []

-	var lastRedrawId = null

-	var lastRedrawCallTime = 0

-	var computePreRedrawHook = null

-	var computePostRedrawHook = null

-	var topComponent

-	var FRAME_BUDGET = 16 // 60 frames per second = 1 call per 16 ms

-

-	function parameterize(component, args) {

-		function controller() {

-			/* eslint-disable no-invalid-this */

-			return (component.controller || noop).apply(this, args) || this

-			/* eslint-enable no-invalid-this */

-		}

-

-		if (component.controller) {

-			controller.prototype = component.controller.prototype

-		}

-

-		function view(ctrl) {

-			var currentArgs = [ctrl].concat(args)

-			for (var i = 1; i < arguments.length; i++) {

-				currentArgs.push(arguments[i])

-			}

-

-			return component.view.apply(component, currentArgs)

-		}

-

-		view.$original = component.view

-		var output = {controller: controller, view: view}

-		if (args[0] && args[0].key != null) output.attrs = {key: args[0].key}

-		return output

-	}

-

-	m.component = function (component) {

-		var args = new Array(arguments.length - 1)

-

-		for (var i = 1; i < arguments.length; i++) {

-			args[i - 1] = arguments[i]

-		}

-

-		return parameterize(component, args)

-	}

-

-	function checkPrevented(component, root, index, isPrevented) {

-		if (!isPrevented) {

-			m.redraw.strategy("all")

-			m.startComputation()

-			roots[index] = root

-			var currentComponent

-

-			if (component) {

-				currentComponent = topComponent = component

-			} else {

-				currentComponent = topComponent = component = {controller: noop}

-			}

-

-			var controller = new (component.controller || noop)()

-

-			// controllers may call m.mount recursively (via m.route redirects,

-			// for example)

-			// this conditional ensures only the last recursive m.mount call is

-			// applied

-			if (currentComponent === topComponent) {

-				controllers[index] = controller

-				components[index] = component

-			}

-			endFirstComputation()

-			if (component === null) {

-				removeRootElement(root, index)

-			}

-			return controllers[index]

-		} else if (component == null) {

-			removeRootElement(root, index)

-		}

-	}

-

-	m.mount = m.module = function (root, component) {

-		if (!root) {

-			throw new Error("Please ensure the DOM element exists before " +

-				"rendering a template into it.")

-		}

-

-		var index = roots.indexOf(root)

-		if (index < 0) index = roots.length

-

-		var isPrevented = false

-		var event = {

-			preventDefault: function () {

-				isPrevented = true

-				computePreRedrawHook = computePostRedrawHook = null

-			}

-		}

-

-		forEach(unloaders, function (unloader) {

-			unloader.handler.call(unloader.controller, event)

-			unloader.controller.onunload = null

-		})

-

-		if (isPrevented) {

-			forEach(unloaders, function (unloader) {

-				unloader.controller.onunload = unloader.handler

-			})

-		} else {

-			unloaders = []

-		}

-

-		if (controllers[index] && isFunction(controllers[index].onunload)) {

-			controllers[index].onunload(event)

-		}

-

-		return checkPrevented(component, root, index, isPrevented)

-	}

-

-	function removeRootElement(root, index) {

-		roots.splice(index, 1)

-		controllers.splice(index, 1)

-		components.splice(index, 1)

-		reset(root)

-		nodeCache.splice(getCellCacheKey(root), 1)

-	}

-

-	var redrawing = false

-	m.redraw = function (force) {

-		if (redrawing) return

-		redrawing = true

-		if (force) forcing = true

-

-		try {

-			// lastRedrawId is a positive number if a second redraw is requested

-			// before the next animation frame

-			// lastRedrawId is null if it's the first redraw and not an event

-			// handler

-			if (lastRedrawId && !force) {

-				// when setTimeout: only reschedule redraw if time between now

-				// and previous redraw is bigger than a frame, otherwise keep

-				// currently scheduled timeout

-				// when rAF: always reschedule redraw

-				if ($requestAnimationFrame === global.requestAnimationFrame ||

-						new Date() - lastRedrawCallTime > FRAME_BUDGET) {

-					if (lastRedrawId > 0) $cancelAnimationFrame(lastRedrawId)

-					lastRedrawId = $requestAnimationFrame(redraw, FRAME_BUDGET)

-				}

-			} else {

-				redraw()

-				lastRedrawId = $requestAnimationFrame(function () {

-					lastRedrawId = null

-				}, FRAME_BUDGET)

-			}

-		} finally {

-			redrawing = forcing = false

-		}

-	}

-

-	m.redraw.strategy = m.prop()

-	function redraw() {

-		if (computePreRedrawHook) {

-			computePreRedrawHook()

-			computePreRedrawHook = null

-		}

-		forEach(roots, function (root, i) {

-			var component = components[i]

-			if (controllers[i]) {

-				var args = [controllers[i]]

-				m.render(root,

-					component.view ? component.view(controllers[i], args) : "")

-			}

-		})

-		// after rendering within a routed context, we need to scroll back to

-		// the top, and fetch the document title for history.pushState

-		if (computePostRedrawHook) {

-			computePostRedrawHook()

-			computePostRedrawHook = null

-		}

-		lastRedrawId = null

-		lastRedrawCallTime = new Date()

-		m.redraw.strategy("diff")

-	}

-

-	function endFirstComputation() {

-		if (m.redraw.strategy() === "none") {

-			pendingRequests--

-			m.redraw.strategy("diff")

-		} else {

-			m.endComputation()

-		}

-	}

-

-	m.withAttr = function (prop, withAttrCallback, callbackThis) {

-		return function (e) {

-			e = e || window.event

-			/* eslint-disable no-invalid-this */

-			var currentTarget = e.currentTarget || this

-			var _this = callbackThis || this

-			/* eslint-enable no-invalid-this */

-			var target = prop in currentTarget ?

-				currentTarget[prop] :

-				currentTarget.getAttribute(prop)

-			withAttrCallback.call(_this, target)

-		}

-	}

-

-	// routing

-	var modes = {pathname: "", hash: "#", search: "?"}

-	var redirect = noop

-	var isDefaultRoute = false

-	var routeParams, currentRoute

-

-	m.route = function (root, arg1, arg2, vdom) { // eslint-disable-line

-		// m.route()

-		if (arguments.length === 0) return currentRoute

-		// m.route(el, defaultRoute, routes)

-		if (arguments.length === 3 && isString(arg1)) {

-			redirect = function (source) {

-				var path = currentRoute = normalizeRoute(source)

-				if (!routeByValue(root, arg2, path)) {

-					if (isDefaultRoute) {

-						throw new Error("Ensure the default route matches " +

-							"one of the routes defined in m.route")

-					}

-

-					isDefaultRoute = true

-					m.route(arg1, true)

-					isDefaultRoute = false

-				}

-			}

-

-			var listener = m.route.mode === "hash" ?

-				"onhashchange" :

-				"onpopstate"

-

-			global[listener] = function () {

-				var path = $location[m.route.mode]

-				if (m.route.mode === "pathname") path += $location.search

-				if (currentRoute !== normalizeRoute(path)) redirect(path)

-			}

-

-			computePreRedrawHook = setScroll

-			global[listener]()

-

-			return

-		}

-

-		// config: m.route

-		if (root.addEventListener || root.attachEvent) {

-			var base = m.route.mode !== "pathname" ? $location.pathname : ""

-			root.href = base + modes[m.route.mode] + vdom.attrs.href

-			if (root.addEventListener) {

-				root.removeEventListener("click", routeUnobtrusive)

-				root.addEventListener("click", routeUnobtrusive)

-			} else {

-				root.detachEvent("onclick", routeUnobtrusive)

-				root.attachEvent("onclick", routeUnobtrusive)

-			}

-

-			return

-		}

-		// m.route(route, params, shouldReplaceHistoryEntry)

-		if (isString(root)) {

-			var oldRoute = currentRoute

-			currentRoute = root

-

-			var args = arg1 || {}

-			var queryIndex = currentRoute.indexOf("?")

-			var params

-

-			if (queryIndex > -1) {

-				params = parseQueryString(currentRoute.slice(queryIndex + 1))

-			} else {

-				params = {}

-			}

-

-			for (var i in args) {

-				if (hasOwn.call(args, i)) {

-					params[i] = args[i]

-				}

-			}

-

-			var querystring = buildQueryString(params)

-			var currentPath

-

-			if (queryIndex > -1) {

-				currentPath = currentRoute.slice(0, queryIndex)

-			} else {

-				currentPath = currentRoute

-			}

-

-			if (querystring) {

-				currentRoute = currentPath +

-					(currentPath.indexOf("?") === -1 ? "?" : "&") +

-					querystring

-			}

-

-			var replaceHistory =

-				(arguments.length === 3 ? arg2 : arg1) === true ||

-				oldRoute === root

-

-			if (global.history.pushState) {

-				var method = replaceHistory ? "replaceState" : "pushState"

-				computePreRedrawHook = setScroll

-				computePostRedrawHook = function () {

-					try {

-						global.history[method](null, $document.title,

-							modes[m.route.mode] + currentRoute)

-					} catch (err) {

-						// In the event of a pushState or replaceState failure,

-						// fallback to a standard redirect. This is specifically

-						// to address a Safari security error when attempting to

-						// call pushState more than 100 times.

-						$location[m.route.mode] = currentRoute

-					}

-				}

-				redirect(modes[m.route.mode] + currentRoute)

-			} else {

-				$location[m.route.mode] = currentRoute

-				redirect(modes[m.route.mode] + currentRoute)

-			}

-		}

-	}

-

-	m.route.param = function (key) {

-		if (!routeParams) {

-			throw new Error("You must call m.route(element, defaultRoute, " +

-				"routes) before calling m.route.param()")

-		}

-

-		if (!key) {

-			return routeParams

-		}

-

-		return routeParams[key]

-	}

-

-	m.route.mode = "search"

-

-	function normalizeRoute(route) {

-		return route.slice(modes[m.route.mode].length)

-	}

-

-	function routeByValue(root, router, path) {

-		routeParams = {}

-

-		var queryStart = path.indexOf("?")

-		if (queryStart !== -1) {

-			routeParams = parseQueryString(

-				path.substr(queryStart + 1, path.length))

-			path = path.substr(0, queryStart)

-		}

-

-		// Get all routes and check if there's

-		// an exact match for the current path

-		var keys = Object.keys(router)

-		var index = keys.indexOf(path)

-

-		if (index !== -1){

-			m.mount(root, router[keys [index]])

-			return true

-		}

-

-		for (var route in router) {

-			if (hasOwn.call(router, route)) {

-				if (route === path) {

-					m.mount(root, router[route])

-					return true

-				}

-

-				var matcher = new RegExp("^" + route

-					.replace(/:[^\/]+?\.{3}/g, "(.*?)")

-					.replace(/:[^\/]+/g, "([^\\/]+)") + "\/?$")

-

-				if (matcher.test(path)) {

-					/* eslint-disable no-loop-func */

-					path.replace(matcher, function () {

-						var keys = route.match(/:[^\/]+/g) || []

-						var values = [].slice.call(arguments, 1, -2)

-						forEach(keys, function (key, i) {

-							routeParams[key.replace(/:|\./g, "")] =

-								decodeURIComponent(values[i])

-						})

-						m.mount(root, router[route])

-					})

-					/* eslint-enable no-loop-func */

-					return true

-				}

-			}

-		}

-	}

-

-	function routeUnobtrusive(e) {

-		e = e || event

-		if (e.ctrlKey || e.metaKey || e.shiftKey || e.which === 2) return

-

-		if (e.preventDefault) {

-			e.preventDefault()

-		} else {

-			e.returnValue = false

-		}

-

-		var currentTarget = e.currentTarget || e.srcElement

-		var args

-

-		if (m.route.mode === "pathname" && currentTarget.search) {

-			args = parseQueryString(currentTarget.search.slice(1))

-		} else {

-			args = {}

-		}

-

-		while (currentTarget && !/a/i.test(currentTarget.nodeName)) {

-			currentTarget = currentTarget.parentNode

-		}

-

-		// clear pendingRequests because we want an immediate route change

-		pendingRequests = 0

-		m.route(currentTarget[m.route.mode]

-			.slice(modes[m.route.mode].length), args)

-	}

-

-	function setScroll() {

-		if (m.route.mode !== "hash" && $location.hash) {

-			$location.hash = $location.hash

-		} else {

-			global.scrollTo(0, 0)

-		}

-	}

-

-	function buildQueryString(object, prefix) {

-		var duplicates = {}

-		var str = []

-

-		for (var prop in object) {

-			if (hasOwn.call(object, prop)) {

-				var key = prefix ? prefix + "[" + prop + "]" : prop

-				var value = object[prop]

-

-				if (value === null) {

-					str.push(encodeURIComponent(key))

-				} else if (isObject(value)) {

-					str.push(buildQueryString(value, key))

-				} else if (isArray(value)) {

-					var keys = []

-					duplicates[key] = duplicates[key] || {}

-					/* eslint-disable no-loop-func */

-					forEach(value, function (item) {

-						/* eslint-enable no-loop-func */

-						if (!duplicates[key][item]) {

-							duplicates[key][item] = true

-							keys.push(encodeURIComponent(key) + "=" +

-								encodeURIComponent(item))

-						}

-					})

-					str.push(keys.join("&"))

-				} else if (value !== undefined) {

-					str.push(encodeURIComponent(key) + "=" +

-						encodeURIComponent(value))

-				}

-			}

-		}

-

-		return str.join("&")

-	}

-

-	function parseQueryString(str) {

-		if (str === "" || str == null) return {}

-		if (str.charAt(0) === "?") str = str.slice(1)

-

-		var pairs = str.split("&")

-		var params = {}

-

-		forEach(pairs, function (string) {

-			var pair = string.split("=")

-			var key = decodeURIComponent(pair[0])

-			var value = pair.length === 2 ? decodeURIComponent(pair[1]) : null

-			if (params[key] != null) {

-				if (!isArray(params[key])) params[key] = [params[key]]

-				params[key].push(value)

-			}

-			else params[key] = value

-		})

-

-		return params

-	}

-

-	m.route.buildQueryString = buildQueryString

-	m.route.parseQueryString = parseQueryString

-

-	function reset(root) {

-		var cacheKey = getCellCacheKey(root)

-		clear(root.childNodes, cellCache[cacheKey])

-		cellCache[cacheKey] = undefined

-	}

-

-	m.deferred = function () {

-		var deferred = new Deferred()

-		deferred.promise = propify(deferred.promise)

-		return deferred

-	}

-

-	function propify(promise, initialValue) {

-		var prop = m.prop(initialValue)

-		promise.then(prop)

-		prop.then = function (resolve, reject) {

-			return propify(promise.then(resolve, reject), initialValue)

-		}

-

-		prop.catch = prop.then.bind(null, null)

-		return prop

-	}

-	// Promiz.mithril.js | Zolmeister | MIT

-	// a modified version of Promiz.js, which does not conform to Promises/A+

-	// for two reasons:

-	//

-	// 1) `then` callbacks are called synchronously (because setTimeout is too

-	//    slow, and the setImmediate polyfill is too big

-	//

-	// 2) throwing subclasses of Error cause the error to be bubbled up instead

-	//    of triggering rejection (because the spec does not account for the

-	//    important use case of default browser error handling, i.e. message w/

-	//    line number)

-

-	var RESOLVING = 1

-	var REJECTING = 2

-	var RESOLVED = 3

-	var REJECTED = 4

-

-	function Deferred(onSuccess, onFailure) {

-		var self = this

-		var state = 0

-		var promiseValue = 0

-		var next = []

-

-		self.promise = {}

-

-		self.resolve = function (value) {

-			if (!state) {

-				promiseValue = value

-				state = RESOLVING

-

-				fire()

-			}

-

-			return self

-		}

-

-		self.reject = function (value) {

-			if (!state) {

-				promiseValue = value

-				state = REJECTING

-

-				fire()

-			}

-

-			return self

-		}

-

-		self.promise.then = function (onSuccess, onFailure) {

-			var deferred = new Deferred(onSuccess, onFailure)

-

-			if (state === RESOLVED) {

-				deferred.resolve(promiseValue)

-			} else if (state === REJECTED) {

-				deferred.reject(promiseValue)

-			} else {

-				next.push(deferred)

-			}

-

-			return deferred.promise

-		}

-

-		function finish(type) {

-			state = type || REJECTED

-			next.map(function (deferred) {

-				if (state === RESOLVED) {

-					deferred.resolve(promiseValue)

-				} else {

-					deferred.reject(promiseValue)

-				}

-			})

-		}

-

-		function thennable(then, success, failure, notThennable) {

-			if (((promiseValue != null && isObject(promiseValue)) ||

-					isFunction(promiseValue)) && isFunction(then)) {

-				try {

-					// count protects against abuse calls from spec checker

-					var count = 0

-					then.call(promiseValue, function (value) {

-						if (count++) return

-						promiseValue = value

-						success()

-					}, function (value) {

-						if (count++) return

-						promiseValue = value

-						failure()

-					})

-				} catch (e) {

-					m.deferred.onerror(e)

-					promiseValue = e

-					failure()

-				}

-			} else {

-				notThennable()

-			}

-		}

-

-		function fire() {

-			// check if it's a thenable

-			var then

-			try {

-				then = promiseValue && promiseValue.then

-			} catch (e) {

-				m.deferred.onerror(e)

-				promiseValue = e

-				state = REJECTING

-				return fire()

-			}

-

-			if (state === REJECTING) {

-				m.deferred.onerror(promiseValue)

-			}

-

-			thennable(then, function () {

-				state = RESOLVING

-				fire()

-			}, function () {

-				state = REJECTING

-				fire()

-			}, function () {

-				try {

-					if (state === RESOLVING && isFunction(onSuccess)) {

-						promiseValue = onSuccess(promiseValue)

-					} else if (state === REJECTING && isFunction(onFailure)) {

-						promiseValue = onFailure(promiseValue)

-						state = RESOLVING

-					}

-				} catch (e) {

-					m.deferred.onerror(e)

-					promiseValue = e

-					return finish()

-				}

-

-				if (promiseValue === self) {

-					promiseValue = TypeError()

-					finish()

-				} else {

-					thennable(then, function () {

-						finish(RESOLVED)

-					}, finish, function () {

-						finish(state === RESOLVING && RESOLVED)

-					})

-				}

-			})

-		}

-	}

-

-	m.deferred.onerror = function (e) {

-		if (type.call(e) === "[object Error]" &&

-				!/ Error/.test(e.constructor.toString())) {

-			pendingRequests = 0

-			throw e

-		}

-	}

-

-	m.sync = function (args) {

-		var deferred = m.deferred()

-		var outstanding = args.length

-		var results = []

-		var method = "resolve"

-

-		function synchronizer(pos, resolved) {

-			return function (value) {

-				results[pos] = value

-				if (!resolved) method = "reject"

-				if (--outstanding === 0) {

-					deferred.promise(results)

-					deferred[method](results)

-				}

-				return value

-			}

-		}

-

-		if (args.length > 0) {

-			forEach(args, function (arg, i) {

-				arg.then(synchronizer(i, true), synchronizer(i, false))

-			})

-		} else {

-			deferred.resolve([])

-		}

-

-		return deferred.promise

-	}

-

-	function identity(value) { return value }

-

-	function handleJsonp(options) {

-		var callbackKey = options.callbackName || "mithril_callback_" +

-			new Date().getTime() + "_" +

-			(Math.round(Math.random() * 1e16)).toString(36)

-

-		var script = $document.createElement("script")

-

-		global[callbackKey] = function (resp) {

-			script.parentNode.removeChild(script)

-			options.onload({

-				type: "load",

-				target: {

-					responseText: resp

-				}

-			})

-			global[callbackKey] = undefined

-		}

-

-		script.onerror = function () {

-			script.parentNode.removeChild(script)

-

-			options.onerror({

-				type: "error",

-				target: {

-					status: 500,

-					responseText: JSON.stringify({

-						error: "Error making jsonp request"

-					})

-				}

-			})

-			global[callbackKey] = undefined

-

-			return false

-		}

-

-		script.onload = function () {

-			return false

-		}

-

-		script.src = options.url +

-			(options.url.indexOf("?") > 0 ? "&" : "?") +

-			(options.callbackKey ? options.callbackKey : "callback") +

-			"=" + callbackKey +

-			"&" + buildQueryString(options.data || {})

-

-		$document.body.appendChild(script)

-	}

-

-	function createXhr(options) {

-		var xhr = new global.XMLHttpRequest()

-		xhr.open(options.method, options.url, true, options.user,

-			options.password)

-

-		xhr.onreadystatechange = function () {

-			if (xhr.readyState === 4) {

-				if (xhr.status >= 200 && xhr.status < 300) {

-					options.onload({type: "load", target: xhr})

-				} else {

-					options.onerror({type: "error", target: xhr})

-				}

-			}

-		}

-

-		if (options.serialize === JSON.stringify &&

-				options.data &&

-				options.method !== "GET") {

-			xhr.setRequestHeader("Content-Type",

-				"application/json; charset=utf-8")

-		}

-

-		if (options.deserialize === JSON.parse) {

-			xhr.setRequestHeader("Accept", "application/json, text/*")

-		}

-

-		if (isFunction(options.config)) {

-			var maybeXhr = options.config(xhr, options)

-			if (maybeXhr != null) xhr = maybeXhr

-		}

-

-		var data = options.method === "GET" || !options.data ? "" : options.data

-

-		if (data && !isString(data) && data.constructor !== global.FormData) {

-			throw new Error("Request data should be either be a string or " +

-				"FormData. Check the `serialize` option in `m.request`")

-		}

-

-		xhr.send(data)

-		return xhr

-	}

-

-	function ajax(options) {

-		if (options.dataType && options.dataType.toLowerCase() === "jsonp") {

-			return handleJsonp(options)

-		} else {

-			return createXhr(options)

-		}

-	}

-

-	function bindData(options, data, serialize) {

-		if (options.method === "GET" && options.dataType !== "jsonp") {

-			var prefix = options.url.indexOf("?") < 0 ? "?" : "&"

-			var querystring = buildQueryString(data)

-			options.url += (querystring ? prefix + querystring : "")

-		} else {

-			options.data = serialize(data)

-		}

-	}

-

-	function parameterizeUrl(url, data) {

-		if (data) {

-			url = url.replace(/:[a-z]\w+/gi, function (token){

-				var key = token.slice(1)

-				var value = data[key] || token

-				delete data[key]

-				return value

-			})

-		}

-		return url

-	}

-

-	m.request = function (options) {

-		if (options.background !== true) m.startComputation()

-		var deferred = new Deferred()

-		var isJSONP = options.dataType &&

-			options.dataType.toLowerCase() === "jsonp"

-

-		var serialize, deserialize, extract

-

-		if (isJSONP) {

-			serialize = options.serialize =

-			deserialize = options.deserialize = identity

-

-			extract = function (jsonp) { return jsonp.responseText }

-		} else {

-			serialize = options.serialize = options.serialize || JSON.stringify

-

-			deserialize = options.deserialize =

-				options.deserialize || JSON.parse

-			extract = options.extract || function (xhr) {

-				if (xhr.responseText.length || deserialize !== JSON.parse) {

-					return xhr.responseText

-				} else {

-					return null

-				}

-			}

-		}

-

-		options.method = (options.method || "GET").toUpperCase()

-		options.url = parameterizeUrl(options.url, options.data)

-		bindData(options, options.data, serialize)

-		options.onload = options.onerror = function (ev) {

-			try {

-				ev = ev || event

-				var response = deserialize(extract(ev.target, options))

-				if (ev.type === "load") {

-					if (options.unwrapSuccess) {

-						response = options.unwrapSuccess(response, ev.target)

-					}

-

-					if (isArray(response) && options.type) {

-						forEach(response, function (res, i) {

-							response[i] = new options.type(res)

-						})

-					} else if (options.type) {

-						response = new options.type(response)

-					}

-

-					deferred.resolve(response)

-				} else {

-					if (options.unwrapError) {

-						response = options.unwrapError(response, ev.target)

-					}

-

-					deferred.reject(response)

-				}

-			} catch (e) {

-				deferred.reject(e)

-				m.deferred.onerror(e)

-			} finally {

-				if (options.background !== true) m.endComputation()

-			}

-		}

-

-		ajax(options)

-		deferred.promise = propify(deferred.promise, options.initialValue)

-		return deferred.promise

-	}

-

-	return m

-}); // eslint-disable-line